Klasifikace obrazu TensorFlow: CNN (Convolutional Neural Network)

Obsah:

Anonim

Co je to konvoluční neurální síť?

Konvoluční neuronová síť, známá také jako convnets nebo CNN, je dobře známá metoda v aplikacích počítačového vidění. Tento typ architektury je dominantní pro rozpoznávání objektů z obrázku nebo videa.

V tomto výukovém programu se naučíte, jak vytvořit konvektor a jak použít TensorFlow k řešení ručně psané datové sady.

V tomto výukovém programu se naučíte

  • Konvoluční neurální síť
  • Architektura konvoluční neuronové sítě
  • Součásti Convnets
  • Trénujte CNN pomocí TensorFlow
  • Krok 1: Nahrajte datovou sadu
  • Krok 2: Vstupní vrstva
  • Krok 3: Konvoluční vrstva
  • Krok 4: Sdružování vrstvy
  • Krok 5: Druhá konvoluční vrstva a vrstva sdružování
  • Krok 6: Hustá vrstva
  • Krok 7: Logitová vrstva

Architektura konvoluční neuronové sítě

Přemýšlejte o Facebooku před několika lety, poté, co jste nahráli obrázek do svého profilu, jste byli požádáni, abyste ručně přidali jméno k obličeji na obrázku. V dnešní době Facebook používá konvektor k automatickému označení vašeho přítele na obrázku.

Konvoluční neurální síť není příliš těžké pochopit. Vstupní obraz je zpracován během fáze konvoluce a později mu byl přidělen štítek.

Typickou architekturu konvety lze shrnout na obrázku níže. Nejprve je obraz přenesen do sítě; tomuto se říká vstupní obraz. Poté vstupní obraz projde nekonečným počtem kroků; toto je konvoluční část sítě. A konečně může neurální síť předpovědět číslici na obrázku.

Obrázek se skládá z řady pixelů s výškou a šířkou. Obrázek ve stupních šedi má pouze jeden kanál, zatímco barevný obrázek má tři kanály (každý pro červený, zelený a modrý). Kanál je naskládán přes sebe. V tomto kurzu použijete obrázek ve stupních šedi pouze s jedním kanálem. Každý pixel má hodnotu od 0 do 255, aby odrážela intenzitu barvy. Například pixel rovný 0 bude zobrazovat bílou barvu, zatímco pixel s hodnotou blízkou 255 bude tmavší.

Pojďme se podívat na obrázek uložený v datové sadě MNIST. Obrázek níže ukazuje, jak reprezentovat obrázek levice ve formátu matice. Všimněte si, že původní matice byla standardizována na hodnotu mezi 0 a 1. U tmavších barev je hodnota v matici přibližně 0,9, zatímco bílé pixely mají hodnotu 0.

Konvoluční operace

Nejkritičtější součástí modelu je konvoluční vrstva. Tato část se zaměřuje na zmenšení velikosti obrazu pro rychlejší výpočet vah a zlepšení jeho zobecnění.

Během konvoluční části si síť zachovává základní vlastnosti obrazu a vylučuje irelevantní šum. Model se například učí, jak rozpoznat slona podle obrázku s horou v pozadí. Pokud používáte tradiční neuronovou síť, model přiřadí váhu všem pixelům, včetně pixelů z hory, což není podstatné a může síť uvést v omyl.

Místo toho bude konvoluční neuronová síť používat matematickou techniku ​​k extrakci pouze nejdůležitějších pixelů. Tato matematická operace se nazývá konvoluce. Tato technika umožňuje síti naučit se v každé vrstvě stále složitější funkce. Konvoluce rozděluje matici na malé kousky, aby se naučil nejdůležitější prvky v každém kousku.

Součásti Convnets

Konvety mají čtyři součásti

  1. Konvoluce
  2. Nelinearita (ReLU)
  3. Sdružování nebo dílčí vzorkování
  4. Klasifikace (plně připojená vrstva)
  • Konvoluce

