Klasifikace obrázků CNN v TensorFlow s kroky a příklady

Co je konvoluční neuronová síť?

Konvoluční neuronová síť, také známý jako convnets nebo CNN, je dobře známá metoda v aplikacích počítačového vidění. Je to třída hlubokých neuronových sítí, které se používají k analýze vizuálních snímků. Tento typ architektury je dominantní pro rozpoznání objektů z obrázku nebo videa. Používá se v aplikacích, jako je rozpoznávání obrazu nebo videa, zpracování neuronového jazyka atd.

Architecture konvoluční neuronové sítě

Vzpomeňte si na Facebook před několika lety, když jste nahráli obrázek na svůj profil, byli jste požádáni, abyste k obličeji na obrázku ručně přidali jméno. V dnešní době Facebook používá convnet k automatickému označení vašeho přítele na obrázku.

Konvoluční neuronová síť pro klasifikaci obrázků není příliš obtížné pochopit. Vstupní obraz je zpracován během fáze konvoluce a později je mu přiřazen štítek.

Typickou convnet architekturu lze shrnout na obrázku níže. Nejprve je do sítě odeslán obrázek; tomu se říká vstupní obrázek. Poté vstupní obraz prochází nekonečným počtem kroků; toto je konvoluční část sítě. Konečně, neuronová síť může předpovědět číslici na obrázku.

Obrázek se skládá z pole 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 tutoriálu použijete obrázek ve stupních šedi pouze s jedním kanálem. Každý pixel má hodnotu od 0 do 255, která odráží intenzitu barvy. Například pixel rovný 0 bude mít bílou barvu, zatímco pixel s hodnotou blízkou 255 bude tmavší.

Podívejme se na obrázek uložený v datový soubor MNIST. Obrázek níže ukazuje, jak znázornit obrázek vlevo v maticovém formátu. Všimněte si, že původní matice byla standardizována tak, aby byla mezi 0 a 1. Pro tmavší barvu je hodnota v matici přibližně 0.9, zatímco bílé pixely mají hodnotu 0.

Konvoluční provoz

Nejkritičtější součástí modelu je konvoluční vrstva. Tato část má za cíl zmenšit velikost obrázku pro rychlejší výpočty vah a zlepšit jeho zobecnění.

Během konvoluční části síť zachovává podstatné rysy obrazu a vylučuje irelevantní šum. Modelka se například učí, jak rozpoznat slona z 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ě těch z hory, což není podstatné a může to síť zmást.

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

Součásti konvoluční neuronové sítě (ConvNet nebo CNN)

Existují čtyři součásti Convnets

1. Konvoluce
2. Nelinearita (ReLU)
3. Pooling nebo dílčí vzorkování
4. Klasifikace (plně propojená vrstva)

Konvoluce

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

Konvoluce je elementární násobení. Tento koncept je snadno pochopitelný. Počítač naskenuje část obrázku, obvykle o rozměru 3×3 a znásobí jej na filtr. Výstup násobení po prvcích se nazývá mapa rysů. 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 uvedena adresa URL, abyste viděli v akci, jak konvoluce funguje.

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

Aritmetika za konvolucí

Konvoluční fáze použije filtr na malé pole pixelů v rámci obrázku. Filtr se bude pohybovat podél vstupního obrazu s obecným tvarem 3×3 nebo 5×5. To znamená, že síť posune tato okna přes celý vstupní obraz a vypočítá konvoluci. Obrázek níže ukazuje, jak konvoluce funguje. Velikost políčka je 3×3 a výstupní matice je výsledkem operace mezi obrazovou maticí a filtrem po jednotlivých prvcích.

Všimnete 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 hraničnímu efektu.

Hraniční efekt

Obrázek má mapu prvků 5×5 a filtr 3×3. Ve středu je pouze jedno okno, kde může filtr promítat mřížku 3×3. Výstupní mapa prvků se zmenší o dvě dlaždice spolu s rozměrem 3×3.

Chcete-li získat stejný výstupní rozměr jako vstupní rozměr, musíte přidat výplň. Výplň spočívá v přidání správného počtu řádků a sloupců na každé straně matice. To umožní, aby se konvoluce vešla do středu každé vstupní dlaždice. Na obrázku níže má vstupní/výstupní matice stejný rozměr 5×5

Když definujete síť, konvolvované 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

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

Příklad kroku 1

krok 2

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

Nelinearita (ReLU)

Na konci operace konvoluce je výstup podroben aktivační funkci, která umožňuje nelinearitu. Obvyklá aktivační funkce pro convnet je Relu. Všechny pixely se zápornou hodnotou budou nahrazeny nulou.

Pooling Operavá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 rozměrů má síť nižší výpočetní hmotnosti, takže zabraňuje nadměrnému přizpůsobení.

