Klasifikacija CNN slike u TensorFlowu s koracima i primjerima

Što je konvolucijska neuronska mreža?

Konvolucijska neuronska mreža, također poznat kao convnets ili CNN, dobro je poznata metoda u aplikacijama računalnog vida. To je klasa dubokih neuronskih mreža koje se koriste za analizu vizualnih slika. Ova vrsta arhitekture je dominantna za prepoznavanje objekata sa slike ili videa. Koristi se u aplikacijama kao što su prepoznavanje slika ili videa, obrada neuralnog jezika itd.

Archistruktura konvolucijske neuronske mreže

Sjetite se Facebooka prije nekoliko godina, nakon što ste prenijeli sliku na svoj profil, od vas se tražilo da ručno dodate ime licu na slici. Danas Facebook koristi convnet za automatsko označavanje vašeg prijatelja na slici.

Konvolucijska neuronska mreža za klasifikaciju slika nije teško razumjeti. Ulazna slika se obrađuje tijekom faze konvolucije i kasnije joj se pripisuje oznaka.

Tipična arhitektura convneta može se sažeti na slici ispod. Prije svega, slika se šalje na mrežu; to se zove ulazna slika. Zatim, ulazna slika prolazi kroz beskonačan broj koraka; ovo je konvolucijski dio mreže. Konačno, neuronska mreža može predvidjeti znamenku na slici.

Slika se sastoji od niza piksela visine i širine. Slika u sivim tonovima ima samo jedan kanal dok slika u boji ima tri kanala (svaki za crvenu, zelenu i plavu). Kanali su naslagani jedan preko drugog. U ovom vodiču koristit ćete sliku u sivim tonovima sa samo jednim kanalom. Svaki piksel ima vrijednost od 0 do 255 koja odražava intenzitet boje. Na primjer, piksel jednak 0 pokazat će bijelu boju dok će piksel s vrijednošću blizu 255 biti tamniji.

Pogledajmo sliku pohranjenu u MNIST skup podataka. Slika ispod pokazuje kako prikazati sliku lijeve strane u matričnom formatu. Imajte na umu da je izvorna matrica standardizirana da bude između 0 i 1. Za tamniju boju vrijednost u matrici je oko 0.9 dok bijeli pikseli imaju vrijednost 0.

Konvolucijska operacija

Najkritičnija komponenta u modelu je konvolucijski sloj. Ovaj dio ima za cilj smanjiti veličinu slike za brže izračunavanje težina i poboljšati njezinu generalizaciju.

Tijekom konvolucijskog dijela, mreža zadržava bitne značajke slike i isključuje nebitan šum. Na primjer, model uči kako prepoznati slona na slici s planinom u pozadini. Ako koristite tradicionalnu neuronsku mrežu, model će dodijeliti težinu svim pikselima, uključujući one s planine, što nije bitno i može zavarati mrežu.

Umjesto toga, a Keras konvolucijska neuronska mreža koristit će matematičku tehniku ​​za objašnjenjetracsamo najrelevantnije piksele. Ova matematička operacija naziva se konvolucija. Ova tehnika omogućuje mreži da uči sve složenije značajke na svakom sloju. Konvolucija dijeli matricu na male dijelove kako bi naučila najbitnije elemente unutar svakog dijela.

Komponente konvolucijske neuronske mreže (ConvNet ili CNN)

Postoje četiri komponente Convneta

1. saziv
2. Nelinearnost (ReLU)
3. Pooling ili poduzorkovanje
4. Klasifikacija (potpuno povezani sloj)

saziv

Svrha konvolucije je objasnititraclokalno prepoznaje značajke objekta na slici. To znači da će mreža naučiti specifične uzorke unutar slike i moći će ih prepoznati svugdje na slici.

Konvolucija je množenje po elementima. Koncept je lako razumjeti. Računalo će skenirati dio slike, obično dimenzija 3×3 i umnožiti ga u filter. Izlaz množenja po elementima naziva se mapa značajki. Ovaj korak se ponavlja dok se ne skenira cijela slika. Imajte na umu da se nakon konvolucije veličina slike smanjuje.

Ispod se nalazi URL vidjeti u akciji kako konvolucija funkcionira.

Dostupni su brojni kanali. U nastavku smo naveli neke od kanala. Možete vidjeti da svaki filtar ima određenu svrhu. Napomena, na slici ispod; Kernel je sinonim za filter.

Aritmetika iza konvolucije