Účelem konvoluce je lokálně extrahovat vlastnosti objektu na obrázku. To znamená, že se síť naučí specifické vzorce v obraze a bude schopna je rozpoznat všude na obrázku.

Konvoluce je elementární násobení. Koncept je snadno pochopitelný. Počítač naskenuje část obrazu, obvykle o rozměru 3x3, a vynásobí ji na filtr. Výstup násobení po prvcích se nazývá mapa funkcí. Tento krok se opakuje, dokud není naskenován celý obrázek. Všimněte si, že po konvoluci se velikost obrázku zmenší.

Níže je adresa URL, která v akci ukazuje, jak funguje konvoluce.

K dispozici je mnoho kanálů. Níže uvádíme některé kanály. Vidíte, že každý filtr má konkrétní účel. Všimněte si, na obrázku níže; jádro je synonymem filtru.

Zdroj

Aritmetika za konvolucí

Konvoluční fáze použije filtr na malé pole pixelů v obraze. Filtr se bude pohybovat podél vstupního obrazu s obecným tvarem 3x3 nebo 5x5. To znamená, že síť posune tato okna napříč celým vstupním obrazem a vypočítá konvoluci. Obrázek níže ukazuje, jak konvoluce funguje. Velikost patche je 3x3 a výstupní matice je výsledkem elementární operace mezi maticí obrazu a filtrem.

Zdroj

Všimněte si, že šířka a výška výstupu se může lišit od šířky a výšky vstupu. Stává se to kvůli efektu hranice.

Efekt hranice

Obrázek má mapu funkcí 5x5 a filtr 3x3. Ve středu je pouze jedno okno, kde může filtr zobrazovat mřížku 3x3. Mapa výstupních funkcí se zmenší o dvě dlaždice vedle dimenze 3x3.

Chcete-li získat stejný výstupní rozměr jako vstupní rozměr, musíte přidat výplň. Výplň se skládá z přidání správného počtu řádků a sloupců na každou stranu matice. Umožní konvoluci vycentrovat všechny vstupní dlaždice. Na obrázku níže má vstupní / výstupní matice stejný rozměr 5x5

Když definujete síť, související funkce jsou řízeny třemi parametry:

  1. Hloubka: Definuje počet filtrů, které se mají použít během konvoluce. V předchozím příkladu jste viděli hloubku 1, což znamená, že je použit pouze jeden filtr. Ve většině případů existuje více než jeden filtr. Obrázek níže ukazuje operace provedené v situaci se třemi filtry

  1. Krok: Definuje počet „skoků pixelu“ mezi dvěma řezy. Pokud je krok roven 1, okna se budou pohybovat s rozpětím jednoho pixelu. Pokud je krok roven dvěma, okna přeskočí o 2 pixely. Pokud zvýšíte krok, budete mít menší mapy funkcí.

Příklad kroku 1

Krok obrázku 2

  1. Nulová výplň: Výplň je operace přidání odpovídajícího počtu řádků a sloupců na každou stranu map vstupních funkcí. V tomto případě má výstup stejný rozměr jako vstup.
  2. Nelinearita (ReLU)

Na konci operace konvoluce je výstup podroben aktivační funkci umožňující nelinearitu. Obvyklou aktivační funkcí pro convnet je Relu. Všechny pixely se zápornou hodnotou budou nahrazeny nulou.

  • Max. Sdružování

Tento krok je snadno pochopitelný. Účelem sdružování je snížit rozměrnost vstupního obrazu. Kroky se provádějí za účelem snížení výpočetní složitosti operace. Snížením dimenzionality má síť nižší váhu pro výpočet, takže zabrání přeplnění.

V této fázi musíte definovat velikost a krok. Standardní způsob, jak shromáždit vstupní obraz, je použít maximální hodnotu mapy prvků. Podívejte se na obrázek níže. "Sdružování" zobrazí čtyři submatice mapy funkcí 4x4 a vrátí maximální hodnotu. Sdružování má maximální hodnotu pole 2x2 a poté přesune tato okna o dva pixely. Například první submatice je [3,1,3,2], sdružení vrátí maximum, což je 3.