V této fázi musíte definovat velikost a krok. Standardním způsobem sdružování vstupního obrázku je použití maximální hodnoty mapy prvků. Podívejte se na obrázek níže. „Sdružování“ zobrazí čtyři podmatice mapy prvků 4×4 a vrátí maximální hodnotu. Sdružování má maximální hodnotu pole 2×2 a poté tato okna posouvá o dva pixely. Například první podmatice je [3,1,3,2], sdružování vrátí maximum, což je 3.

Existuje další operace sdružování, jako je střední hodnota.

Tato operace agresivně zmenšuje velikost mapy prvků

Plně propojené vrstvy

Posledním krokem je vybudování tradičního umělá neuronová síť jako jste to udělali v předchozím tutoriálu. Všechny neurony z předchozí vrstvy propojíte s vrstvou následující. Ke klasifikaci čísla na vstupním obrázku se používá aktivační funkce softmax.

Shrnout:

Konvoluční neuronová síť TensorFlow sestavuje různé vrstvy před provedením předpovědi. Neuronová síť má:

• Konvoluční vrstva
• Funkce aktivace Relu
• Pooling vrstva
• Hustě spojená vrstva

Konvoluční vrstvy aplikují různé filtry na dílčí oblast obrázku. Funkce aktivace Relu přidává nelinearitu a sdružovací vrstvy snižují dimenzionalitu map prvků.

Všechny tyto vrstvy extrahují podstatné informace z obrázků. Nakonec jsou mapy prvků přiváděny do primární plně propojené vrstvy s funkcí softmax, aby bylo možné provést předpověď.

Trénujte CNN pomocí TensorFlow

Nyní, když jste obeznámeni se stavebním kamenem convnets, jste připraveni jej vytvořit TensorFlow. Pro klasifikaci obrázků CNN použijeme datovou sadu MNIST.

Příprava dat je stejná jako v předchozím tutoriálu. Můžete spustit kódy a přejít přímo na architekturu CNN.

Pro klasifikaci obrázků pomocí CNN budete postupovat podle následujících kroků:

Krok 1: Nahrajte datovou sadu

Krok 2: Vstupní vrstva

Krok 3: Konvoluční vrstva

Krok 4: Pooling vrstva

Krok 5: Druhá konvoluční vrstva a Pooling Vrstva

Krok 6: Hustá vrstva

Krok 7: Logit Layer

Krok 1: Nahrajte datovou sadu

Datový soubor MNIST je k dispozici se scikit, kde se můžete naučit URL. Stáhněte si ji a uložte do složky Stažené soubory. Můžete jej nahrát pomocí fetch_mldata('MNIST original').

Vytvořte vlakovou/testovací soupravu

Musíte rozdělit datovou sadu pomocí train_test_split

Měřítko funkcí

Nakonec můžete škálovat prvek pomocí MinMaxScaler, jak je znázorněno na níže uvedené klasifikaci obrázku pomocí příkladu TensorFlow CNN.

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:]

Definujte CNN

CNN používá filtry na surovém pixelu obrázku, aby zjistila podrobnosti o vzoru ve srovnání s globálním vzorem s tradiční neuronovou sítí. Chcete-li vytvořit CNN, musíte definovat:

1. Konvoluční vrstva: Použijte n počet filtrů na mapu prvků. Po konvoluci musíte použít funkci aktivace Relu, abyste do sítě přidali nelinearitu.
2. Pooling vrstva: Dalším krokem po konvoluci je převzorkování objektu max. Účelem je snížit dimenzionalitu mapy prvků, aby se zabránilo nadměrnému přizpůsobení a zlepšila se rychlost výpočtu. Max sdružování je konvenční technika, která rozděluje mapy prvků do podoblastí (obvykle o velikosti 2×2) a zachovává pouze maximální hodnoty.
3. Plně propojené vrstvy: Všechny neurony z předchozích vrstev jsou spojeny s následujícími vrstvami. CNN klasifikuje štítek podle rysů z konvolučních vrstev a redukuje se sdružovací vrstvou.

Architektura CNN

• Konvoluční vrstva: Aplikuje 14 filtrů 5×5 (extrakce 5×5pixelových podoblastí) s funkcí aktivace ReLU
• Pooling Vrstva: Provádí maximální sdružování s filtrem 2×2 a krokem 2 (což určuje, že se sdružené oblasti nepřekrývají)
• Konvoluční vrstva: Aplikuje 36 filtrů 5×5 s funkcí aktivace ReLU
• Pooling Vrstva #2: Opět provádí maximální sdružování s filtrem 2×2 a krokem 2
• 1,764 0.4 neuronů s mírou regularizace výpadků 0.4 (pravděpodobnost XNUMX, že během tréninku vypadne jakýkoli daný prvek)
• Hustá vrstva (Logits Layer): 10 neuronů, jeden pro každou cílovou třídu číslic (0–9).

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

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

Definujete funkci pro sestavení CNN. Podívejme se podrobně na to, jak zkonstruovat každý stavební blok předtím, než vše zabalíte 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, že tenzor má být přeměněn a tvar tenzoru. Prvním argumentem jsou vlastnosti dat, které jsou definovány v argumentu funkce.