Konvolucijska faza primijenit će filtar na mali niz piksela unutar slike. Filtar će se pomicati duž ulazne slike s općim oblikom 3×3 ili 5×5. To znači da će mreža kliziti ovim prozorima preko cijele ulazne slike i izračunati konvoluciju. Slika ispod pokazuje kako radi konvolucija. Veličina zakrpe je 3×3, a izlazna matrica rezultat je elementarne operacije između matrice slike i filtra.

Primjećujete da se širina i visina izlaza mogu razlikovati od širine i visine ulaza. To se događa zbog efekta granice.

Efekt granice

Slika ima kartu značajki 5×5 i filtar 3×3. Postoji samo jedan prozor u sredini gdje filtar može prikazati mrežu 3×3. Izlazna karta značajki smanjit će se za dvije pločice zajedno s dimenzijom 3×3.

Da biste dobili istu izlaznu dimenziju kao ulaznu dimenziju, morate dodati ispunu. Ispuna se sastoji od dodavanja pravog broja redaka i stupaca sa svake strane matrice. To će omogućiti da konvolucija centrira svaku ulaznu pločicu. Na slici ispod, ulazno/izlazna matrica ima istu dimenziju 5×5

Kada definirate mrežu, konvolvirane značajke kontroliraju tri parametra:

1. Dubina: Definira broj filtara koji se primjenjuju tijekom konvolucije. U prethodnom primjeru vidjeli ste dubinu 1, što znači da se koristi samo jedan filtar. U većini slučajeva postoji više od jednog filtera. Donja slika prikazuje operacije izvedene u situaciji s tri filtera

2. Korak: Definira broj "skoka piksela" između dva dijela. Ako je korak jednak 1, prozori će se pomicati s rasponom piksela od jedan. Ako je korak jednak dva, prozori će skočiti za 2 piksela. Ako povećate korak, imat ćete manje mape značajki.

Primjer koraka 1

korak 2

3. Nulta podstava: Ispuna je operacija dodavanja odgovarajućeg broja redaka i stupaca sa svake strane karte ulaznih značajki. U ovom slučaju, izlaz ima istu dimenziju kao i ulaz.

Nelinearnost (ReLU)

Na kraju operacije konvolucije, izlaz podliježe aktivacijskoj funkciji kako bi se omogućila nelinearnost. Uobičajena funkcija aktivacije za convnet je Relu. Svi pikseli s negativnom vrijednošću bit će zamijenjeni nulom.

Pooling OperaANJE

Ovaj je korak lako razumjeti. Svrha udruživanja je smanjiti dimenzionalnost ulazne slike. Koraci se rade kako bi se smanjila računalna složenost operacije. Smanjenjem dimenzionalnosti, mreža ima manje težine za izračunavanje, tako da sprječava prekomjerno prilagođavanje.

U ovoj fazi potrebno je definirati veličinu i korak. Standardni način skupljanja ulazne slike je korištenje maksimalne vrijednosti karte značajki. Pogledajte sliku ispod. "Udruživanje" će prikazati četiri podmatrice karte značajki 4×4 i vratiti maksimalnu vrijednost. Skupljanje uzima maksimalnu vrijednost niza 2×2 i zatim pomiče ove prozore za dva piksela. Na primjer, prva podmatrica je [3,1,3,2], udruživanje će vratiti maksimum, koji je 3.

Postoji još jedna operacija udruživanja kao što je srednja vrijednost.

Ova operacija agresivno smanjuje veličinu mape značajki

Potpuno povezani slojevi

Posljednji korak sastoji se od izgradnje tradicionalnog umjetna neuronska mreža kao što ste učinili u prethodnom vodiču. Povezujete sve neurone iz prethodnog sloja sa sljedećim slojem. Koristite softmax aktivacijsku funkciju za klasificiranje broja na ulaznoj slici.

Rekapitulacija:

TensorFlow Convolutional Neural network kompilira različite slojeve prije predviđanja. Neuronska mreža ima:

• Konvolucijski sloj
• Relu aktivacijska funkcija
• Pooling sloj
• Gusto povezani sloj

Konvolucijski slojevi primjenjuju različite filtre na podregiju slike. Aktivacijska funkcija Relu dodaje nelinearnost, a slojevi udruživanja smanjuju dimenzionalnost mapa značajki.

Svi ovi slojevi extracbitne informacije sa slika. Na kraju, karta značajki se šalje primarnom potpuno povezanom sloju pomoću softmax funkcije za izradu predviđanja.

Uvježbajte CNN uz TensorFlow

Sada kada ste upoznati sa sastavnim elementom konvneta, spremni ste za izgradnju jednog TensorFlow. Koristit ćemo skup podataka MNIST za CNN klasifikaciju slika.

