Was ist ein Faltungs-Neuronales Netz?
Das Faltungs-Neuronale Netzwerk, auch als Convnets oder CNN bekannt, ist eine bekannte Methode in Computer-Vision-Anwendungen. Diese Art von Architektur ist dominant, um Objekte aus einem Bild oder Video zu erkennen.
In diesem Tutorial erfahren Sie, wie Sie ein Convnet erstellen und wie Sie mit TensorFlow den handschriftlichen Datensatz lösen.
In diesem Tutorial lernen Sie
- Faltungs-Neuronales Netz
- Architektur eines Faltungs-Neuronalen Netzes
- Komponenten von Convnets
- Trainiere CNN mit TensorFlow
- Schritt 1: Datensatz hochladen
- Schritt 2: Eingabeebene
- Schritt 3: Faltungsschicht
- Schritt 4: Pooling-Schicht
- Schritt 5: Zweite Faltungsschicht und Pooling-Schicht
- Schritt 6: Dichte Schicht
- Schritt 7: Logit Layer
Architektur eines Faltungs-Neuronalen Netzes
Denken Sie an Facebook. Vor einigen Jahren, nachdem Sie ein Bild in Ihr Profil hochgeladen haben, wurden Sie aufgefordert, dem Gesicht auf dem Bild manuell einen Namen hinzuzufügen. Heutzutage verwendet Facebook Convnet, um Ihren Freund automatisch im Bild zu markieren.
Ein Faltungsnetzwerk ist nicht sehr schwer zu verstehen. Ein Eingabebild wird während der Faltungsphase verarbeitet und später mit einem Etikett versehen.
Eine typische Convnet-Architektur kann im folgenden Bild zusammengefasst werden. Zunächst wird ein Bild in das Netzwerk übertragen. Dies wird als Eingabebild bezeichnet. Dann durchläuft das Eingabebild eine unendliche Anzahl von Schritten; Dies ist der Faltungsteil des Netzwerks. Schließlich kann das neuronale Netzwerk die Ziffer auf dem Bild vorhersagen.
Ein Bild besteht aus einer Anordnung von Pixeln mit Höhe und Breite. Ein Graustufenbild hat nur einen Kanal, während das Farbbild drei Kanäle hat (jeder für Rot, Grün und Blau). Ein Kanal ist übereinander gestapelt. In diesem Tutorial verwenden Sie ein Graustufenbild mit nur einem Kanal. Jedes Pixel hat einen Wert von 0 bis 255, um die Intensität der Farbe widerzuspiegeln. Beispielsweise zeigt ein Pixel gleich 0 eine weiße Farbe, während ein Pixel mit einem Wert nahe 255 dunkler ist.
Schauen wir uns ein Bild an, das im MNIST-Datensatz gespeichert ist. Das folgende Bild zeigt, wie das Bild von links in einem Matrixformat dargestellt wird. Beachten Sie, dass die ursprüngliche Matrix so standardisiert wurde, dass sie zwischen 0 und 1 liegt. Bei dunkleren Farben beträgt der Wert in der Matrix etwa 0,9, während weiße Pixel den Wert 0 haben.
Faltungsoperation
Die kritischste Komponente im Modell ist die Faltungsschicht. Dieser Teil zielt darauf ab, die Größe des Bildes für schnellere Berechnungen der Gewichte zu reduzieren und seine Verallgemeinerung zu verbessern.
Während des Faltungsteils behält das Netzwerk die wesentlichen Merkmale des Bildes bei und schließt irrelevantes Rauschen aus. Zum Beispiel lernt das Modell, wie man einen Elefanten anhand eines Bildes mit einem Berg im Hintergrund erkennt. Wenn Sie ein traditionelles neuronales Netzwerk verwenden, weist das Modell allen Pixeln eine Gewichtung zu, einschließlich derjenigen vom Berg, die nicht unbedingt erforderlich sind und das Netzwerk irreführen können.
Stattdessen verwendet ein Faltungs-Neuronales Netzwerk eine mathematische Technik, um nur die relevantesten Pixel zu extrahieren. Diese mathematische Operation nennt man Faltung. Diese Technik ermöglicht es dem Netzwerk, auf jeder Ebene immer komplexere Merkmale zu lernen. Die Faltung unterteilt die Matrix in kleine Teile, um die wichtigsten Elemente in jedem Teil zu lernen.
Komponenten von Convnets
Es gibt vier Komponenten eines Convnets
- Faltung
- Nichtlinearität (ReLU)
- Pooling oder Sub Sampling
- Klassifizierung (vollständig verbundene Schicht)
- Faltung
Der Zweck der Faltung besteht darin, die Merkmale des Objekts auf dem Bild lokal zu extrahieren. Dies bedeutet, dass das Netzwerk bestimmte Muster im Bild lernt und sie überall im Bild erkennen kann.
Faltung ist eine elementweise Multiplikation. Das Konzept ist leicht zu verstehen. Der Computer scannt einen Teil des Bildes, normalerweise mit einer Größe von 3 x 3, und multipliziert es mit einem Filter. Die Ausgabe der elementweisen Multiplikation wird als Feature-Map bezeichnet. Dieser Schritt wird wiederholt, bis das gesamte Bild gescannt ist. Beachten Sie, dass nach der Faltung die Größe des Bildes verringert wird.
Unten finden Sie eine URL, mit der Sie in Aktion sehen können, wie die Faltung funktioniert.
Es stehen zahlreiche Kanäle zur Verfügung. Nachfolgend haben wir einige der Kanäle aufgelistet. Sie können sehen, dass jeder Filter einen bestimmten Zweck hat. Beachten Sie im Bild unten; Der Kernel ist ein Synonym für den Filter.
Quelle
Arithmetik hinter der Faltung
In der Faltungsphase wird der Filter auf eine kleine Anordnung von Pixeln im Bild angewendet. Der Filter bewegt sich entlang des Eingabebildes mit einer allgemeinen Form von 3x3 oder 5x5. Dies bedeutet, dass das Netzwerk diese Fenster über das gesamte Eingabebild schiebt und die Faltung berechnet. Das Bild unten zeigt, wie die Faltung funktioniert. Die Größe des Patches beträgt 3 x 3, und die Ausgabematrix ist das Ergebnis der elementweisen Operation zwischen der Bildmatrix und dem Filter.
Quelle
Sie stellen fest, dass die Breite und Höhe der Ausgabe von der Breite und Höhe der Eingabe abweichen kann. Es passiert wegen des Randeffekts.
Randeffekt
Das Bild verfügt über eine 5x5-Funktionskarte und einen 3x3-Filter. In der Mitte gibt es nur ein Fenster, in dem der Filter ein 3x3-Raster anzeigen kann. Die Ausgabe-Feature-Map wird zusammen mit einer 3x3-Dimension um zwei Kacheln verkleinert.
Um die gleiche Ausgabedimension wie die Eingabedimension zu erhalten, müssen Sie eine Auffüllung hinzufügen. Das Auffüllen besteht aus dem Hinzufügen der richtigen Anzahl von Zeilen und Spalten auf jeder Seite der Matrix. Dadurch kann die Faltung jede Eingabekachel zentrieren. In der Abbildung unten hat die Eingabe- / Ausgabematrix die gleiche Abmessung 5x5
Wenn Sie das Netzwerk definieren, werden die gefalteten Funktionen durch drei Parameter gesteuert:
- Tiefe: Definiert die Anzahl der Filter, die während der Faltung angewendet werden sollen. Im vorherigen Beispiel haben Sie eine Tiefe von 1 gesehen, was bedeutet, dass nur ein Filter verwendet wird. In den meisten Fällen gibt es mehr als einen Filter. Das Bild unten zeigt die Vorgänge in einer Situation mit drei Filtern
- Schritt: Definiert die Anzahl der "Pixelsprünge" zwischen zwei Schichten. Wenn der Schritt gleich 1 ist, bewegen sich die Fenster mit einer Pixelstreuung von eins. Wenn der Schritt gleich zwei ist, springen die Fenster um 2 Pixel. Wenn Sie den Schritt erhöhen, erhalten Sie kleinere Feature-Maps.
Beispiel Schritt 1
Bildschritt 2
- Null-Auffüllung: Bei einer Auffüllung wird eine entsprechende Anzahl von Zeilen und Spalten auf jeder Seite der Eingabe-Feature-Maps hinzugefügt. In diesem Fall hat die Ausgabe dieselbe Dimension wie die Eingabe.
- Nichtlinearität (ReLU)
Am Ende der Faltungsoperation unterliegt der Ausgang einer Aktivierungsfunktion, um Nichtlinearität zu ermöglichen. Die übliche Aktivierungsfunktion für convnet ist das Relu. Alle Pixel mit einem negativen Wert werden durch Null ersetzt.
- Max-Pooling-Betrieb
Dieser Schritt ist leicht zu verstehen. Der Zweck des Poolings besteht darin, die Dimensionalität des Eingabebildes zu verringern. Die Schritte werden ausgeführt, um die Rechenkomplexität der Operation zu verringern. Durch Verringern der Dimensionalität muss das Netzwerk mit geringeren Gewichten berechnet werden, sodass eine Überanpassung verhindert wird.
In dieser Phase müssen Sie die Größe und den Schritt definieren. Eine Standardmethode zum Poolen des Eingabebilds besteht darin, den Maximalwert der Feature-Map zu verwenden. Schauen Sie sich das Bild unten an. Das "Pooling" überprüft eine Vier-Submatrix der 4x4-Feature-Map und gibt den Maximalwert zurück. Das Pooling nimmt den Maximalwert eines 2x2-Arrays an und verschiebt dieses Fenster dann um zwei Pixel. Zum Beispiel ist die erste Submatrix [3,1,3,2], das Pooling gibt das Maximum zurück, das 3 ist.
Es gibt eine andere Pooling-Operation wie den Mittelwert.
Dieser Vorgang reduziert die Größe der Feature-Map aggressiv
- Vollständig verbundene Schichten
Der letzte Schritt besteht darin, ein traditionelles künstliches neuronales Netzwerk aufzubauen, wie Sie es im vorherigen Tutorial getan haben. Sie verbinden alle Neuronen von der vorherigen Ebene mit der nächsten Ebene. Sie verwenden eine Softmax-Aktivierungsfunktion, um die Nummer auf dem Eingabebild zu klassifizieren.
Rekapitulieren:
Das Faltungs-Neuronale Netz kompiliert verschiedene Schichten, bevor eine Vorhersage getroffen wird. Ein neuronales Netzwerk hat:
- Eine Faltungsschicht
- Relu Aktivierungsfunktion
- Pooling-Schicht
- Dicht verbundene Schicht
Die Faltungsschichten wenden unterschiedliche Filter auf einen Teilbereich des Bildes an. Die Relu-Aktivierungsfunktion fügt Nichtlinearität hinzu, und die Pooling-Ebenen reduzieren die Dimensionalität der Feature-Maps.
Alle diese Ebenen extrahieren wichtige Informationen aus den Bildern. Zuletzt wird die Feature-Map einem primären, vollständig verbundenen Layer mit einer Softmax-Funktion zugeführt, um eine Vorhersage zu treffen.
Trainiere CNN mit TensorFlow
Nachdem Sie mit dem Baustein eines Convnets vertraut sind, können Sie mit TensorFlow einen erstellen. Wir werden den MNIST-Datensatz für die Bildklassifizierung verwenden.
Die Datenaufbereitung ist dieselbe wie im vorherigen Tutorial. Sie können die Codes ausführen und direkt zur Architektur des CNN springen.
Sie werden die folgenden Schritte ausführen:
Schritt 1: Datensatz hochladen
Schritt 2: Eingabeebene
Schritt 3: Faltungsschicht
Schritt 4: Pooling-Schicht
Schritt 5: Zweite Faltungsschicht und Pooling-Schicht
Schritt 6: Dichte Schicht
Schritt 7: Logit Layer
Schritt 1: Datensatz hochladen
Der MNIST-Datensatz ist mit scikit verfügbar, um unter dieser URL zu lernen. Bitte laden Sie es herunter und speichern Sie es in Downloads. Sie können es mit fetch_mldata ('MNIST original') hochladen.
Erstellen Sie ein Zug- / Test-Set
Sie müssen den Datensatz mit train_test_split teilen
Skalieren Sie die Funktionen
Schließlich können Sie die Funktion mit MinMaxScaler skalieren
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:]
Definieren Sie die CNN
Ein CNN verwendet Filter für das Rohpixel eines Bildes, um das Detailmuster im Vergleich zum globalen Muster mit einem herkömmlichen neuronalen Netz zu lernen. Um ein CNN zu erstellen, müssen Sie Folgendes definieren:
- Eine Faltungsebene: Wenden Sie n Filter auf die Feature-Map an. Nach der Faltung müssen Sie eine Relu-Aktivierungsfunktion verwenden, um dem Netzwerk Nichtlinearität hinzuzufügen.
- Pooling-Schicht: Der nächste Schritt nach der Faltung besteht darin, das Merkmal max. Der Zweck besteht darin, die Dimensionalität der Feature-Map zu reduzieren, um eine Überanpassung zu verhindern und die Rechengeschwindigkeit zu verbessern. Max Pooling ist die herkömmliche Technik, bei der die Feature-Maps in Unterregionen (normalerweise mit einer Größe von 2 x 2) unterteilt werden und nur die Maximalwerte beibehalten werden.
- Vollständig verbundene Schichten: Alle Neuronen der vorherigen Schichten sind mit den nächsten Schichten verbunden. Das CNN klassifiziert das Etikett gemäß den Merkmalen aus den Faltungsschichten und reduziert es mit der Pooling-Schicht.
CNN-Architektur
- Faltungsschicht: Wendet 14 5x5-Filter (Extrahieren von 5x5-Pixel-Unterregionen) mit ReLU-Aktivierungsfunktion an
- Pooling Layer: Führt ein maximales Pooling mit einem 2x2-Filter und einem Schritt von 2 durch (was angibt, dass sich gepoolte Regionen nicht überlappen).
- Faltungsschicht: Wendet 36 5x5-Filter mit ReLU-Aktivierungsfunktion an
- Pooling Layer # 2: Führt erneut ein maximales Pooling mit einem 2x2-Filter und einem Schritt von 2 durch
- 1.764 Neuronen mit einer Dropout-Regularisierungsrate von 0,4 (Wahrscheinlichkeit von 0,4, dass ein bestimmtes Element während des Trainings fallen gelassen wird)
- Dichte Schicht (Logits-Schicht): 10 Neuronen, eine für jede Ziffernzielklasse (0-9).
Es gibt drei wichtige Module zum Erstellen eines CNN:
- conv2d (). Konstruiert eine zweidimensionale Faltungsschicht mit der Anzahl der Filter, der Filterkerngröße, dem Auffüllen und der Aktivierungsfunktion als Argumenten.
- max_pooling2d (). Konstruiert eine zweidimensionale Pooling-Schicht unter Verwendung des Max-Pooling-Algorithmus.
- dicht(). Erstellt eine dichte Ebene mit den verborgenen Ebenen und Einheiten
Sie definieren eine Funktion zum Erstellen des CNN. Lassen Sie uns im Detail sehen, wie Sie jeden Baustein konstruieren, bevor Sie alles in der Funktion zusammenfassen.
Schritt 2: Eingabeebene
def cnn_model_fn(features, labels, mode):input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Sie müssen einen Tensor mit der Form der Daten definieren. Dafür können Sie das Modul tf.reshape verwenden. In diesem Modul müssen Sie den Tensor für die Umformung und die Form des Tensors deklarieren. Das erste Argument sind die Merkmale der Daten, die im Argument der Funktion definiert sind.
Ein Bild hat eine Höhe, eine Breite und einen Kanal. Der MNIST-Datensatz ist ein monochrones Bild mit einer Größe von 28 x 28. Wir setzen die Stapelgröße im Formargument auf -1, damit sie die Form der Features ["x"] annimmt. Der Vorteil besteht darin, dass die Hyperparameter für die Stapelgröße angepasst werden. Wenn die Chargengröße auf 7 eingestellt ist, speist der Tensor 5.488 Werte (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)
Die erste Faltungsschicht hat 14 Filter mit einer Kerngröße von 5 x 5 bei gleicher Auffüllung. Die gleiche Polsterung bedeutet, dass sowohl der Ausgangstensor als auch der Eingangstensor dieselbe Höhe und Breite haben sollten. Tensorflow fügt den Zeilen und Spalten Nullen hinzu, um die gleiche Größe sicherzustellen.
Sie verwenden die Relu-Aktivierungsfunktion. Die Ausgabegröße ist [28, 28, 14].
Schritt 4: Pooling-Schicht
Der nächste Schritt nach der Faltung ist die Pooling-Berechnung. Die Pooling-Berechnung reduziert die Dimensionalität der Daten. Sie können das Modul max_pooling2d mit einer Größe von 2x2 und einem Schritt von 2 verwenden. Sie verwenden die vorherige Ebene als Eingabe. Die Ausgabegröße ist [batch_size, 14, 14, 14].
# first Pooling Layerpool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Schritt 5: Zweite Faltungsschicht und Pooling-Schicht
Die zweite Faltungsschicht hat 32 Filter mit einer Ausgabegröße von [batch_size, 14, 14, 32]. Die Pooling-Ebene hat dieselbe Größe wie zuvor und die Ausgabeform ist [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)
Schritt 6: Dichte Schicht
Anschließend müssen Sie die vollständig verbundene Ebene definieren. Die Feature-Map muss vor dem Verbinden mit der dichten Ebene abgeflacht werden. Sie können die Modulumformung mit einer Größe von 7 * 7 * 36 verwenden.
Die dichte Schicht verbindet 1764 Neuronen. Sie fügen eine Relu-Aktivierungsfunktion hinzu. Außerdem fügen Sie einen Dropout-Regularisierungsterm mit einer Rate von 0,3 hinzu, was bedeutet, dass 30 Prozent der Gewichte auf 0 gesetzt werden. Beachten Sie, dass der Dropout nur während der Trainingsphase stattfindet. Die Funktion cnn_model_fn verfügt über einen Argumentmodus, um zu deklarieren, ob das Modell trainiert oder ausgewertet werden muss.
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)
Schritt 7: Logit Layer
Schließlich können Sie die letzte Ebene mit der Vorhersage des Modells definieren. Die Ausgabeform entspricht der Stapelgröße und 10 der Gesamtzahl der Bilder.
# Logits Layerlogits = tf.layers.dense(inputs=dropout, units=10)
Sie können ein Wörterbuch erstellen, das die Klassen und die Wahrscheinlichkeit jeder Klasse enthält. Das Modul tf.argmax () mit gibt den höchsten Wert zurück, wenn die Logit-Ebenen. Die Softmax-Funktion gibt die Wahrscheinlichkeit jeder Klasse zurück.
predictions = {# Generate predictions"classes": tf.argmax(input=logits, axis=1),"probabilities": tf.nn.softmax(logits, name="softmax_tensor") }
Sie möchten die Wörterbuchvorhersage nur zurückgeben, wenn der Modus auf Vorhersage eingestellt ist. Sie fügen diese Codes hinzu, um die Vorhersagen anzuzeigen
if mode == tf.estimator.ModeKeys.PREDICT:return tf.estimator.EstimatorSpec(mode=mode, predictions=predictions)
Der nächste Schritt besteht darin, den Verlust des Modells zu berechnen. Im letzten Tutorial haben Sie gelernt, dass die Verlustfunktion für ein Mehrklassenmodell die Kreuzentropie ist. Der Verlust kann leicht mit dem folgenden Code berechnet werden:
# Calculate Loss (for both TRAIN and EVAL modes)loss = tf.losses.sparse_softmax_cross_entropy(labels=labels, logits=logits)
Der letzte Schritt besteht darin, das Modell zu optimieren, dh die besten Werte der Gewichte zu finden. Dazu verwenden Sie einen Gradientenabstiegsoptimierer mit einer Lernrate von 0,001. Ziel ist es, den Verlust zu minimieren
optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.001)train_op = optimizer.minimize(loss=loss,global_step=tf.train.get_global_step())
Sie sind mit dem CNN fertig. Sie möchten jedoch die Leistungsmetriken im Bewertungsmodus anzeigen. Die Leistungsmetriken für ein Modell mit mehreren Klassen sind die Genauigkeitsmetriken. Tensorflow ist mit einer Modulgenauigkeit mit zwei Argumenten ausgestattet, den Beschriftungen und den vorhergesagten Werten.
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)
Das ist es. Sie haben Ihr erstes CNN erstellt und sind bereit, alles in eine Funktion zu packen, um damit das Modell zu trainieren und zu bewerten.
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)
Die folgenden Schritte entsprechen den vorherigen Tutorials.
Zunächst definieren Sie einen Schätzer mit dem CNN-Modell.
# Create the Estimatormnist_classifier = tf.estimator.Estimator(model_fn=cnn_model_fn, model_dir="train/mnist_convnet_model")
Das Trainieren eines CNN dauert viele Male. Daher erstellen Sie alle 50 Iterationen einen Protokollierungs-Hook, um die Werte der Softmax-Ebenen zu speichern.
# Set up logging for predictionstensors_to_log = {"probabilities": "softmax_tensor"}logging_hook = tf.train.LoggingTensorHook(tensors=tensors_to_log, every_n_iter=50)
Sie können das Modell schätzen. Sie legen eine Stapelgröße von 100 fest und mischen die Daten. Beachten Sie, dass wir Trainingsschritte von 16.000 festlegen. Das Training kann viel Zeit in Anspruch nehmen. Sei geduldig.
# 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])
Nachdem das Modell trainiert wurde, können Sie es auswerten und die Ergebnisse ausdrucken
# 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}
Mit der aktuellen Architektur erhalten Sie eine Genauigkeit von 97%. Sie können die Architektur, die Stapelgröße und die Anzahl der Iterationen ändern, um die Genauigkeit zu verbessern. Das neuronale CNN-Netzwerk hat eine weitaus bessere Leistung erbracht als ANN oder logistische Regression. Im Tutorial zum künstlichen neuronalen Netzwerk hatten Sie eine Genauigkeit von 96%, was dem CNN entspricht. Die Leistungen des CNN sind beeindruckend mit einem größeren Bild Set , sowohl in der Bezeichnung der Geschwindigkeitsberechnung und Genauigkeit.
Zusammenfassung
Ein Faltungs-Neuronales Netzwerk funktioniert sehr gut, um das Bild zu bewerten. Diese Art von Architektur ist dominant, um Objekte aus einem Bild oder Video zu erkennen.
Um ein CNN zu erstellen, müssen Sie sechs Schritte ausführen:
Schritt 1: Eingabeebene:
Dieser Schritt formt die Daten neu. Die Form entspricht der Quadratwurzel der Pixelanzahl. Wenn ein Bild beispielsweise 156 Pixel hat, ist die Form 26 x 26. Sie müssen angeben, ob das Bild Farbe hat oder nicht. Wenn ja, dann hatten Sie 3 zur Form - 3 für RGB -, sonst 1.
input_layer = tf.reshape(tensor = features["x"],shape =[-1, 28, 28, 1])
Schritt 2: Faltungsschicht
Als nächstes müssen Sie die Faltungsebenen erstellen. Sie wenden verschiedene Filter an, damit das Netzwerk wichtige Funktionen erlernen kann. Sie geben die Größe des Kernels und die Anzahl der Filter an.
conv1 = tf.layers.conv2d(inputs=input_layer,filters=14,kernel_size=[5, 5],padding="same",activation=tf.nn.relu)
Schritt 3: Pooling-Schicht
Im dritten Schritt fügen Sie eine Pooling-Ebene hinzu. Diese Ebene verringert die Größe der Eingabe. Dazu wird der Maximalwert einer Submatrix verwendet. Wenn die Submatrix beispielsweise [3,1,3,2] ist, gibt das Pooling das Maximum zurück, das 3 ist.
pool1 = tf.layers.max_pooling2d(inputs=conv1, pool_size=[2, 2], strides=2)
Schritt 4: Faltungsschicht und Poolschicht hinzufügen
In diesem Schritt können Sie beliebig viele Conv- und Pooling-Layer hinzufügen. Google verwendet eine Architektur mit mehr als 20 Conv-Ebenen.
Schritt 5: Dichte Schicht
In Schritt 5 wird der vorherige Schritt abgeflacht, um vollständig verbundene Ebenen zu erstellen. In diesem Schritt können Sie verschiedene Aktivierungsfunktionen verwenden und einen Dropout-Effekt hinzufügen.
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)
Schritt 6: Logit Layer
Der letzte Schritt ist die Vorhersage.
logits = tf.layers.dense(inputs=dropout, units=10)