Mi az a konvolúciós neurális hálózat?
A konvolúciós ideghálózat, más néven convnets vagy CNN, jól ismert módszer a számítógépes látási alkalmazásokban. Ez a típusú architektúra domináns az objektumok képből vagy videóból történő felismeréséhez.
Ebben az oktatóanyagban megtanulhatja, hogyan készítsen konvnetet, és hogyan használja a TensorFlow-t a kézzel írt adatkészlet megoldására.
Ebben az oktatóanyagban megtanulja
- Konvolúciós neurális hálózat
- Konvolúciós neurális hálózat felépítése
- A Convnets elemei
- Vonatozza a CNN-t a TensorFlow segítségével
- 1. lépés: Töltse fel az adatkészletet
- 2. lépés: Bemeneti réteg
- 3. lépés: Konvolúciós réteg
- 4. lépés: Réteg összegyűjtése
- 5. lépés: Második konvolúciós réteg és egyesítő réteg
- 6. lépés: Sűrű réteg
- 7. lépés: Logit réteg
Konvolúciós neurális hálózat felépítése
Gondoljon néhány évvel ezelőtt a Facebookra, miután feltöltött egy képet a profiljára, megkérték, hogy adjon nevet a kép arcához manuálisan. Manapság a Facebook a convnet segítségével automatikusan megjelöli a barátodat a képen.
A konvolúciós ideghálózatot nem nagyon nehéz megérteni. Egy bemeneti képet feldolgoznak a konvolúciós szakaszban, é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épet tolnak a hálózatra; 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 az idegháló képes megjósolni a képen látható számjegyet.
A kép magasságú és szélességű pixelek 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). Egy csatorna egymásra van rakva. Ebben az oktatóanyagban csak egy csatornával rendelkező szürkeárnyalatos képet fog használni. Minden pixel értéke 0 és 255 között tükrözi a szín intenzitását. Például egy 0-nak megfelelő pixel fehér színt mutat, míg a 255-höz közeli értékű sötétebb.
Nézzünk meg egy képet, amelyet az MNIST adatkészlet tárolt. Az alábbi kép megmutatja, hogyan ábrázolhatjuk a bal oldali képet mátrix formátumban. Ne feledje, hogy az eredeti mátrixot 0 és 1 közé standardizálták. Sötétebb szín 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űködés
A modell legkritikusabb eleme a konvolúciós réteg. Ez a rész a kép méretének csökkentését célozza a súlyok gyorsabb kiszámítása érdekében, és javítja annak általánosítását.
A konvolúciós rész során a hálózat megőrzi a kép alapvető jellemzőit, és kizárja a lényegtelen zajt. Például a modell megtanulja, hogyan lehet felismerni egy elefántot egy olyan képről, amelynek a háttérben hegy van. Ha hagyományos neurális hálózatot használ, akkor a modell súlyt fog rendelni az összes képponthoz, beleértve a hegyi képpontokat is, ami nem alapvető fontosságú, és félrevezetheti a hálózatot.
Ehelyett egy konvolúciós ideghálózat matematikai technikával csak a legrelevánsabb pixeleket vonja ki. Ezt a matematikai műveletet konvolúciónak nevezzük. Ez a technika lehetővé teszi a hálózat számára, hogy minden rétegnél egyre összetettebb funkciókat tanuljon meg. A konvolúció a mátrixot apró darabokra osztja, hogy megtanulják a legfontosabb elemeket az egyes darabokon belül.
A Convnets elemei
A Convnets négy összetevője
- Konvolúció
- Nem linearitás (ReLU)
- Egyesítés vagy részmintavétel
- Besorolás (teljesen összekapcsolt réteg)
- Konvolúció
A konvolúció célja, hogy a képen lévő objektum jellemzőit helyileg kinyerje. Ez azt jelenti, hogy a hálózat sajátos mintákat tanul meg a képen belül, és képes lesz felismerni a kép mindenhol.
A konvolúció 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 3x3-as dimenzióval, és megszorozza egy szűrővé. Az elemenkénti szorzás kimenetét jellemző térképnek nevezzük. Ezt a lépést addig ismételjük, amíg az összes képet be nem szkenneljük. Vegye figyelembe, hogy a konvolúció után a kép mérete csökken.
Az alábbiakban van egy URL, amellyel megtekintheti a konvolúció működését.
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.
Forrás
Aritmetika a konvolúció mögött
A konvolúciós szakasz a szűrőn a képen található kis pixelcsoportra alkalmazza. A szűrő a bemeneti kép mentén mozog, általános alakja 3x3 vagy 5x5. Ez azt jelenti, hogy a hálózat ezeket az ablakokat áthúzza az összes bemeneti képen, és kiszámítja a konvolúciót. Az alábbi kép mutatja, hogyan működik a konvolúció. A javítás mérete 3x3, a kimeneti mátrix pedig a képmátrix és a szűrő közötti elemenkénti művelet eredménye.
Forrás
Észreveszi, hogy a kimenet szélessége és magassága eltérhet a bemenet szélességétől és magasságától. A határhatás miatt történik.
Határhatás
A kép 5x5-ös térképpel és 3x3-as szűrővel rendelkezik. Csak egy ablak van a közepén, ahol a szűrő 3x3-as rácsot képes megjeleníteni. A kimeneti jellemző térképe két csempével zsugorodik a 3x3 méret mellett.
Ahhoz, hogy a bemeneti dimenzióval megegyező kimeneti dimenziót kapjon, hozzá kell adnia a kitöltést. A kitöltés abból áll, hogy a mátrix mindkét oldalán megfelelő számú sort és oszlopot adunk hozzá. Ez lehetővé teszi, hogy a konvolúció minden bemeneti csempe középre illeszkedjen. Az alábbi képen a bemeneti / kimeneti mátrix 5x5 méretű
A hálózat definiálásakor az összevont szolgáltatásokat három paraméter vezérli:
- Mélység: Meghatározza a konvolúció során alkalmazandó szűrők számát. Az előző példában 1 mélységet látott, vagyis csak egy szűrőt használ. Az esetek többségében egynél több szűrő van. Az alábbi képen három szűrővel végzett műveletek láthatók
- Stride: Meghatározza a két pixel közötti "pixel ugrás" számát. Ha a lépés egyenlő 1-vel, akkor az ablakok egy pixel elosztással mozognak. Ha a lépés egyenlő kettővel, akkor az ablakok 2 pixellel ugranak. Ha növeli az előrelépést, kisebb funkciótérképeket kap.
Példa 1. lépés
Kép lépése 2
- Nulla kitöltés: A kitöltés olyan művelet, amely megfelelő számú sort és oszlopot ad hozzá a bemeneti jellemzők térképeinek mindkét oldalához. Ebben az esetben a kimenetnek ugyanaz a dimenziója, mint a bemenetnek.
- Nem linearitás (ReLU)
A konvolúciós művelet végén a kimenetet aktiválási függvénynek vetik alá a nem-linearitás lehetővé tétele érdekében. A convnet szokásos aktiválási funkciója a Relu. Az összes negatív értékű pixelt nulla váltja fel.
- Max pooling művelet
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 komplexitásának csökkentése érdekében végezzük. A méret csökkentésével a hálózatnak kisebb súlya van a számításhoz, í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 egyesítésének 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 4x4 jellemzők térképének négy almátrixát jeleníti meg, és megadja a maximális értéket. Az egyesítés a 2x2 tömb maximális értékét veszi fel, majd ezt az ablakot két pixelrel mozgatja. Például az első almátrix [3,1,3,2], a pooling megadja a maximumot, ami 3.
Van még egy pooling művelet, 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 egy hagyományos mesterséges ideghálózat kiépítéséből áll, ahogy az előző bemutatóban tetted. Az előző réteg összes neuronját összekapcsolja a következő réteggel. Softmax aktiválási funkcióval osztályozza a számot a bemeneti képen.
Újrafutóz:
A konvolúciós neurális hálózat különféle rétegeket állít össze, mielőtt előrejelzést adna. Egy neurális hálózat:
- Konvolúciós réteg
- Relu aktiválás funkció
- Pooling réteg
- Sűrűn összekapcsolt réteg
A konvolúciós rétegek különböző szűrőket alkalmaznak a kép kistérségére. A Relu aktiválási függvény nem-linearitást ad, és az egyesítő rétegek csökkentik a jellemzők térképeinek dimenzióit.
Mindezek a rétegek lényeges információkat vonnak le a képekről. Végül a jellemzők térképe egy elsődleges, teljesen összekapcsolt rétegbe kerül, amely egy softmax funkcióval rendelkezik az előrejelzés érdekében.
Vonatozza a CNN-t a TensorFlow segítségével
Most, hogy ismeri a konnetek építőelemét, készen áll a TensorFlow használatával. A képek osztályozásához az MNIST adatkészletet fogjuk használni.
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ára ugorhat.
Kövesse az alábbi lépéseket:
1. lépés: Töltse fel az adatkészletet
2. lépés: Bemeneti réteg
3. lépés: Konvolúciós réteg
4. lépés: Réteg összegyűjtése
5. lépés: Második konvolúciós réteg és egyesítő réteg
6. lépés: Sűrű réteg
7. lépés: Logit réteg
1. lépés: Töltse fel az adatkészletet
Az MNIST adatkészlet scikit használatával érhető el ezen az URL-en. Kérjük, töltse le és tárolja a Letöltések listában. Feltöltheti a fetch_mldata ('MNIST eredeti') segítségével.
Hozzon létre egy vonatot / tesztkészletet
Fel kell osztania az adatkészletet a train_test_split paranccsal
Méretezze a funkciókat
Végül a MinMaxScaler segítségével méretezheti a funkciót
import numpy as npimport tensorflow as tffrom sklearn.datasets import fetch_mldata#Change USERNAME by the username of your machine## Windows USERmnist = fetch_mldata('C:\\Users\\USERNAME\\Downloads\\MNIST original')## Mac Usermnist = fetch_mldata('/Users/USERNAME/Downloads/MNIST original')print(mnist.data.shape)print(mnist.target.shape)from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)y_train = y_train.astype(int)y_test = y_test.astype(int)batch_size =len(X_train)print(X_train.shape, y_train.shape,y_test.shape )## resclaefrom sklearn.preprocessing import MinMaxScalerscaler = MinMaxScaler()# TrainX_train_scaled = scaler.fit_transform(X_train.astype(np.float64))# testX_test_scaled = scaler.fit_transform(X_test.astype(np.float64))feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]X_train_scaled.shape[1:]
Határozza meg a CNN-t
A CNN a kép nyers pixelén található szűrőket használja a részletek megismeréséhez, összehasonlítva a hagyományos ideghálóval rendelkező globális mintákkal. CNN összeállításához meg kell határoznia:
- Konvolúciós réteg: n számú szűrőt alkalmazzon a jellemző térképen. A konvolúció után Relu aktiválási funkcióval kell hozzáadnia a hálózathoz a nem-linearitást.
- Pooling layer: A konvolúció után a következő lépés a max. A cél a funkciótérkép dimenzióinak csökkentése a túlillesztés megakadályozása és a számítási sebesség javítása érdekében. A max pooling a hagyományos technika, amely a jellemző térképeket kistérségekre osztja (általában 2x2 méretűek), és csak a maximális értékeket tartja meg.
- Teljesen összekapcsolt rétegek: Az előző rétegek összes neuronja 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 a pooling réteggel csökkentve.
CNN architektúra
- Konvolúciós réteg: 14 db 5x5 szűrőt alkalmaz (5x5 pixeles alrégiók kivonása), ReLU aktiválási funkcióval
- Pooling Layer: Maximális összevonást végez 2x2 szűrővel és 2 lépéses lépéssel (amely meghatározza, hogy az egyesített régiók ne fedjék egymást)
- Konvolúciós réteg: 36 db 5x5 szűrőt alkalmaz, ReLU aktiválási funkcióval
- 2. réteg összevonása: Ismét maximális összevonást hajt végre 2x2 szűrővel és 2 lépéssel
- 1764 neuron, a lemorzsolódás aránya 0,4 (annak valószínűsége, hogy 0,4 az adott elem elesik az edzés során)
- Sűrű réteg (Logits réteg): 10 neuron, egy minden számjegyű célosztályhoz (0–9).
Három fontos modul használható a CNN létrehozására:
- conv2d (). Kétdimenziós konvolúciós réteget készít, argumentumként a szűrők számát, a szűrőmag méretét, a kitöltést és az aktiválási funkciót.
- max_pooling2d (). Kétdimenziós pooling réteget készít a max pooling algoritmus segítségével.
- sűrű(). Sűrű réteget készít a rejtett rétegekkel és egységekkel
Megad egy függvényt a CNN felépítéséhez. Nézzük meg részletesen, hogyan kell megalkotni az egyes építőelemeket, mielőtt mindent összefoglalnának a függvényben.
2. lépés: Bemeneti 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 be kell jelentenie a tenzor átalakítását és a tenzor alakjának átalakítását. Az első érv az adatok jellemzői, amelyeket a függvény argumentumában határozunk meg.
A kép magassága, szélessége és csatornája van. Az MNIST adatkészlet monokróm kép, 28x28 méretű. Az alak argumentumban -1 értékre állítottuk a kötegelt méretet, hogy az a [[x]] tulajdonságok alakját öltse. Előnye, hogy a köteg méretét hiperparaméterekkel állítják be. Ha a kötegméret 7-re van állítva, akkor a tenzor 5488 értéket táplál (28 * 28 * 7).
Step 3: Convolutional layer
# first Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Az első konvolúciós réteg 14 szűrővel rendelkezik, 5x5 magmérettel, azonos kitöltéssel. Ugyanaz a párnázás azt jelenti, hogy a kimeneti és a bemeneti tenzornak egyaránt azonos magassággal és szélességgel kell rendelkeznie. A Tensorflow nullákat ad hozzá a sorokhoz és oszlopokhoz az azonos méret biztosítása érdekében.
Használja a Relu aktiválási funkciót. A kimenet mérete [28, 28, 14] lesz.
4. lépés: Réteg összegyűjtése
A konvolúció után következő lépés a pooling számítás. Az összevont számítás csökkenti az adatok dimenzióit. Használhatja a max_pooling2d 2x2 méretű és 2 lépéses modult. Bemenetként az előző réteget használja. A kimenet mérete [batch_size, 14, 14, 14]
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
5. lépés: Második konvolúciós réteg és egyesítő réteg
A második konvolúciós réteg 32 szűrővel rendelkezik, a [batch_size, 14, 14, 32] kimeneti méret. A pooling réteg mérete megegyezik a korábbival, és a kimeneti alak [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 térképet le kell simítani, mielőtt összekapcsolódna a sűrű réteggel. Használhatja a modul átalakítását 7 * 7 * 36 méretben.
A sűrű réteg 1764 neuront fog összekapcsolni. Hozzáad egy Relu aktiválási funkciót. Ezenkívül hozzáad egy lemorzsolódási szabályt, amelynek mértéke 0,3, vagyis a súlyok 30 százaléka 0 lesz. Ne feledje, hogy a lemorzsolódás csak az edzés szakaszában történik. A cnn_model_fn függvénynek argumentummódja van annak kijelentésére, hogy a modellt ki kell-e képezni, vagy értékelni kell.
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 meghatározhatja az utolsó réteget a modell előrejelzésével. A kimeneti forma megegyezik a köteg méretével és 10-vel, a képek teljes számával.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Készíthet szótárt, amely tartalmazza az osztályokat és az egyes osztályok valószínűségét. A tf.argmax () with modul a legmagasabb értéket adja vissza, ha a logit rétegek vannak. 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é visszaadni a szótár előrejelzését, ha a mód előrejelzésre van állítva. Ezeket a kódokat hozzáadja az előrejelzések eloszlatásához
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 megtudta, hogy egy többosztályos modell veszteségfüggvénye kereszt-entró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)
Az utolsó lépés a modell optimalizálása, vagyis a súlyok legjobb értékeinek megtalálása. Ehhez használjon gradiens süllyedés optimalizálót, amelynek tanulási sebessége 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. Az értékelési módban azonban meg akarja jeleníteni a teljesítménymutatókat. A többosztályos modell teljesítménymutatói a pontossági mutatók. A Tensorflow modul két pontossággal, a címkékkel és a megjósolt értékekkel rendelkezik.
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 az első CNN-jét, és készen áll arra, hogy mindent belefoglaljon egy függvénybe annak érdekében, hogy ezt felhasználja a modell képzésére és értékelésére.
def cnn_model_fn(features, labels, mode):"""Model function for CNN."""# Input Layerinput_layer = tf.reshape(features["x"], [-1, 28, 28, 1])# Convolutional Layerconv1 = tf.layers.conv2d(inputs=input_layer,filters=32,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)# Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)# Convolutional Layer #2 and Pooling Layerconv2 = tf.layers.conv2d(inputs=pool1,filters=36,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)# Dense Layerpool2_flat = tf.reshape(pool2, [-1, 7 * 7 * 36])dense = tf.layers.dense(inputs=pool2_flat, units=7 * 7 * 36, activation=tf.nn.relu)dropout = tf.layers.dropout(inputs=dense, rate=0.4, training=mode == tf.estimator.ModeKeys.TRAIN)# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)predictions = {# Generate predictions (for PREDICT and EVAL mode)"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor")}if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)# Calculate Lossloss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)# Configure the Training Op (for TRAIN mode)if mode == tf.estimator.ModeKeys.TRAIN:optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())return tf.estimator.EstimatorSpec(mode=mode, loss=loss, train_op=train_op)# Add evaluation metrics Evaluation modeeval_metric_ops = {"accuracy": tf.metrics.accuracy(labels=labels, predictions=predictions["classes"])}return tf.estimator.EstimatorSpec(mode=mode, loss=loss, eval_metric_ops=eval_metric_ops)
Az alábbi lépések megegyeznek az előző oktatóanyagokkal.
Mindenekelőtt megad egy becslőt a CNN modellel.
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
A CNN-nek sokszor kell edzeni, ezért létrehoz egy naplózási kampót, hogy 50 iterációnként tárolja a softmax rétegek értékeit.
# Set up logging for predictionstensors_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 keveri az adatokat. Ne feledje, hogy 16.000 képzési lépést állítottunk be, sok időbe telhet az edzés. Legyél türelmes.
# Train the modeltrain_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_train_scaled},y=y_train,batch_size=100,num_epochs=None,shuffle=True)mnist_classifier.train(input_fn=train_input_fn,steps=16000,hooks=[logging_hook])
Most, hogy a modell vonatozik, kiértékelheti és kinyomtathatja az eredményeket
# Evaluate the model and print resultseval_input_fn = tf.estimator.inputs.numpy_input_fn(x={"x": X_test_scaled},y=y_test,num_epochs=1,shuffle=False)eval_results = mnist_classifier.evaluate(input_fn=eval_input_fn)print(eval_results)
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-08-05-12:52:41INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/mnist_convnet_model/model.ckpt-15652INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-08-05-12:52:56INFO:tensorflow:Saving dict for global step 15652: accuracy = 0.9589286, global_step = 15652, loss = 0.13894269{'accuracy': 0.9689286, 'loss': 0.13894269, 'global_step': 15652}
A jelenlegi architektúrával 97% -os pontosságot kap. A pontosság javítása érdekében megváltoztathatja az architektúrát, a kötegelt méretet és az iteráció számát. A CNN neurális hálózat sokkal jobban teljesített, mint az ANN vagy a logisztikai regresszió. A mesterséges ideghálózat oktatóanyagában 96% -os pontossággal rendelkezett, ami alacsonyabb a CNN-nél. Az előadások a CNN is lenyűgöző egy nagyobb kép set , mind a kifejezés a sebesség számítás és pontosságát.
Összegzés
A konvolúciós ideghálózat nagyon jól működik a kép értékeléséhez. Ez a típusú architektúra domináns az objektumok képből vagy videóból történő felismeréséhez.
A CNN felépítéséhez hat lépést kell végrehajtania:
1. lépés: Bemeneti réteg:
Ez a lépés átalakítja az adatokat. A forma megegyezik a pixelek számának négyzetgyökével. Például, ha egy képnek 156 képpontja van, akkor az alakja 26x26. Meg kell adnia, hogy a kép színes-e vagy sem. Ha igen, akkor 3 volt az alakja- 3 RGB-hez, különben 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
2. lépés: Konvolúciós réteg
Ezután létre kell hoznia a konvolúciós rétegeket. Különböző szűrőket alkalmaz, hogy a hálózat megtanulja a fontos funkciókat. Megadhatja 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)
3. lépés: Réteg összegyűjtése
A harmadik lépésben hozzáad egy pooling réteget. Ez a réteg csökkenti a bemenet méretét. Ezt úgy teszi, hogy felveszi az almátrix maximális értékét. Például, ha az almátrix [3,1,3,2], akkor a pooling megadja a maximumot, ami 3.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
4. lépés: Adja hozzá a konvolúciós és a pooling réteget
Ebben a lépésben annyit adhat hozzá, amennyit csak akar konv. És egyesítő rétegek. A Google több mint 20 konv. Réteggel rendelkező architektúrát használ.
5. lépés: Sűrű réteg
Az 5. lépés simítja az előzőt egy teljesen összekapcsolt réteg létrehozásához. Ebben a lépésben különböző aktiválási funkciókat használhat, és hozzáadhat egy lemorzsolódó hatást.
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)
6. lépés: Logit réteg
Az utolsó lépés az előrejelzés.
logits = tf.layers.dense(inputs=dropout, units=10)