Priprema podataka je ista kao u prethodnom vodiču. Možete pokrenuti kodove i skočiti izravno na arhitekturu CNN-a.

Za klasifikaciju slika pomoću CNN-a slijedit ćete korake u nastavku:

Korak 1: Prenesite skup podataka

Korak 2: Ulazni sloj

Korak 3: Konvolucijski sloj

Korak 4: Pooling sloj

Korak 5: Drugi konvolucijski sloj i Pooling Sloj

Korak 6: Gusti sloj

Korak 7: Logit sloj

Korak 1: Prenesite skup podataka

MNIST skup podataka dostupan je uz scikit za učenje o tome URL. Preuzmite ga i pohranite u Preuzimanja. Možete ga učitati pomoću fetch_mldata('MNIST original').

Stvorite set vlakova/testiranja

Morate podijeliti skup podataka s train_test_split

Skalirajte značajke

Konačno, možete skalirati značajku s MinMaxScaler-om kao što je prikazano u klasifikaciji slika u nastavku koristeći TensorFlow CNN primjer.

import numpy as np
import tensorflow as tf
from sklearn.datasets import fetch_mldata

#Change USERNAME by the username of your machine
## Windows USER
mnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')
## Mac User
mnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')

print(mnist.data.shape)
print(mnist.target.shape)
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )
## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))
feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]
X_train_scaled.shape[1:]

Definirajte CNN

CNN koristi filtre na neobrađenom pikselu slike kako bi saznao detalje uzorka u usporedbi s globalnim uzorkom s tradicionalnom neuronskom mrežom. Da biste izgradili CNN, morate definirati:

1. Konvolucijski sloj: Primijenite n broj filtara na mapu značajki. Nakon konvolucije morate upotrijebiti Relu aktivacijsku funkciju za dodavanje nelinearnosti mreži.
2. Pooling sloj: Sljedeći korak nakon konvolucije je smanjenje uzorkovanja maks. Svrha je smanjiti dimenzionalnost mape značajki kako bi se spriječilo prekomjerno uklapanje i poboljšala brzina izračuna. Maksimalno udruživanje je konvencionalna tehnika koja dijeli karte značajki u podregije (obično veličine 2×2) i zadržava samo maksimalne vrijednosti.
3. Potpuno povezani slojevi: Svi neuroni iz prethodnih slojeva povezani su sa sljedećim slojevima. CNN će klasificirati oznaku prema značajkama iz konvolucijskih slojeva i reducirati sa slojem udruživanja.

CNN arhitektura

