CNN képosztályozás a TensorFlow-ban lépésekkel és példákkal

Mi az a konvolúciós neurális hálózat?

Konvolúciós Neurális Hálózat, más néven convnets vagy CNN, jól ismert módszer a számítógépes látás alkalmazásokban. Ez a mély neurális hálózatok osztálya, amelyeket vizuális képek elemzésére használnak. Ez a fajta architektúra domináns az objektumok képből vagy videóból való felismerésére. Olyan alkalmazásokban használják, mint a kép- vagy videófelismerés, a neurális nyelvi feldolgozás stb.

ArchiKonvolúciós Neurális Hálózat szerkezete

Gondoljon csak a Facebookra néhány évvel ezelőtt, miután feltöltött egy képet a profiljába, megkértek, hogy adjon nevet a képen látható archoz. Manapság a Facebook a convnet segítségével automatikusan megjelöli az ismerősét a képen.

A képosztályozáshoz használt konvolúciós neurális hálózatot nem nehéz megérteni. A bemeneti képet a konvolúciós fázisban dolgozzák fel, és később címkét rendelnek hozzá.

Egy tipikus convnet architektúra az alábbi képen foglalható össze. Mindenekelőtt egy kép kerül a hálózatba; ezt nevezzük bemeneti képnek. Ezután a bemeneti kép végtelen számú lépésen megy keresztül; ez a hálózat konvolúciós része. Végül a neurális hálózat meg tudja jósolni a képen látható számjegyet.

A kép magasságú és szélességű képpontok tömbjéből áll. A szürkeárnyalatos képnek csak egy csatornája van, míg a színes képnek három csatornája van (mindegyik piros, zöld és kék csatornával). Egy csatorna egymásra van rakva. Ebben az oktatóanyagban szürkeárnyalatos képet fog használni csak egy csatornával. Minden pixel értéke 0 és 255 között van, hogy tükrözze a szín intenzitását. Például egy 0-val egyenlő képpont fehér színt mutat, míg a 255-höz közeli értékű képpont sötétebb lesz.

Vessünk egy pillantást a ben tárolt képre MNIST adatkészlet. Az alábbi képen látható, hogyan ábrázolható a bal oldali kép mátrix formátumban. Vegye figyelembe, hogy az eredeti mátrixot 0 és 1 közé szabványosították. Sötétebb színek esetén a mátrix értéke körülbelül 0.9, míg a fehér pixelek értéke 0.

Konvolúciós művelet

A modell legkritikusabb összetevője a konvolúciós réteg. Ennek a résznek a célja a kép méretének csökkentése a súlyok gyorsabb kiszámítása és az általánosítás javítása érdekében.

A konvolúciós rész során a hálózat megtartja a kép lényeges tulajdonságait, és kizárja az irreleváns zajt. Például a modell megtanulja, hogyan lehet felismerni egy elefántot egy képről, amelyen egy hegy van a háttérben. Ha hagyományos neurális hálózatot használ, a modell súlyt rendel az összes pixelhez, beleértve a hegyről származókat is, ami nem lényeges, és félrevezetheti a hálózatot.

Ehelyett a Keras A konvolúciós neurális hálózat matematikai technikát alkalmaz a kiszámításhoztraccsak a legrelevánsabb pixeleket. Ezt a matematikai műveletet konvolúciónak nevezik. Ez a technika lehetővé teszi a hálózat számára, hogy minden rétegen egyre összetettebb jellemzőket tanuljon meg. A konvolúció a mátrixot apró darabokra osztja, hogy az egyes darabokon belüli legfontosabb elemeket tanulja meg.

A konvolúciós neurális hálózat összetevői (ConvNet vagy CNN)

A Convnet négy összetevőből áll

1. tekeredés
2. Nemlinearitás (ReLU)
3. Pooling vagy Sub Sampling
4. Osztályozás (teljesen összekapcsolt réteg)

tekeredés

A konvolúció célja a kivlasztásatracA képen látható objektum jellemzőit lokálisan figyeli. Ez azt jelenti, hogy a hálózat megtanulja a képen belüli specifikus mintákat, és képes lesz felismerni azokat a kép minden pontján.

A konvolúció elemenkénti szorzás. A koncepció könnyen érthető. A számítógép beszkenneli a kép egy részét, általában 3×3-as méretben, és megszorozza egy szűrővel. Az elemenkénti szorzás kimenetét jellemzőtérképnek nevezzük. Ezt a lépést addig ismétli, amíg az összes képet be nem olvasta. Vegye figyelembe, hogy a konvolúció után a kép mérete csökken.

