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ózatA convnet vagy CNN néven is ismert módszer a számítógépes látás alkalmazásaiban. Mély neurális hálózatok egy osztálya, amelyeket vizuális képek elemzésére használnak. Ez a típusú architektúra domináns objektumok felismerésében képről vagy videóról. Olyan alkalmazásokban használják, mint a kép- vagy videófelismerés, a természetes nyelvi feldolgozás és az ajánlórendszerek.

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 konvnet architektúra az alábbi képen foglalható össze. Először is, egy képet küldenek a hálózatnak; ezt nevezik bemeneti képnek. Ezután a bemeneti kép egy sor 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évő számjegyet.

Egy kép pixelek tömbjéből áll, magassággal és szélességgel. Egy szürkeárnyalatos képnek csak egy csatornája van, míg a színes képnek három (mindegyik a vörös, zöld és kék színhez). A csatornák egymásra vannak halmozva. Ebben az oktatóanyagban egy egyetlen csatornával rendelkező szürkeárnyalatos képet fogsz használni. Minden pixel 0 és 255 közötti értékkel rendelkezik, amely a szín intenzitását tükrözi. Például egy 0 értékű pixel fehér színt mutat, míg egy 255-höz közeli értékű pixel sötétebb lesz.

Vessünk egy pillantást a ben tárolt képre MNIST adatkészletAz alábbi kép bemutatja, hogyan ábrázolható a bal oldali kép mátrix formátumban. Megjegyzendő, hogy az eredeti mátrix 0 és 1 közé van szabványosítva. 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 legfontosabb ö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)

Egy konvnetnek négy összetevője van:

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ó egy elemenkénti szorzás. A koncepció könnyen érthető. A számítógép beolvassa a kép egy részét, általában 3×3 dimenzióval, és egy szűrővel megszorozza. Az elemenkénti szorzás kimenetét jellemzőtérképnek nevezzük. Ezt a lépést addig ismételjük, amíg a teljes kép beolvasásra nem kerül. Megjegyezzük, hogy a konvolúció után a kép mérete csökken.

Az alábbi ábra a kép egy részének a szűrővel való megszorzását mutatja, így a jellemzőtérkép egyetlen cellája jön létre.

Az alábbi animáció ugyanazt a konvolúciót mutatja a teljes képen.

Számos szűrő érhető el. Az alábbiakban felsoroltunk néhányat közülük. Látható, hogy minden szűrőnek megvan a maga célja. Figyeljük meg, hogy 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 szűrőt a képen belüli kis pixeltömbre alkalmazza. A szűrő a bemeneti kép mentén mozog egy általános 3×3 vagy 5×5 alakú kör mentén. Ez azt jelenti, hogy a hálózat ezeket az ablakokat csúsztatja végig a teljes bemeneti képen, és kiszámítja a konvolúciót. Az alábbi animáció bemutatja a konvolúció működését. A folt mérete 3×3, a kimeneti mátrix pedig a képmátrix és a szűrő közötti elemenkénti műveletek 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ép egy 5×5-ös jellemzőtérképet és egy 3×3-as szűrőt tartalmaz. Csak egy ablak található középen, ahol a szűrő egy 3×3-as rácsot tud szűrni. A kimeneti jellemzőtérkép tengelyenként két csempével zsugorodik, így 3×3-as dimenzió marad.

Ahhoz, hogy a kimeneti dimenzió megegyezzen a bemeneti dimenzióval, kitöltést kell hozzáadni. A kitöltés azt jelenti, hogy a mátrix mindkét oldalán a megfelelő számú sort és oszlopot adjuk hozzá. Ez lehetővé teszi, hogy a konvolúció minden bemeneti csempét középre illesztsen. Az alábbi képen a bemeneti és kimeneti mátrixok azonos dimenzióval rendelkeznek, 5×5-ösek.

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

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

Lépés: Ez határozza meg a két szelet közötti „pixelugrások” számát. Ha a lépésszám egyenlő 1-gyel, az ablak egy pixelnyi szórással mozdul el. Ha a lépésszám egyenlő kettővel, az ablak 2 pixellel ugrik. Ha növeli a lépésszámot, kisebb jellemzőtérképeket kap. Az alábbi két ábra az 1-es és a 2-es lépésszámot hasonlítja össze.

1. lépés példa

2. lépés

Nulla kitöltés: A kitöltés egy olyan művelet, amelynek során a bemeneti jellemzőtérképek mindkét oldalán megfelelő számú sort és oszlopot adunk hozzá. Ebben az esetben a kimenet dimenziója megegyezik a bemenetével.

Nemlinearitás (ReLU)