Existuje další operace sdružování, například průměr.

Tato operace agresivně zmenšuje velikost mapy prvků

  • Plně spojené vrstvy

Poslední krok spočívá v budování tradiční umělé neuronové sítě, jak jste to udělali v předchozím tutoriálu. Spojíte všechny neurony z předchozí vrstvy do další vrstvy. Pomocí funkce aktivace softmax klasifikujete číslo na vstupním obrázku.

Shrnout:

Konvoluční neurální síť před vytvořením predikce kompiluje různé vrstvy. Neuronová síť má:

  • Konvoluční vrstva
  • Relu aktivační funkce
  • Sdružovací vrstva
  • Hustě spojená vrstva

Konvoluční vrstvy aplikují na podoblast obrazu různé filtry. Funkce aktivace Relu přidává nelinearitu a sdružující vrstvy snižují rozměrnost map prvků.

Všechny tyto vrstvy extrahují z obrazů základní informace. Nakonec se mapa funkcí přenese na primární plně spojenou vrstvu s funkcí softmax, aby se vytvořila předpověď.

Trénujte CNN pomocí TensorFlow

Nyní, když jste obeznámeni se stavebním blokem konvety, jste připraveni vytvořit jeden pomocí TensorFlow. Pro klasifikaci obrázků použijeme datovou sadu MNIST.

Příprava dat je stejná jako v předchozím kurzu. Můžete spustit kódy a přeskočit přímo na architekturu CNN.

Postupujete podle následujících kroků:

Krok 1: Nahrajte datovou sadu

Krok 2: Vstupní vrstva

Krok 3: Konvoluční vrstva

Krok 4: Sdružování vrstvy

Krok 5: Druhá konvoluční vrstva a vrstva sdružování

Krok 6: Hustá vrstva

Krok 7: Logitová vrstva

Krok 1: Nahrajte datovou sadu

Datová sada MNIST je k dispozici se scikitem, který se můžete naučit na této adrese URL. Stáhněte si ji a uložte do složky Ke stažení. Můžete jej nahrát pomocí fetch_mldata („originál MNIST“).

Vytvořte vlak / testovací sadu

Musíte rozdělit datovou sadu pomocí train_test_split

Škálování funkcí

Nakonec můžete funkci škálovat pomocí MinMaxScaler

import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_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 )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_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:]

Definujte CNN

CNN používá filtry na surovém pixelu obrázku, aby se dozvěděla podrobnosti vzoru ve srovnání s globálním vzorem pomocí tradiční neurální sítě. Chcete-li vytvořit CNN, musíte definovat:

  1. Konvoluční vrstva: Aplikujte na mapu prvků n počet filtrů. Po konvoluci musíte použít aktivační funkci Relu a přidat do sítě nelinearitu.
  2. Sdružování vrstvy: Dalším krokem po konvoluci je převzorkování funkce max. Účelem je snížit rozměrnost mapy prvků, aby se zabránilo nadměrnému vybavení a zlepšit rychlost výpočtu. Max pooling je konvenční technika, která rozděluje mapy prvků do podoblastí (obvykle s velikostí 2x2) a zachovává pouze maximální hodnoty.
  3. Plně spojené vrstvy: Všechny neurony z předchozích vrstev jsou spojeny s následujícími vrstvami. CNN klasifikuje štítek podle funkcí z konvolučních vrstev a redukuje se pomocí sdružené vrstvy.

Architektura CNN

  • Konvoluční vrstva: Aplikuje 14 filtrů 5x5 (extrakce podoblastí 5x5 pixelů), s aktivační funkcí ReLU
  • Pooling Layer: Provádí maximální sdružování s filtrem 2x2 a krokem 2 (což určuje, že se sdružené oblasti nepřekrývají)
  • Konvoluční vrstva: Aplikuje 36 filtrů 5x5 s aktivační funkcí ReLU
  • Layer Layer # 2: Opět provádí maximální sdružování s filtrem 2x2 a krokem 2
  • 1764 neuronů s mírou regularizace výpadku 0,4 (pravděpodobnost 0,4, že některý daný prvek bude během tréninku vynechán)
  • Hustá vrstva (vrstva logitů): 10 neuronů, jeden pro každou číslici cílové třídy (0-9).