Lent van egy URL hogy működés közben lássuk, hogyan működik a konvolúció.

Számos csatorna áll rendelkezésre. Az alábbiakban felsoroltunk néhány csatornát. Láthatja, hogy minden szűrőnek meghatározott célja van. Megjegyzés: az alábbi képen; a Kernel a szűrő szinonimája.

Aritmetika a konvolúció mögött

A konvolúciós fázis a képen belüli kis pixeltömbön alkalmazza a szűrőt. A szűrő a bemeneti kép mentén 3×3 vagy 5×5 általános alakban mozog. Ez azt jelenti, hogy a hálózat átcsúsztatja ezeket az ablakokat az összes bemeneti képen, és kiszámítja a konvolúciót. Az alábbi képen látható a konvolúció működése. A patch mérete 3×3, a kimeneti mátrix pedig a képmátrix és a szűrő közötti elemenkénti művelet eredménye.

Észreveszi, hogy a kimenet szélessége és magassága eltérhet a bemenet szélességétől és magasságától. Ez a határhatás miatt történik.

Határ hatás

A képen 5×5-ös térkép és 3×3-as szűrő található. Csak egy ablak van a közepén, ahol a szűrő képes egy 3 × 3-as rácsot kiszűrni. A kimeneti jellemzőtérkép két csempével csökken a 3×3-as méret mellett.

Ahhoz, hogy ugyanazt a kimeneti méretet kapja, mint a bemeneti dimenzió, kitöltést kell hozzáadnia. A kitöltés abból áll, hogy a megfelelő számú sort és oszlopot adjuk hozzá a mátrix mindkét oldalán. Lehetővé teszi, hogy a konvolúció minden bemeneti lapkához illeszkedjen. Az alábbi képen a bemeneti/kimeneti mátrix mérete azonos 5×5

A hálózat meghatározásakor az összevont funkciókat három paraméter vezérli:

1. Mélység: Meghatározza a konvolúció során alkalmazandó szűrők számát. Az előző példában 1-es mélységet látott, ami azt jelenti, hogy csak egy szűrőt használnak. A legtöbb esetben egynél több szűrő van. Az alábbi kép a három szűrős helyzetben végzett műveleteket mutatja be

2. Lépés: Meghatározza a „pixel ugrások” számát két szelet között. Ha a lépésszám egyenlő 1-gyel, az ablakok egy pixeltávolsággal mozognak. Ha a lépésszám egyenlő kettővel, az ablakok 2 képponttal ugranak. Ha növeli a lépést, kisebb tereptérképei lesznek.

1. lépés példa

2. lépés

3. Nulla-párnázás: A kitöltés egy megfelelő számú sor és oszlop hozzáadásának művelete a beviteli jellemzőtérképek mindkét oldalán. Ebben az esetben a kimenet mérete megegyezik a bemenettel.

Nemlinearitás (ReLU)

A konvolúciós művelet végén a kimenetre egy aktiválási függvény vonatkozik, amely lehetővé teszi a nemlinearitást. A convnet szokásos aktiválási funkciója a Relu. Az összes negatív értékű pixel helyére nulla kerül.

Pooling OperaCIÓ

Ez a lépés könnyen érthető. A pooling célja a bemeneti kép méretének csökkentése. A lépéseket a művelet számítási bonyolultságának csökkentése érdekében hajtják végre. A dimenzionalitás csökkentésével a hálózatnak kisebb a számítási súlya, így megakadályozza a túlillesztést.

Ebben a szakaszban meg kell határoznia a méretet és a lépést. A bemeneti kép összevonásának szokásos módja a jellemzőtérkép maximális értékének használata. Nézd meg az alábbi képet. A „pooling” a 4×4-es jellemzőtérkép négy almátrixát jeleníti meg, és visszaadja a maximális értéket. A pooling egy 2×2-es tömb maximális értékét veszi fel, majd ezt az ablakot két képponttal mozgatja. Például az első almátrix [3,1,3,2], a pooling a maximumot adja vissza, ami 3.

Van egy másik összevonási művelet is, például az átlag.

Ez a művelet agresszíven csökkenti a tereptérkép méretét

Teljesen összekapcsolt rétegek