A konvolúciós művelet végén a kimenetet egy aktivációs függvénynek vetik alá a nemlinearitás lehetővé tétele érdekében. A konvnet szokásos aktivációs függvénye a ReLU. Az összes negatív értékű pixel nullára lesz cserélve.

Pooling OperaCIÓ

Ez a lépés könnyen érthető. A pooling célja a bemeneti kép dimenzionalitásának csökkentése. A lépések célja a művelet számítási komplexitásának csökkentése. A dimenzionalitás csökkentésével a hálózatnak kevesebb súlyt kell kiszámítania, így megakadályozza a túlillesztést.

Ebben a szakaszban meg kell határozni a méretet és a lépésszámot. A bemeneti kép poolingolásának egy szabványos 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 szűri, és a maximális értéket adja vissza. A pooling egy 2×2-es tömb maximális értékét veszi, majd ezt az ablakot két pixellel elmozdítja. Például az első almátrix [3,1,3,2], így 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 jellemzőté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:

Egy TensorFlow konvolúciós neurális hálózat különböző rétegeket állít össze, mielőtt predikciót végezne. Egy neurális hálózat a következőkkel rendelkezik:

• 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 alrégiójára. A ReLU aktivációs függvény nemlinearitást ad hozzá, míg a pooling rétegek csökkentik a jellemzőtérképek dimenzionalitását.

Mindezek a rétegek extracA képekből kinyerhető lényeges információk. Végül a jellemzőtérképeket egy teljesen összekapcsolt rétegre továbbítják egy softmax függvénnyel, hogy predikciót készítsenek.

Vonatoztassa a CNN-t a TensorFlow-val

Most, hogy ismeri a konvnet építőelemeit, készen áll arra, hogy felépítsen egyet a következővel: 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. 1. lépés: Adatkészlet feltöltése
2. 2. lépés: Beviteli réteg
3. 3. lépés: Konvolúciós réteg
4. Lépés 4: Pooling réteg
5. 5. lépés: Második konvolúciós réteg és Pooling Réteg
6. 6. lépés: Sűrű réteg
7. 7. lépés: Logit réteg

Verzió megjegyzés: Az alábbi listák a TensorFlow 1.x verzióját célozzák. A TensorFlow 2-ben a tf.layers névtér és a tf.estimator.inputs.numpy_input_fn már nem létezik; a megfelelőik a tf.keras.layers.Conv2D, Max.PoolinA g2D, Dense és Dropout rétegek egy tf.keras.Model fájlban vannak összeállítva és model.fit() függvénnyel vannak betanítva. Olvasd el az egyes rétegek mechanikájának lépéseit, majd képezd le őket a Keras API-ra.

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

Az MNIST adathalmaz elérhető a scikit-learn segítségével. Kérjük, töltse le és tárolja a Letöltések mappában. Feltöltheti a fetch_mldata('MNIST original') paranccsal.

Verzió megjegyzés: Az mldata.org bezárt, és a fetch_mldata() függvényt eltávolították a scikit-learn 0.22-es verziójából. Bármelyik jelenlegi telepítésnél töltse be ugyanazokat a számjegyeket a következővel: fetch_openml ehelyett a fetch_openml('mnist_784', version=1) függvényt használjuk. A folyamat többi része változatlan marad.

Hozzon létre egy vonat/tesztkészletet

A train_test_split segítségével kell felosztani az adathalmazt.

Méretezze a jellemzőket

Végül a MinMaxScaler segítségével skálázhatja a funkciókat, ahogy az az alábbi képosztályozáson látható a TensorFlow CNN példájával.

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

Egy CNN szűrőket használ a kép nyers pixelein, hogy részletes mintákat tanuljon meg a hagyományos neurális hálózatok által tanult globális mintákhoz képest. Egy CNN létrehozásához a következőket kell definiálni:

1. Konvolúciós réteg: n számú szűrőt alkalmazunk a jellemzőtérképre. A konvolúció után egy ReLU aktivációs függvényt kell használnunk a hálózat nemlinearitásának növeléséhez.
2. Pooling réteg: A konvolúció utáni következő lépés a jellemzőtérkép lemintavételezése. A cél a jellemzőtérkép dimenziójának csökkentése a túlillesztés elkerülése és a számítási sebesség javítása érdekében. A maximális összevonás a hagyományos technika, amely a jellemzőtérképeket alrégiókra osztja (általában 2×2 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

Definiálsz 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 a csomagolás előtt.ping minden együtt van 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.

Egy képnek van magassága, szélessége és csatornája. Az MNIST adathalmaz egy monokróm kép, amelynek mérete 28×28. A batch méretét az alak argumentumban -1-re állítottuk, hogy az alakot vegye fel [„x”]. Az előnye az, hogy a batch mérete egy hangolható hiperparaméterré válik. Ha a batch mérete 7-re van állítva, akkor a tenzor 5,488 értéket fog betáplálni (28*28*7).

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 és azonos kitöltésekkel. Az azonos kitöltés azt jelenti, hogy mind a kimeneti, mind a bemeneti tenzornak azonos magasságúnak é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.

A ReLU aktivációs függvényt használod. A kimeneti méret [28, 28, 14] lesz.

Lépés 4: Pooling réteg

A konvolúció utáni következő lépés a pooling számítás. A pooling számítás csökkenti az adatok dimenzionalitását. Használhatod a max_pooling2d modult 2×2 mérettel és 2 stride-dal. Bemenetként az előző réteget használod. 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 36 szűrőt alkalmaz, ami [batch_size, 14, 14, 36] kimeneti méretet eredményez. A pooling réteg ugyanazt a 2×2-es ablakot és 2-es lépésközt használja, mint korábban, így minden térbeli tengelyt felez, és a kimeneti alak [batch_size, 7, 7, 36] lesz.

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ároznod a teljesen összekapcsolt réteget. A jellemzőtérképet a sűrű réteggel való összekapcsolás előtt lapítani kell. Használhatod a modul átformálását 7*7*36 mérettel.

A sűrű réteg 1,764 neuront fog összekötni. Hozzáadsz egy ReLU aktivációs függvényt. Ezenkívül hozzáadsz egy 0.3-as arányú kiesési regularizációs tagot, ami azt jelenti, hogy az aktiválások 30 százaléka 0-ra lesz állítva. Megjegyzendő, hogy a kiesés csak a betanítási fázisban történik. A cnn_model_fn függvénynek van egy argumentummódja, amellyel deklarálható, hogy a modellt betanítani vagy kiértékelni kell-e, ahogy az az alábbi CNN képosztályozási TensorFlow példában is 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éposztályozási példában definiálhatod az utolsó réteget a modell predikciójával. A kimeneti alak megegyezik a köteg méretével és 10-zel, a célosztályok teljes számával.

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

Létrehozhatsz egy szótárat, amely tartalmazza az osztályokat és az egyes osztályok valószínűségét. A tf.argmax() függvény a logits rétegben található legmagasabb érték indexét adja vissza. A softmax függvény az egyes osztályok 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éd visszaadni a predikciós szótárat, ha a mód predikcióra van állítva. Ezt a kódot add hozzá a predikciók 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 előző oktatóanyagban megtanultad, hogy egy többosztályos modell veszteségfüggvénye kereszt-entropia. 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, azaz a súlyok legjobb értékeinek megtalálása. Ehhez egy 0.001 tanulási rátájú gradiens descent optimalizálót használunk. 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())

Kész is vagy a CNN-nel. Azonban szeretnéd megjeleníteni a teljesítménymutatókat a kiértékelési módban. A többosztályos modellek teljesítménymutatója a pontosság. A TensorFlow egy pontossági modullal van felszerelve, amely két argumentumot fogad el: a címkéket és az előrejelzett értékeket.

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)

Megjegyzés az összeszerelt funkcióról: A fenti becsomagolt verzió az első konvolúciós réteget 32 ​​szűrőre, a kihagyást pedig 0.4-re állítja, míg a lépésenkénti kódrészletek 14 szűrőt és 0.3-at használnak. Mindkettő fut, de válasszon ki egy értékpárt, és tartsa azt konzisztensen, hogy a kinyomtatott alakzatok illeszkedjenek a rétegtáblázathoz.

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 betanítása hosszú időt vesz igénybe, ezért létre kell hozni egy naplózó hook-ot, 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 állsz a modell becslésére. 100-as kötegméretet állítasz be, és összekevered az adatokat. Figyeld meg, hogy 16 000-es betanítási lépést állítottunk be, aminek a betanítása sok időt vehet igénybe. Légy 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ítva van, 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)

A kiértékelés kinyomtatja a visszaállított ellenőrzőpontot, a leállítás lépését és a végső metrikák szótárát.

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 a kiértékelő szótár 0.9689286-os pontosságot jelez, ami nagyjából 97%. A pontosság javítása é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 sokkal jobban teljesített, mint egy mesterséges idegi hálózat vagy logisztikus regresszió: a mesterséges neurális hálózatokról szóló oktatóanyagban 96%-os pontosságot kaptál, ami alacsonyabb, mint a CNN-nél. A CNN teljesítménye lenyűgöző egy nagyobb képhalmazzal, mind a számítási sebesség, mind a pontosság tekintetében.

GYIK