Obrázek má výšku, šířku a kanál. Datový soubor MNIST je monochronní obrázek o velikosti 28×28. Velikost dávky nastavíme v argumentu tvaru na -1, aby převzal tvar prvků[“x”]. Výhodou je, aby se hyperparametry velikosti dávky vyladily. Pokud je velikost dávky nastavena na 7, pak tenzor dodá 5,488 28 hodnot (28*7*XNUMX).

Krok 3: Konvoluční vrstva

# first Convolutional Layer
  conv1 = 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ů o velikosti jádra 5×5 se stejnou výplní. Stejná výplň znamená, že jak výstupní tenzor, tak vstupní tenzor by měly mít stejnou výšku a šířku. Tensorflow přidá nuly do řádků a sloupců, aby byla zajištěna stejná velikost.

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

Krok 4: Pooling vrstva

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 2×2 a kroku 2. Jako vstup použijete předchozí vrstvu. Výstupní velikost bude [velikost_dávky, 14, 14, 14]

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

Krok 5: Druhá konvoluční vrstva a Pooling Vrstva

Druhá konvoluční vrstva má 32 filtrů s výstupní velikostí [batch_size, 14, 14, 32]. Sdružovací vrstva má stejnou velikost jako předtím a výstupní tvar je [velikost_dávky, 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ě propojenou vrstvu. Mapa prvků musí být před spojením s hustou vrstvou vyrovnána. Můžete použít modul reshape o velikosti 7*7*36.

Hustá vrstva spojí 1764 neuronů. Přidáte funkci aktivace Relu. Kromě toho přidáte termín regularizace výpadku s mírou 0.3, což znamená, že 30 procent vah bude nastaveno na 0. Pamatujte, že k výpadku dochází pouze během tréninkové fáze. Funkce cnn_model_fn má režim argumentů, který deklaruje, zda je třeba model trénovat nebo vyhodnotit, jak je znázorněno v níže uvedeném příkladu klasifikace obrázků CNN TensorFlow.

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: Logit Layer

Nakonec v příkladu klasifikace obrázku TensorFlow 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 Layer
logits = 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 jsou 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")  }			

Předikci slovníku chcete vrátit pouze tehdy, když je režim nastaven na predikci. Přidáním těchto kódů se předpovědi zruší

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 minulém tutoriálu jste se naučili, že ztrátovou funkcí pro vícetřídní model 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 příkladu TensorFlow CNN je optimalizace modelu, tedy nalezení nejlepších hodnot vah. K tomu použijte Gradient sestupový optimalizátor s rychlostí učení 0.001. Cílem je minimalizovat ztráty

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

S CNN jste skončili. Chcete však zobrazit metriky výkonu během režimu hodnocení. Metrikou výkonu pro vícetřídní model je metrika 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 svou první CNN a jste připraveni vše zabalit do funkce, abyste ji mohli použít k trénování a vyhodnocování modelu.

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)

Níže uvedené kroky jsou stejné jako v předchozích výukových programech.

Nejprve definujete odhad pomocí modelu CNN pro klasifikaci snímků.

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

CNN se trénuje mnohokrát, proto si vytvoříte Logging hook pro uložení hodnot softmaxových vrstev každých 50 iterací.

# Set up logging for predictions
tensors_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 data zamícháte. Všimněte si, že jsme nastavili tréninkové kroky 16.000 XNUMX, trénink může zabrat spoustu času. Buď trpělivý.

# 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])

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

# 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}

Se současnou architekturou získáte přesnost 97 %. Pro zvýšení přesnosti můžete změnit architekturu, velikost dávky a počet iterací. Neuronová síť CNN fungovala 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ším obrazem sada, a to jak z hlediska rychlosti výpočtu, tak přesnosti.

Shrnutí

K vyhodnocení obrázku velmi dobře funguje konvoluční neuronová síť. Tento typ architektury je dominantní pro rozpoznání objektů z obrázku nebo videa.

Chcete-li vytvořit TensorFlow CNN, musíte provést sedm kroků:

Krok 1: Nahrát datovou sadu:

Datový soubor MNIST je k dispozici se scikit k učení. Stáhněte si ji a uložte do složky Stažené soubory. Můžete jej nahrát pomocí fetch_mldata('MNIST original').

Krok 2: Vstupní vrstva:

Tento krok změní tvar dat. Tvar se rovná druhé odmocnině počtu pixelů. Pokud má obrázek například 156 pixelů, pak je tvar 26×26. 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 3: Konvoluční vrstva

Dále musíte vytvořit konvoluční vrstvy. Aplikujete různé filtry, které umožní 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 4: Pooling vrstva

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

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

Krok 5: Přidat konvoluční vrstvu a Pooling Vrstva

V tomto kroku můžete přidat tolik vrstev, kolik chcete převádět a sdružovat vrstvy. Google používá architekturu s více než 20 vrstvami konv.

Krok 6: Hustá vrstva

Krok 6 vyrovná předchozí, aby se vytvořily 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 7: Logit Layer

Posledním krokem je předpověď.

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