Az utolsó lépés a hagyományos felépítése mesterséges idegi hálózat ahogy az előző oktatóanyagban tetted. Összekapcsolja az előző réteg összes neuronját a következő réteggel. A bemeneti képen lévő szám osztályozásához softmax aktiválási funkciót használ.

Újrafutóz:

A TensorFlow konvolúciós neurális hálózat különböző rétegeket állít össze, mielőtt előrejelzést készítene. Egy neurális hálózatnak a következők vannak:

• Konvolúciós réteg
• Relu aktiválási funkció
• Pooling réteg
• Sűrűn összefüggő réteg

A konvolúciós rétegek különböző szűrőket alkalmaznak a kép egy részterületére. A Relu aktiválási funkció nemlinearitást ad, és a pooling rétegek csökkentik a jellemzőtérképek dimenzióját.

Mindezek a rétegek extracA képekből kinyerhető lényeges információk. Végül a jellemzőtérképet egy elsődleges, teljesen összekapcsolt rétegre továbbítják egy softmax függvénnyel, amely előrejelzést készít.

Vonatoztassa a CNN-t a TensorFlow-val

Most, hogy ismeri a convnet építőelemét, készen áll az építkezésre TensorFlow. Az MNIST adatkészletet fogjuk használni a CNN képosztályozáshoz.

Az adatok előkészítése megegyezik az előző oktatóanyaggal. Futtathatja a kódokat, és közvetlenül a CNN architektúrájához ugorhat.

Kövesse az alábbi lépéseket a CNN segítségével történő képosztályozáshoz:

1. lépés: Adatkészlet feltöltése

2. lépés: Beviteli réteg

3. lépés: Konvolúciós réteg

Lépés 4: Pooling réteg

5. lépés: Második konvolúciós réteg és Pooling Réteg

6. lépés: Sűrű réteg

7. lépés: Logit réteg

1. lépés: Adatkészlet feltöltése

Az MNIST adatkészlet a scikittel együtt elérhető, hogy megtanulja ezt URL. Kérjük, töltse le és tárolja a Letöltések között. A fetch_mldata('MNIST original') segítségével töltheti fel.

Hozzon létre egy vonat/tesztkészletet

Az adatkészletet fel kell osztania a train_test_split paraméterrel

Méretezze a jellemzőket

Végül méretezheti a funkciót a MinMaxScaler segítségével, amint az az alábbi képbesorolásban látható, a TensorFlow CNN példa segítségével.

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

Határozza meg a CNN-t

A CNN szűrőket használ a kép nyers pixelén, hogy megtanulja a részleteket, összehasonlítva a hagyományos neurális hálóval végzett globális mintával. A CNN létrehozásához meg kell határoznia:

1. Konvolúciós réteg: Alkalmazzon n számú szűrőt a tereptérképre. A konvolúció után egy Relu aktiválási függvényt kell használnia, hogy nemlinearitást adjon a hálózathoz.
2. Pooling réteg: A következő lépés a konvolúció után a jellemző max. mintavételezése. A cél a jellemzőtérkép méretének csökkentése a túlillesztés elkerülése és a számítási sebesség javítása érdekében. A Max pooling a hagyományos technika, amely a tereptérképeket alrégiókra osztja (általában 2×2-es méretben), és csak a maximális értékeket tartja meg.
3. Teljesen összekapcsolt rétegek: Az előző rétegekből származó összes neuron kapcsolódik a következő rétegekhez. A CNN osztályozza a címkét a konvolúciós rétegek jellemzői szerint, és csökkenti a gyűjtőréteggel.

CNN architektúra

• Konvolúciós réteg: 14 db 5×5-ös szűrőt alkalmaz (pl.trac5×5 pixeles alrégiók) ReLU aktivációs függvényével
• Pooling Réteg: Maximális összevonást hajt végre 2×2-es szűrővel és 2-es lépésközzel (ami azt jelzi, hogy az összevont régiók nem fedik át egymást)
• Konvolúciós réteg: 36 db 5×5 szűrőt alkalmaz, ReLU aktiválási funkcióval
• Pooling 2. réteg: Ismét végrehajtja a maximális összevonást 2×2-es szűrővel és 2-es lépéssel
• 1,764 neuron, 0.4-es lemorzsolódási arány mellett (0.4 a valószínűsége annak, hogy egy adott elem kiesik a képzés során)
• Sűrű réteg (Logits Layer): 10 neuron, egy minden számjegy célosztályhoz (0–9).

