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

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

Konvoluční neuronová síť, známá také jako convnets nebo CNN, je známá metoda v aplikacích počítačového vidění. Jedná se o třídu hlubokých neuronových sítí, které se používají k analýze vizuálních obrazů. Tento typ architektury je dominantní pro rozpoznávání objektů z obrázku nebo videa. Používá se v aplikacích, jako je rozpoznávání obrázků nebo videa, zpracování přirozeného jazyka a doporučovací systémy.

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 architekturu convnet lze shrnout na obrázku níže. Nejprve je do sítě odeslán obrázek; tomu se říká vstupní obrázek. Poté vstupní obrázek prochází řadou kroků; to je konvoluční část sítě. Nakonec neuronová síť dokáže předpovědět číslici na obrázku.

Obrázek se skládá z pole pixelů s určitou 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 červenou, zelenou a modrou). Kanály jsou naskládány 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 zobrazovat bílou barvu, zatímco pixel s hodnotou blízkou 255 bude tmavší.

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

Konvoluční provoz

Nejdůležitější součástí modelu je konvoluční vrstva. Tato část si klade za cíl zmenšit velikost obrazu pro rychlejší výpočty vah a zlepšit 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íť použije matematickou techniku ​​k vysvětlenítracpouze nejrelevantnější pixely. Tato matematická operace se nazývá konvoluce. Tato technika umožňuje síti učit se stále složitější prvky v každé vrstvě. Konvoluce rozděluje matici na malé části, aby se naučila nejdůležitější prvky v rámci každé části.

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

Konvertibilní síť má čtyři složky:

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

Konvoluce

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

Konvoluce je násobení po jednotlivých prvcích. Koncept je snadno pochopitelný. Počítač naskenuje část obrazu, obvykle o rozměru 3×3, a vynásobí ji filtrem. Výstup násobení po jednotlivých prvcích se nazývá mapa prvků. Tento krok se opakuje, dokud není naskenován celý obraz. Všimněte si, že po konvoluci se velikost obrazu zmenší.

Níže uvedený diagram ukazuje, jak je jedna část obrazu vynásobena filtrem, čímž vznikne jedna buňka mapy prvků.

Níže uvedená animace ukazuje stejnou konvoluci probíhající přes celý obrázek.

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

Aritmetika za konvolucí

Konvoluční fáze aplikuje filtr na malé pole pixelů v obrázku. Filtr se bude pohybovat podél vstupního obrazu s obecným tvarem 3×3 nebo 5×5. To znamená, že síť bude posouvat tato okna po celém vstupním obrazu a vypočítávat konvoluci. Níže uvedená animace ukazuje, jak konvoluce funguje. Velikost oblasti je 3×3 a výstupní matice je výsledkem operace po prvcích mezi obrazovou maticí a filtrem.

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ů o rozměrech 5×5 a filtr 3×3. Uprostřed je pouze jedno okno, kde filtr dokáže zobrazit mřížku 3×3. Výstupní mapa prvků se zmenší o dva dlaždice na každé ose, čímž zůstane rozměr 3×3.

Abyste dosáhli stejného výstupního rozměru jako vstupního, je třeba přidat odsazení. Odsazení spočívá v přidání správného počtu řádků a sloupců na každou stranu matice. To umožní konvoluci vycentrovat každou vstupní dlaždici. Na obrázku níže mají vstupní a výstupní matice stejný rozměr, 5×5.

Když definujete síť, konvolvované funkce jsou řízeny třemi parametry:

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 se používá pouze jeden filtr. Ve většině případů je filtrů více. Animace níže ukazuje operace provedené v situaci se třemi filtry.

Krok: Definuje počet „skoků pixelů“ mezi dvěma řezy. Pokud je krok roven 1, okno se bude pohybovat s rozpětím pixelu jedna. Pokud je krok roven dvěma, okno se bude pohybovat o 2 pixely. Pokud krok zvětšíte, budete mít menší mapy prvků. Dva níže uvedené diagramy porovnávají krok 1 s krokem 2.

Příklad kroku 1

krok 2

Doplnění nulou: Doplnění je operace přidání odpovídajícího počtu řádků a sloupců na každou stranu vstupních map prvků. V tomto případě má výstup stejnou dimenzi jako vstup.

Nelinearita (ReLU)