K vytvoření CNN lze použít tři důležité moduly:

  • conv2d (). Konstruuje dvourozměrnou konvoluční vrstvu s počtem filtrů, velikostí jádra filtru, odsazením a aktivační funkcí jako argumenty.
  • max_pooling2d (). Vytvoří dvourozměrnou vrstvu sdružování pomocí algoritmu sdružování max.
  • hustý(). Vytvoří hustou vrstvu se skrytými vrstvami a jednotkami

Definujete funkci pro sestavení CNN. Podívejme se podrobně, jak před sestavením každého stavebního bloku zabalit vše dohromady do funkce.

Krok 2: Vstupní vrstva

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

Musíte definovat tenzor s tvarem dat. K tomu můžete použít modul tf.reshape. V tomto modulu musíte deklarovat tenzor, který má změnit tvar a tvar tenzoru. Prvním argumentem jsou vlastnosti dat, která jsou definována v argumentu funkce.

Obrázek má výšku, šířku a kanál. Datová sada MNIST je monochronický obrázek o velikosti 28x28. V argumentu tvar jsme nastavili velikost dávky na -1, aby převzala tvar prvků ["x"]. Výhodou je vyladění hyperparametrů velikosti dávky. Pokud je velikost dávky nastavena na 7, bude tenzor napájet 5 488 hodnot (28 * 28 * 7).

Step 3: Convolutional layer
# first Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)

První konvoluční vrstva má 14 filtrů s velikostí jádra 5x5 se stejnou výplní. Stejná výplň znamená, že výstupní tenzor i vstupní tenzor by měly mít stejnou výšku a šířku. Tensorflow přidá do řádků a sloupců nuly, aby byla zajištěna stejná velikost.

Používáte funkci aktivace Relu. Výstupní velikost bude [28, 28, 14].

Krok 4: Sdružování vrstvy

Dalším krokem po konvoluci je výpočet sdružování. Výpočet sdružování sníží rozměrnost dat. Můžete použít modul max_pooling2d o velikosti 2x2 a kroku 2. Jako vstup použijete předchozí vrstvu. Výstupní velikost bude [batch_size, 14, 14, 14]

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

Krok 5: Druhá konvoluční vrstva a vrstva sdružování

Druhá konvoluční vrstva má 32 filtrů s výstupní velikostí [batch_size, 14, 14, 32]. Sloučená vrstva má stejnou velikost jako dříve a výstupní tvar 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)

Krok 6: Hustá vrstva

Poté musíte definovat plně připojenou vrstvu. Před propojením s hustou vrstvou musí být mapa prvků zploštěna. Můžete použít přetvoření modulu o velikosti 7 * 7 * 36.

Hustá vrstva spojí 1764 neuronů. Přidáte funkci aktivace Relu. Kromě toho přidáte termín pro regulaci předčasného ukončení kurzu s rychlostí 0,3, což znamená, že 30 procent vah bude nastaveno na 0. Všimněte si, že k předčasnému ukončení dochází pouze během tréninkové fáze. Funkce cnn_model_fn má režim argumentu, který deklaruje, zda je třeba model vyškolit nebo vyhodnotit.

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)

Krok 7: Logitová vrstva

Nakonec můžete definovat poslední vrstvu s predikcí modelu. Výstupní tvar se rovná velikosti dávky a 10, celkovému počtu obrázků.

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

Můžete vytvořit slovník obsahující třídy a pravděpodobnost každé třídy. Modul tf.argmax () s vrací nejvyšší hodnotu, pokud logit vrstvy. Funkce softmax vrací pravděpodobnost každé třídy.

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