• Konvolucijski sloj: Primjenjuje 14 filtera veličine 5×5 (npr.trac(podregije veličine 5 × 5 piksela), s ReLU aktivacijskom funkcijom
• Pooling Sloj: Izvodi maksimalno udruživanje s filtrom 2×2 i korakom od 2 (što navodi da se objedinjena područja ne preklapaju)
• Konvolucijski sloj: primjenjuje 36 filtara 5×5, s ReLU aktivacijskom funkcijom
• Pooling Sloj #2: Opet, izvodi maksimalno udruživanje s filtrom 2×2 i korakom od 2
• 1,764 neurona, sa stopom regulacije ispadanja od 0.4 (vjerojatnost od 0.4 da će bilo koji element biti odbačen tijekom treninga)
• Gusti sloj (logički sloj): 10 neurona, po jedan za svaku ciljnu klasu znamenki (0–9).

Postoje tri važna modula koja se koriste za stvaranje CNN-a:

• conv2d(). Konstruira dvodimenzionalni konvolucijski sloj s brojem filtara, veličinom jezgre filtra, ispunom i aktivacijskom funkcijom kao argumentima.
• max_udruživanje2d(). Konstruira dvodimenzionalni sloj udruživanja pomoću algoritma maksimalnog udruživanja.
• gust(). Konstruira gusti sloj sa skrivenim slojevima i jedinicama

Definirat ćete funkciju za izgradnju CNN-a. Pogledajmo detaljno kako konstruirati svaki građevni blok prije nego što sve zajedno zamotamo u funkciju.

Korak 2: Ulazni sloj

def cnn_model_fn(features, labels, mode):
    input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Morate definirati tenzor s oblikom podataka. Za to možete koristiti modul tf.reshape. U ovom modulu trebate deklarirati tenzor koji želite preoblikovati i oblik tenzora. Prvi argument je značajka podataka, koja je definirana u argumentu funkcije.

Slika ima visinu, širinu i kanal. MNIST skup podataka je monokronična slika veličine 28×28. Postavljamo veličinu serije na -1 u argumentu oblika tako da poprima oblik značajki[“x”]. Prednost je podešavanje hiperparametara veličine serije. Ako je veličina serije postavljena na 7, tada će tenzor unijeti 5,488 vrijednosti (28*28*7).

Korak 3: Konvolucijski sloj

# first Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Prvi konvolucijski sloj ima 14 filtara s veličinom jezgre 5×5 s istim punjenjem. Isto punjenje znači da bi i izlazni i ulazni tenzor trebali imati istu visinu i širinu. Tensorflow će dodati nule u retke i stupce kako bi osigurao istu veličinu.

Koristite Relu aktivacijsku funkciju. Veličina izlaza bit će [28, 28, 14].

Korak 4: Pooling sloj

Sljedeći korak nakon konvolucije je izračun udruživanja. Izračun udruživanja će smanjiti dimenzionalnost podataka. Možete koristiti modul max_pooling2d s veličinom 2×2 i korakom 2. Prethodni sloj koristite kao ulaz. Izlazna veličina bit će [batch_size, 14, 14, 14]

# first Pooling Layer 
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Korak 5: Drugi konvolucijski sloj i Pooling Sloj

Drugi konvolucijski sloj ima 32 filtera, s izlaznom veličinom [batch_size, 14, 14, 32]. Sloj za udruživanje ima istu veličinu kao i prije, a izlazni oblik je [batch_size, 14, 14, 18].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Korak 6: Gusti sloj

Zatim trebate definirati potpuno povezani sloj. Karta značajki mora se izravnati prije povezivanja s gustim slojem. Možete koristiti preoblikovanje modula s veličinom 7*7*36.

Gusti sloj će povezivati ​​1764 neurona. Dodali ste Relu aktivacijsku funkciju. Osim toga, dodajete termin regularizacije ispadanja sa stopom od 0.3, što znači da će 30 posto težina biti postavljeno na 0. Imajte na umu da se ispadanje događa samo tijekom faze treninga. Funkcija cnn_model_fn ima način argumenta za deklariranje treba li se model obučiti ili procijeniti kao što je prikazano u donjem primjeru TensorFlow klasifikacije CNN slike.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Korak 7: Logit sloj

Konačno, u primjeru klasifikacije slike TensorFlow, možete definirati posljednji sloj s predviđanjem modela. Izlazni oblik jednak je veličini serije i 10, ukupnom broju slika.

# Logits Layer
logits = tf.layers.dense(inputs=dropout, units=10)

Možete stvoriti rječnik koji sadrži klase i vjerojatnost svake klase. Modul tf.argmax() s vraća najveću vrijednost ako logit slojevi. Funkcija softmax vraća vjerojatnost svake klase.

predictions = {				
	# Generate predictions				
    "classes": tf.argmax(input=logits, axis=1),				
    "probabilities": tf.nn.softmax(logits, name="softmax_tensor")  }			

Predviđanje rječnika želite vratiti samo kada je način rada postavljen na predviđanje. Ove kodove dodajete da biste prikazali predviđanja

if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

Sljedeći korak sastoji se od izračunavanja gubitka modela. U prošlom vodiču ste naučili da je funkcija gubitka za višeklasni model unakrsna entropija. Gubitak se lako izračunava pomoću sljedećeg koda:

# Calculate Loss (for both TRAIN and EVAL modes)
loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

Posljednji korak primjera TensorFlow CNN je optimizacija modela, odnosno pronalaženje najboljih vrijednosti težina. Za to koristite Gradient descent optimizer sa stopom učenja od 0.001. Cilj je minimizirati gubitak

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())

Završili ste s CNN-om. Međutim, želite prikazati metriku izvedbe tijekom načina evaluacije. Mjerilo izvedbe za višeklasni model je mjerilo točnosti. Tensorflow je opremljen modulom točnosti s dva argumenta, oznakama i predviđenim vrijednostima.

eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}
return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

To je to. Stvorili ste svoj prvi CNN i spremni ste sve zamotati u funkciju kako biste je upotrijebili za obuku i procjenu modela.

def cnn_model_fn(features, labels, mode):
  """Model function for CNN."""
  # Input Layer
  input_layer = tf.reshape(features["x"], [-1, 28, 28, 1])

  # Convolutional Layer
  conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=32,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

  # Pooling Layer
  pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

  # Convolutional Layer #2 and Pooling Layer
  conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
  pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

  # Dense Layer
  pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])
  dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
  dropout = tf.layers.dropout(
      inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)

  # Logits Layer
  logits = tf.layers.dense(inputs=dropout, units=10)

  predictions = {
      # Generate predictions (for PREDICT and EVAL mode)
      "classes": tf.argmax(input=logits, axis=1),
      "probabilities": tf.nn.softmax(logits, name="softmax_tensor")
  }

  if mode == tf.estimator.ModeKeys.PREDICT:
    return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)

  # Calculate Loss
  loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)

  # Configure the Training Op (for TRAIN mode)
  if mode == tf.estimator.ModeKeys.TRAIN:
    optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)
    train_op = optimizer.minimize(
        loss=loss,
        global_step=tf.train.get_global_step())
    return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)

  # Add evaluation metrics Evaluation mode
  eval_metric_ops = {
      "accuracy": tf.metrics.accuracy(
          labels=labels, predictions=predictions["classes"])}
  return tf.estimator.EstimatorSpec(
      mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)