Na konci konvoluční operace je výstup podroben aktivační funkci, která umožňuje nelinearitu. Obvyklá aktivační funkce pro konvoluční síť 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 dimenzionalitu vstupního obrazu. Tyto kroky se provádějí za účelem snížení výpočetní složitosti operace. Zmenšením dimenzionality má síť k výpočtu méně vah, což zabraňuje přeplnění.

V této fázi je třeba definovat velikost a krok. Standardní způsob, jak sloučit vstupní obrázek, je použít maximální hodnotu mapy prvků. Podívejte se na obrázek níže. Sloučení prohlédne čtyři podmatice mapy prvků 4×4 a vrátí maximální hodnotu. Sloučení vezme maximální hodnotu pole 2×2 a poté toto okno posune o dva pixely. Například první podmatice je [3,1,3,2], takže sloučení vrátí maximum, které 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 před provedením predikce sestavuje různé vrstvy. Neuronová síť má:

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

Konvoluční vrstvy aplikují různé filtry na podoblast obrázku. Aktivační funkce ReLU přidává nelinearitu a sdružené vrstvy snižují dimenzionalitu map prvků.

Všechny tyto vrstvytracZákladní informace z obrázků. Nakonec jsou mapy prvků přeneseny do plně propojené vrstvy s funkcí softmax pro provedení predikce.

Trénujte CNN pomocí TensorFlow

Nyní, když jste obeznámeni se stavebními bloky sítě convnet, jste připraveni ji sestavit pomocí 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ů:

1. Krok 1: Nahrajte datovou sadu
2. Krok 2: Vstupní vrstva
3. Krok 3: Konvoluční vrstva
4. Krok 4: Pooling vrstva
5. Krok 5: Druhá konvoluční vrstva a Pooling Vrstva
6. Krok 6: Hustá vrstva
7. Krok 7: Logit Layer

Poznámka k verzi: Níže uvedené záznamy cílí na TensorFlow 1.x. V TensorFlow 2 již jmenný prostor tf.layers a tf.estimator.inputs.numpy_input_fn neexistují; ekvivalenty jsou tf.keras.layers.Conv2D, Max.Pooling2D, Dense a Dropout sestavené v tf.keras.Model a trénované pomocí model.fit(). Přečtěte si kroky pro mechaniku každé vrstvy a poté je namapujte na Keras API.

Krok 1: Nahrajte datovou sadu

Datová sada MNIST je k dispozici prostřednictvím scikit-learn. Stáhněte si ji prosím a uložte do složky Ke stažení. Můžete ji nahrát pomocí fetch_mldata('MNIST original').

Poznámka k verzi: Stránka mldata.org byla ukončena a funkce fetch_mldata() byla v souboru scikit-learn verze 0.22 odstraněna. V jakékoli aktuální instalaci načtěte stejné číslice pomocí fetch_openml místo toho se používá fetch_openml('mnist_784', version=1). Zbytek pipeline zůstává nezměněn.

Vytvořte vlakovou/testovací soupravu

Datovou sadu je potřeba rozdělit pomocí funkce train_test_split.

Měřítko funkcí

Nakonec můžete prvky škálovat pomocí MinMaxScaler, jak je znázorněno na níže uvedeném obrázku s použitím 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 nezpracovaných pixelech obrazu k učení detailních vzorů ve srovnání s globálními vzory naučenými tradiční neuronovou sítí. Pro konstrukci CNN je třeba definovat:

1. Konvoluční vrstva: Na mapu prvků aplikujte n filtrů. Po konvoluci je třeba k přidání nelinearity do sítě použít aktivační funkci ReLU.
2. Pooling vrstva: Dalším krokem po konvoluci je downvzorkování mapy příznaků. Účelem je snížit dimenzionalitu mapy příznaků, aby se zabránilo přeplnění a zvýšila se rychlost výpočtu. Max pooling je konvenční technika, která rozděluje mapy příznaků do podoblastí (obvykle o velikosti 2×2) a ponechá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 (např.trac(podoblasti o velikosti 5×5 pixelů) s aktivační funkcí 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. Pojďme se podrobně podívat, jak sestavit jednotlivé stavební bloky před zabalením.ping vše pohromadě ve funkci.

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á sada MNIST je monochromatický obrázek o velikosti 28×28. V argumentu tvaru nastavíme velikost dávky na -1, aby obrázek nabýval tvaru prvků [„x“]. Výhodou je, že velikost dávky je hyperparametr k ladění. Pokud je velikost dávky nastavena na 7, pak tenzor vrátí 5 488 hodnot (28*28*7).

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ů s velikostí jádra 5×5 se stejným odsazením. Stejné odsazení znamená, že výstupní i vstupní tenzor by měly mít stejnou výšku a šířku. TensorFlow přidá do řádků a sloupců nuly, aby zajistil stejnou velikost.

Používáte aktivační funkci ReLU. Výstupní velikost bude [28, 28, 14].

Krok 4: Pooling vrstva

Dalším krokem po konvoluci je výpočet sdružování dat (pooling). Výpočet sdružování dat sníží dimenzionalitu dat. Můžete použít modul max_pooling2d s velikostí 2×2 a krokem 2. Jako vstup použijete předchozí vrstvu. Výstupní velikost bude [batch_size, 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 aplikuje 36 filtrů, čímž dává výstupní velikost [batch_size, 14, 14, 36]. Vrstva sdružování používá stejné okno 2×2 a krok 2 jako dříve, takže každou prostorovou osu rozdělí na polovinu a výstupní tvar se stává [batch_size, 7, 7, 36].

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

Pak je třeba definovat plně propojenou vrstvu. Mapa prvků musí být před propojením s hustou vrstvou zploštěna. Můžete použít modul přetvoření o velikosti 7*7*36.

Hustá vrstva propojí 1 764 neuronů. Přidáte aktivační funkci ReLU. Kromě toho přidáte regularizační člen dropout s mírou 0.3, což znamená, že 30 procent aktivací bude nastaveno na 0. Všimněte si, že k dropoutu dochází pouze během trénovací fáze. Funkce cnn_model_fn má argument mode pro deklaraci, zda je třeba model trénovat nebo vyhodnocovat, jak je znázorněno v níže uvedeném příkladu klasifikace obrazu CNN v 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ázků TensorFlow můžete definovat poslední vrstvu s predikcí modelu. Výstupní tvar se rovná velikosti dávky a 10, což je celkový počet cílových tříd.

# 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. Funkce tf.argmax() vrací index nejvyšší hodnoty ve vrstvě logitů. 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")  }			

Slovník predikcí chcete vrátit pouze tehdy, když je režim nastaven na predikci. Pro zobrazení predikcí přidáte tento kód.

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

Dalším krokem je výpočet ztrát modelu. V minulém tutoriálu 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 příkladu TensorFlow CNN je optimalizace modelu, tj. nalezení nejlepších hodnot vah. K tomu se používá gradientní sestupný optimalizátor s mírou 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 hotovi. Chcete však zobrazit metriky výkonu během režimu vyhodnocování. Metrikou výkonu pro model s více třídami je přesnost. TensorFlow je vybaven modulem přesnosti, který přijímá dva argumenty, popisky a predikované hodnoty.

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)

Poznámka k sestavené funkci: Výše uvedená zabalená verze nastavuje první konvoluční vrstvu na 32 filtrů a dropout na 0.4, zatímco podrobné úryvky používají 14 filtrů a 0.3. Obě verze fungují, ale vybírají jeden pár hodnot a udržují je konzistentní, aby vytištěné tvary odpovídaly tabulce vrstev.

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")

Trénování CNN trvá dlouho, proto se každých 50 iterací vytvoří logovací hook, který ukládá hodnoty vrstev softmax.

# 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 promícháte. Všimněte si, že jsme nastavili trénovací kroky na 16 000, což může trénování zabrat hodně času. Buďte 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 natré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)

Vyhodnocení vytiskne obnovený kontrolní bod, krok, na kterém se zastavilo, a finální slovník metrik.

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 uvádí vyhodnocovací slovník přesnost 0.9689286, což je zhruba 97 %. Pro zlepšení přesnosti můžete změnit architekturu, velikost dávky a počet iterací. CNN si vedla mnohem lépe než... umělá neuronová síť nebo logistická regrese: v tutoriálu o umělých neuronových sítích jste měli přesnost 96 %, což je méně než u CNN. Výkon CNN je s větší sadou obrázků působivý, a to jak z hlediska rychlosti výpočtu, tak i přesnosti.

Nejčastější dotazy