Chcete pouze vrátit predikci slovníku, když je režim nastaven na predikci. Tento kód přidáte, aby se předpovědi zobrazily

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

Dalším krokem je výpočet ztráty modelu. V posledním kurzu jste se dozvěděli, že ztrátovou funkcí pro model s více třídami je křížová entropie. Ztráta se snadno vypočítá pomocí následujícího kódu:

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

Posledním krokem je optimalizace modelu, to znamená nalezení nejlepších hodnot vah. K tomu použijete Optimalizátor sestupového přechodu s rychlostí učení 0,001. Cílem je minimalizovat ztrátu

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

Skončili jste s CNN. Chcete však zobrazit metriky výkonu během režimu hodnocení. Metriky výkonu pro model s více třídami jsou metriky přesnosti. Tensorflow je vybaven přesností modulu se dvěma argumenty, štítky a předpokládanými hodnotami.

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)

A je to. Vytvořili jste první CNN a jste připraveni zabalit vše do funkce, abyste ji mohli použít k trénování a vyhodnocení modelu.

def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = 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 Layerpool2_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 Layerlogits = 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 Lossloss = 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 modeeval_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)

Kroky níže jsou stejné jako předchozí výukové programy.

Nejprve definujete odhad pomocí modelu CNN.

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

Trénování CNN trvá mnohokrát, proto vytvoříte logovací hák, který uloží hodnoty vrstev softmax každých 50 iterací.

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

Jste připraveni odhadnout model. Nastavíte velikost dávky 100 a zamícháte data. Všimněte si, že jsme nastavili tréninkové kroky na 16 000, takže trénink může zabrat spoustu času. Buď trpělivý.

# Train the modeltrain_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])

Nyní, když je model trénovaný, můžete jej vyhodnotit a vytisknout výsledky

# Evaluate the model and print resultseval_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:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO: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}

Se současnou architekturou získáte přesnost 97%. Chcete-li zlepšit přesnost, můžete změnit architekturu, velikost dávky a počet iterací. Neuronová síť CNN si vedla mnohem lépe než ANN nebo logistická regrese. V tutoriálu o umělé neuronové síti jste měli přesnost 96%, což je nižší CNN. Výkony CNN jsou působivé s větší sadou obrázků , a to jak z hlediska výpočtu rychlosti, tak z hlediska přesnosti.

souhrn

Konvoluční neurální síť funguje velmi dobře při hodnocení obrazu. Tento typ architektury je dominantní pro rozpoznávání objektů z obrázku nebo videa.

Chcete-li vytvořit CNN, musíte postupovat podle šesti kroků:

Krok 1: Vstupní vrstva:

Tento krok přetváří data. Tvar se rovná druhé odmocnině počtu pixelů. Například pokud má obrázek 156 pixelů, pak má tvar 26x26. Musíte určit, zda má obrázek barvu nebo ne. Pokud ano, pak jste měli 3 do tvaru - 3 pro RGB-, jinak 1.

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

Krok 2: Konvoluční vrstva

Dále musíte vytvořit konvoluční vrstvy. Pomocí různých filtrů umožníte síti naučit se důležité funkce. Zadáte velikost jádra a množství filtrů.

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

Krok 3: Sdružování vrstvy

Ve třetím kroku přidáte vrstvu sdružování. Tato vrstva zmenšuje velikost vstupu. Dělá to tak, že vezme maximální hodnotu dílčí matice. Například pokud je podmatice [3,1,3,2], sdružení vrátí maximum, což je 3.

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

Krok 4: Přidejte vrstvu pro převod a vrstvu sdružování

V tomto kroku můžete přidat tolik, kolik chcete, vrstvy konverzace a sdružování vrstev. Google používá architekturu s více než 20 konverzními vrstvami.

Krok 5: Hustá vrstva

Krok 5 zplošťuje předchozí a vytvoří plně spojené vrstvy. V tomto kroku můžete použít různé aktivační funkce a přidat efekt odpadnutí.

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)

Krok 6: Logitová vrstva

Posledním krokem je předpověď.

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