Koraci u nastavku su isti kao i prethodni vodiči.

Prije svega, definirate procjenitelj s CNN modelom za klasifikaciju slika.

# Create the Estimator
mnist_classifier = tf.estimator.Estimator(
    model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")

CNN-u je potrebno mnogo vremena za treniranje, stoga stvarate kuku za bilježenje za pohranjivanje vrijednosti softmax slojeva svakih 50 ponavljanja.

# Set up logging for predictions
tensors_to_log = {"probabilities": "softmax_tensor"}
logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)

Spremni ste za procjenu modela. Postavljate veličinu serije od 100 i miješate podatke. Imajte na umu da smo postavili korake treninga od 16.000, može potrajati puno vremena za trening. Budi strpljiv.

# Train the model
train_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=100,
    num_epochs=None,
    shuffle=True)
mnist_classifier.train(
    input_fn=train_input_fn,
    steps=16000,
    hooks=[logging_hook])

Sada kada je model treniran, možete ga procijeniti i ispisati rezultate

# Evaluate the model and print results
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test,
    num_epochs=1,
    shuffle=False)
eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)
print(eval_results)

INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56
INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269
{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}

S trenutnom arhitekturom dobivate točnost od 97%. Možete promijeniti arhitekturu, veličinu serije i broj ponavljanja kako biste poboljšali točnost. CNN neuronska mreža pokazala se daleko boljom od ANN-a ili logističke regresije. U tutorialu o umjetnoj neuronskoj mreži imali ste točnost od 96%, što je niže od CNN-a. Nastupi CNN-a impresivni su većom slikom postaviti, kako u pogledu brzine računanja tako i točnosti.

Rezime

Konvolucijska neuronska mreža vrlo dobro radi za procjenu slike. Ova vrsta arhitekture je dominantna za prepoznavanje objekata sa slike ili videa.

Da biste izgradili TensorFlow CNN, trebate slijediti sedam koraka:

Korak 1: Prenesi skup podataka:

Skup podataka MNIST dostupan je uz scikit za učenje. Preuzmite ga i pohranite u Preuzimanja. Možete ga učitati pomoću fetch_mldata('MNIST original').

Korak 2: Ulazni sloj:

Ovaj korak preoblikuje podatke. Oblik je jednak kvadratnom korijenu broja piksela. Na primjer, ako slika ima 156 piksela, onda je oblik 26×26. Morate odrediti ima li slika boju ili ne. Ako da, tada ste imali 3 za oblik- 3 za RGB-, inače 1.

input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])

Korak 3: Konvolucijski sloj

Zatim trebate stvoriti konvolucijske slojeve. Primjenjujete različite filtre kako biste omogućili mreži da nauči važne značajke. Vi određujete veličinu kernela i količinu filtera.

conv1 = tf.layers.conv2d(
      inputs=input_layer,
      filters=14,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)

Korak 4: Pooling sloj

U trećem koraku dodajete sloj za udruživanje. Ovaj sloj smanjuje veličinu unosa. To čini uzimanjem maksimalne vrijednosti podmatrice a. Na primjer, ako je podmatrica [3,1,3,2], udruživanje će vratiti maksimum, koji je 3.

pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)

Korak 5: Dodajte konvolucijski sloj i Pooling Sloj

U ovom koraku možete dodati koliko god želite konvertacijskih i objedinjujućih slojeva. Google koristi arhitekturu s više od 20 konverzijskih slojeva.

Korak 6: Gusti sloj

Korak 6 poravnajte prethodni kako biste stvorili potpuno povezane slojeve. U ovom koraku možete koristiti različite funkcije aktivacije i dodati učinak ispadanja.

pool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])

dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)
dropout = tf.layers.dropout(
      inputs=dense, rate=0.3, training=mode == tf.estimator.ModeKeys.TRAIN)

Korak 7: Logit sloj

Posljednji korak je predviđanje.

logits = tf.layers.dense(inputs=dropout, units=10)