Három fontos modult kell használni a CNN létrehozásához:

• conv2d(). Kétdimenziós konvolúciós réteget hoz létre argumentumként a szűrők számával, a szűrőmag méretével, a kitöltéssel és az aktiválási függvényekkel.
• max_pooling2d(). Kétdimenziós pooling réteget hoz létre a max-pooling algoritmus segítségével.
• sűrű(). Sűrű réteget hoz létre a rejtett rétegekkel és egységekkel

Meg kell határoznia egy függvényt a CNN felépítéséhez. Nézzük meg részletesen, hogyan kell felépíteni az egyes építőelemeket, mielőtt mindent összefogna a függvényben.

2. lépés: Beviteli réteg

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

Meg kell határoznia egy tenzort az adatok alakjával. Ehhez használhatja a tf.reshape modult. Ebben a modulban deklarálnia kell az átformálandó tenzort és a tenzor alakját. Az első argumentum az adatok jellemzői, amelyeket a függvény argumentumában definiálunk.

A képnek magassága, szélessége és csatornája van. Az MNIST adatkészlet egy 28×28-as méretű, monokron kép. Az alak argumentumban a köteg méretét -1-re állítjuk, hogy felvegye az [“x”] jellemzők alakját. Az előny az, hogy a kötegméret hiperparamétereit hangoljuk. Ha a kötegméret 7-re van állítva, akkor a tenzor 5,488 értéket (28*28*7) fog betáplálni.

3. lépés: Konvolúciós réteg

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

Az első konvolúciós réteg 14 szűrőt tartalmaz, 5×5-ös kernelmérettel, azonos kitöltéssel. Ugyanaz a kitöltés azt jelenti, hogy a kimeneti tenzornak és a bemeneti tenzornak azonos magasságú és szélességűnek kell lennie. A Tensorflow nullákat ad a sorokhoz és oszlopokhoz az azonos méret biztosítása érdekében.

Ön a Relu aktiválási funkciót használja. A kimenet mérete [28, 28, 14] lesz.

Lépés 4: Pooling réteg

A következő lépés a konvolúció után a pooling számítás. A pooling számítás csökkenti az adatok dimenzióját. Használhatja a max_pooling2d modult 2×2 mérettel és 2 lépéssel. Bemenetként az előző réteget használja. A kimeneti méret [batch_size, 14, 14, 14] lesz

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

5. lépés: Második konvolúciós réteg és Pooling Réteg

A második konvolúciós réteg 32 szűrőt tartalmaz, amelyek kimeneti mérete [batch_size, 14, 14, 32]. A pooling réteg mérete megegyezik az előzővel, a kimeneti alak pedig [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)

6. lépés: Sűrű réteg

Ezután meg kell határoznia a teljesen összekapcsolt réteget. A tereptérképet le kell lapítani, mielőtt a sűrű réteggel összekapcsolható. A modul átformálását 7*7*36 méretben használhatja.

A sűrű réteg 1764 neuront köt majd össze. Hozzáad egy Relu aktiválási funkciót. Emellett hozzáad egy lemorzsolódási szabályzó kifejezést 0.3-as aránnyal, ami azt jelenti, hogy a súlyok 30 százaléka 0-ra lesz állítva. Vegye figyelembe, hogy a lemorzsolódás csak az edzési szakaszban történik. A cnn_model_fn függvénynek van egy argumentummódja annak deklarálására, hogy a modellt betanítani kell-e vagy ki kell-e értékelni, ahogy az az alábbi TensorFlow CNN-képosztályozási példában látható.

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)

7. lépés: Logit réteg

Végül a TensorFlow képbesorolási példában meghatározhatja az utolsó réteget a modell előrejelzésével. A kimenet alakja megegyezik a köteg méretével és 10-nel, a képek teljes számával.

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

Létrehozhat egy szótárt, amely tartalmazza az osztályokat és az egyes osztályok valószínűségét. A tf.argmax() modul a legmagasabb értéket adja vissza, ha a logit rétegek. A softmax függvény minden osztály valószínűségét adja vissza.

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

Csak akkor szeretné visszaadni a szótár előrejelzését, ha a mód előrejelzésre van állítva. Ezeket a kódokat adja hozzá az előrejelzések megjelenítéséhez

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

A következő lépés a modell veszteségének kiszámítása. Az utolsó oktatóanyagban megtanulta, hogy a többosztályú modell veszteségfüggvénye a keresztentrópia. A veszteség könnyen kiszámítható a következő kóddal:

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

A TensorFlow CNN példa utolsó lépése a modell optimalizálása, vagyis a súlyok legjobb értékeinek megtalálása. Ehhez egy Gradient süllyedés-optimalizálót használ, amelynek tanulási aránya 0.001. A cél a veszteség minimalizálása

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

Elkészült a CNN-nel. A teljesítménymutatókat azonban meg szeretné jeleníteni az értékelési módban. A többosztályú modell teljesítménymutatói a pontossági mutatók. A Tensorflow modul pontossággal van felszerelve két argumentummal, a címkékkel és az előrejelzett értékekkel.

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)

Ez az. Létrehozta első CNN-jét, és készen áll, hogy mindent egy függvénybe csomagoljon, hogy azt a modell betanításához és értékeléséhez használja.

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)

Az alábbi lépések megegyeznek az előző oktatóanyagokéval.

Először is definiál egy becslőt a CNN modellel a képosztályozáshoz.

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

Egy CNN-nek sokszor kell betanulnia, ezért létrehoz egy naplózási horgot, amely 50 iterációnként tárolja a softmax rétegek értékeit.

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

Készen áll a modell becslésére. 100-as kötegméretet állít be, és megkeveri az adatokat. Vegye figyelembe, hogy 16.000 edzési lépést állítunk be, sok időt vehet igénybe az edzés. Legyél türelmes.

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

Most, hogy a modell betanított, kiértékelheti és kinyomtathatja az eredményeket

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

A jelenlegi architektúrával 97%-os pontosságot kap. A pontosság növelése érdekében módosíthatja az architektúrát, a köteg méretét és az iterációk számát. A CNN neurális hálózat sokkal jobban teljesített, mint az ANN vagy a logisztikai regresszió. A mesterséges neurális hálózatról szóló oktatóanyagban 96%-os pontosság volt, ami alacsonyabb a CNN-nél. A CNN előadásai nagyobb képpel lenyűgözőek készlet, mind a sebességszámítás, mind a pontosság tekintetében.

Összegzésként

A konvolúciós neurális hálózat nagyon jól működik a kép értékelésében. Ez a fajta architektúra domináns az objektumok képből vagy videóból való felismerésére.

A TensorFlow CNN felépítéséhez hét lépést kell követnie:

1 lépés: Adatkészlet feltöltése:

Az MNIST adatkészlet a scikittel együtt elérhető. Kérjük, töltse le és tárolja a Letöltések között. A fetch_mldata('MNIST original') segítségével töltheti fel.

2 lépés: Bemeneti réteg:

Ez a lépés átformálja az adatokat. Az alak megegyezik a képpontok számának négyzetgyökével. Például, ha egy kép 156 pixeles, akkor az alakzat 26×26. Meg kell adnia, hogy a kép színes-e vagy sem. Ha igen, akkor 3 volt az alakzathoz – 3 az RGB-hez-, egyébként 1.

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

3 lépés: Konvolúciós réteg

Ezután létre kell hoznia a konvolúciós rétegeket. Különféle szűrőket alkalmaz, hogy a hálózat megtanulja a fontos funkciókat. Megadhatod a kernel méretét és a szűrők mennyiségét.

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

4 lépés: Pooling réteg

A harmadik lépésben egy pooling réteget ad hozzá. Ez a réteg csökkenti a bemenet méretét. Ezt úgy teszi, hogy az a részmátrix maximális értékét veszi fel. Például, ha az almátrix [3,1,3,2], a pooling a maximumot adja vissza, ami 3.

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

5 lépés: Konvolúciós réteg hozzáadása és Pooling Réteg

Ebben a lépésben annyi konverziós réteget és összevonó réteget adhatsz hozzá, amennyit csak szeretnél. Google több mint 20 konverziós réteggel rendelkező architektúrát használ.

6 lépés: Sűrű réteg

A 6. lépés simítsa le az előzőt, hogy teljesen összekapcsolt rétegeket hozzon létre. Ebben a lépésben különböző aktiválási funkciókat használhat, és hozzáadhat egy lemorzsolódási effektust.

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)

7 lépés: Logit Layer

Az utolsó lépés az előrejelzés.

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