CNN-Bildklassifizierung in TensorFlow mit Schritten und Beispielen

Was ist Convolutional Neural Network?

Faltungs-Neuronales NetzConvolutional Neural Networks (CNNs), auch bekannt als Convolutional Neural Networks, sind eine etablierte Methode in der Computer Vision. Sie gehören zu den tiefen neuronalen Netzen und werden zur Analyse visueller Daten eingesetzt. Diese Architektur ist besonders geeignet für die Objekterkennung in Bildern oder Videos. Sie findet Anwendung in Bereichen wie Bild- und Videoerkennung, natürlicher Sprachverarbeitung und Empfehlungssystemen.

ArchiStruktur eines Faltungs-Neuronalen Netzwerks

Denken Sie an Facebook vor ein paar Jahren: Nachdem Sie ein Bild in Ihr Profil hochgeladen hatten, wurden Sie aufgefordert, dem Gesicht auf dem Bild manuell einen Namen hinzuzufügen. Heutzutage verwendet Facebook convnet, um Ihren Freund automatisch auf dem Bild zu markieren.

Ein Convolutional Neural Network zur Bildklassifizierung ist nicht sehr schwer zu verstehen. Ein Eingabebild wird während der Faltungsphase verarbeitet und später mit einem Label versehen.

Eine typische Architektur eines Convolutional Neural Networks (CNN) lässt sich in der folgenden Abbildung zusammenfassen. Zunächst wird ein Bild an das Netzwerk übergeben; dies wird als Eingabebild bezeichnet. Anschließend durchläuft das Eingabebild eine Reihe von Schritten; dies ist der Faltungsteil des Netzwerks. Schließlich kann das neuronale Netzwerk die Ziffer im Bild vorhersagen.

Ein Bild besteht aus einer Anordnung von Pixeln mit bestimmter Höhe und Breite. Ein Graustufenbild hat nur einen Kanal, während ein Farbbild drei Kanäle besitzt (jeweils einen für Rot, Grün und Blau). Die Kanäle sind übereinander angeordnet. In diesem Tutorial verwenden Sie ein Graustufenbild mit nur einem Kanal. Jeder Pixel hat einen Wert zwischen 0 und 255, der die Farbintensität widerspiegelt. Beispielsweise stellt ein Pixel mit dem Wert 0 Weiß dar, während ein Pixel mit einem Wert nahe 255 dunkler ist.

Werfen wir einen Blick auf ein im gespeichertes Bild MNIST-DatensatzDie Abbildung unten zeigt, wie das Bild links in Matrixform dargestellt wird. Die ursprüngliche Matrix ist auf einen Bereich zwischen 0 und 1 standardisiert. Dunklere Farben haben einen Matrixwert von etwa 0.9, während weiße Pixel den Wert 0 aufweisen.

Faltungsoperation

Die wichtigste Komponente des Modells ist die Faltungsschicht. Diese Schicht dient dazu, die Bildgröße zu reduzieren, um die Gewichte schneller berechnen zu können und die Generalisierung zu verbessern.

Während des Faltungsteils behält das Netzwerk die wesentlichen Merkmale des Bildes bei und schließt irrelevantes Rauschen aus. Das Modell lernt beispielsweise, wie man einen Elefanten anhand eines Bildes mit einem Berg im Hintergrund erkennt. Wenn Sie ein herkömmliches neuronales Netzwerk verwenden, weist das Modell allen Pixeln eine Gewichtung zu, auch denen vom Berg, was nicht unbedingt erforderlich ist und das Netzwerk irreführen kann.

Stattdessen a Keras Ein Convolutional Neural Network (CNN) verwendet eine mathematische Technik, um …tracEs werden nur die relevantesten Pixel extrahiert. Diese mathematische Operation heißt Faltung. Diese Technik ermöglicht es dem Netzwerk, in jeder Schicht zunehmend komplexere Merkmale zu erlernen. Die Faltung teilt die Matrix in kleine Teile, um die wichtigsten Elemente innerhalb jedes Teils zu extrahieren.

Komponenten des Convolutional Neural Network (ConvNet oder CNN)

Ein Faltungsnetz besteht aus vier Komponenten:

1. Windung
2. Nichtlinearität (ReLU)
3. Pooling oder Subsampling
4. Klassifizierung (vollständig verbundene Schicht)

Windung

Der Zweck der Faltung besteht darin,tracDie Merkmale des Objekts im Bild werden lokal erfasst. Das bedeutet, dass das Netzwerk spezifische Muster innerhalb des Bildes lernt und diese überall im Bild erkennen kann.

Die Faltung ist eine elementweise Multiplikation. Das Prinzip ist leicht verständlich. Der Computer scannt einen Bildausschnitt, üblicherweise mit den Dimensionen 3×3, und multipliziert ihn mit einem Filter. Das Ergebnis dieser elementweisen Multiplikation wird als Merkmalskarte bezeichnet. Dieser Schritt wird wiederholt, bis das gesamte Bild gescannt ist. Nach der Faltung ist die Bildgröße reduziert.

Das untenstehende Diagramm zeigt, wie ein Ausschnitt des Bildes mit dem Filter multipliziert wird, um eine einzelne Zelle der Feature-Map zu erzeugen.

Die untenstehende Animation zeigt dieselbe Faltung, die über das gesamte Bild verläuft.

Es stehen zahlreiche Filter zur Verfügung. Im Folgenden haben wir einige davon aufgelistet. Jeder Filter hat einen bestimmten Zweck. Beachten Sie, dass im Bild unten der Begriff „Kernel“ ein Synonym für den Filter ist.

Arithmetik hinter der Faltung

Die Faltungsphase wendet den Filter auf ein kleines Pixel-Array innerhalb des Bildes an. Der Filter bewegt sich entlang des Eingabebildes mit einer typischen Form von 3×3 oder 5×5 Pixeln. Das Netzwerk verschiebt diese Fenster also über das gesamte Eingabebild und berechnet die Faltung. Die Animation unten veranschaulicht die Funktionsweise der Faltung. Die Größe des Ausschnitts beträgt 3×3 Pixel, und die Ausgabematrix ist das Ergebnis der elementweisen Operation zwischen der Bildmatrix und dem Filter.

Sie bemerken, dass die Breite und Höhe der Ausgabe von der Breite und Höhe der Eingabe abweichen kann. Dies geschieht aufgrund des Grenzeffekts.

Grenzeffekt

Das Bild enthält eine 5×5-Feature-Map und einen 3×3-Filter. Es gibt nur ein Fenster in der Mitte, durch das der Filter ein 3×3-Raster ausblenden kann. Die resultierende Feature-Map wird auf jeder Achse um zwei Kacheln verkleinert, sodass eine 3×3-Dimension verbleibt.

Um die gleiche Ausgabedimension wie die Eingabedimension zu erhalten, muss Padding hinzugefügt werden. Padding bedeutet, die richtige Anzahl an Zeilen und Spalten auf jeder Seite der Matrix hinzuzufügen. Dadurch wird sichergestellt, dass die Faltung jedes Eingabefeld zentriert. In der Abbildung unten haben die Eingabe- und Ausgabematrix die gleiche Dimension, nämlich 5×5.

Wenn Sie das Netzwerk definieren, werden die gefalteten Features durch drei Parameter gesteuert:

Tiefe: Sie definiert die Anzahl der Filter, die während der Faltung angewendet werden. Im vorherigen Beispiel wurde eine Tiefe von 1 verwendet, was bedeutet, dass nur ein Filter zum Einsatz kommt. In den meisten Fällen werden jedoch mehrere Filter verwendet. Die folgende Animation veranschaulicht die Operationen mit drei Filtern.

Schreiten: Der Wert definiert die Anzahl der Pixel, die zwischen zwei Segmenten gesprungen werden. Bei einem Stride von 1 bewegt sich das Fenster um ein Pixel. Bei einem Stride von 2 springt das Fenster um zwei Pixel. Durch Erhöhen des Strides werden die Feature-Maps kleiner. Die beiden folgenden Diagramme vergleichen einen Stride von 1 mit einem Stride von 2.

Beispielschritt 1

Schritt 2

Nullauffüllung: Beim Padding werden den Eingabe-Feature-Maps auf beiden Seiten eine entsprechende Anzahl von Zeilen und Spalten hinzugefügt. Dadurch hat die Ausgabe die gleiche Dimension wie die Eingabe.

Nichtlinearität (ReLU)

Am Ende der Faltungsoperation wird der Output einer Aktivierungsfunktion unterzogen, um Nichtlinearität zu ermöglichen. Die übliche Aktivierungsfunktion für ein Convolutional Neural Network (CNN) ist ReLU. Alle Pixel mit einem negativen Wert werden durch Null ersetzt.

Pooling OperaProduktion

Dieser Schritt ist leicht verständlich. Das Pooling dient dazu, die Dimensionalität des Eingabebildes zu reduzieren. Die Schritte werden durchgeführt, um die Rechenkomplexität der Operation zu verringern. Durch die Reduzierung der Dimensionalität muss das Netzwerk weniger Gewichte berechnen, wodurch ein Überanpassen verhindert wird.

In diesem Schritt müssen Sie die Größe und die Schrittweite festlegen. Eine gängige Methode zum Pooling des Eingabebildes besteht darin, den Maximalwert der Feature-Map zu verwenden. Betrachten Sie die Abbildung unten. Beim Pooling werden vier Teilmatrizen der 4×4-Feature-Map durchsucht und der Maximalwert zurückgegeben. Das Pooling nimmt den Maximalwert eines 2×2-Arrays und verschiebt dieses Fenster dann um zwei Pixel. Beispielsweise ist die erste Teilmatrix [3,1,3,2], daher gibt das Pooling den Maximalwert 3 zurück.

Es gibt eine weitere Pooling-Operation wie den Mittelwert.

Diese Operation reduziert die Größe der Feature-Map auf aggressive Weise.

Vollständig verbundene Ebenen

Der letzte Schritt besteht im Aufbau eines traditionellen künstliche neuronale Netz wie Sie es im vorherigen Tutorial getan haben. Sie verbinden alle Neuronen der vorherigen Schicht mit der nächsten Schicht. Sie verwenden eine Softmax-Aktivierungsfunktion, um die Zahl auf dem Eingabebild zu klassifizieren.

Recap:

Ein Convolutional Neural Network (CNN) von TensorFlow kompiliert verschiedene Schichten, bevor es eine Vorhersage trifft. Ein neuronales Netzwerk besteht aus:

• 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-Schichten reduzieren die Dimensionalität der Merkmalskarten.

Alle diese Schichten z.B.tracDie wesentlichen Informationen werden aus den Bildern extrahiert. Schließlich werden die Feature-Maps einer vollständig verbundenen Schicht mit einer Softmax-Funktion zugeführt, um eine Vorhersage zu treffen.

Trainieren Sie CNN mit TensorFlow

Nachdem Sie nun mit den Bausteinen eines Faltungsnetzes vertraut sind, können Sie selbst eines erstellen. TensorFlow. Wir werden den MNIST-Datensatz für die CNN-Bildklassifizierung verwenden.

Die Datenaufbereitung erfolgt wie im vorherigen Tutorial. Sie können die Codes ausführen und direkt zur Architektur des CNN springen.

Für die Bildklassifizierung mit CNN führen Sie die folgenden Schritte aus:

1. Schritt 1: Datensatz hochladen
2. Schritt 2: Eingabeebene
3. Schritt 3: Faltungsschicht
4. Schritt 4: Pooling-Schicht
5. Schritt 5: Zweite Faltungsschicht und Pooling Ebene
6. Schritt 6: Dichte Schicht
7. Schritt 7: Logit-Schicht

Versionshinweis: Die folgenden Auflistungen beziehen sich auf TensorFlow 1.x. In TensorFlow 2 existieren der Namespace `tf.layers` und die Funktion `tf.estimator.inputs.numpy_input_fn` nicht mehr; die Entsprechungen sind `tf.keras.layers.Conv2D` und `Max`.Pooling2D, Dense und Dropout wurden in einem tf.keras.Model zusammengefasst und mit model.fit() trainiert. Lesen Sie die Schritte, um die Funktionsweise jeder Schicht zu verstehen, und wenden Sie diese dann auf die Keras-API an.

Schritt 1: Datensatz hochladen

Der MNIST-Datensatz ist über scikit-learn verfügbar. Bitte laden Sie ihn herunter und speichern Sie ihn im Ordner „Downloads“. Sie können ihn mit `fetch_mldata('MNIST original')` hochladen.

Versionshinweis: mldata.org wurde abgeschaltet und fetch_mldata() wurde in scikit-learn 0.22 entfernt. Laden Sie bei jeder aktuellen Installation die gleichen Ziffern mit fetch_openml Stattdessen wird fetch_openml('mnist_784', version=1) verwendet. Der Rest der Pipeline bleibt unverändert.

Erstellen Sie einen Zug-/Testsatz

Sie müssen den Datensatz mit train_test_split aufteilen.

Skalieren Sie die Funktionen

Abschließend können Sie die Merkmale mit MinMaxScaler skalieren, wie im folgenden Beispiel zur Bildklassifizierung mit TensorFlow CNN gezeigt.

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

Definieren Sie das CNN

Ein CNN verwendet Filter auf den Rohpixeln eines Bildes, um Detailmuster zu lernen, im Gegensatz zu den globalen Mustern, die ein herkömmliches neuronales Netz lernt. Um ein CNN zu konstruieren, müssen Sie Folgendes definieren:

1. Eine Faltungsschicht: Wenden Sie n Filter auf die Merkmalskarte an. Nach der Faltung muss eine ReLU-Aktivierungsfunktion verwendet werden, um dem Netzwerk Nichtlinearität hinzuzufügen.
2. Pooling-Schicht: Nach der Faltung erfolgt das Downsampling der Feature-Map. Ziel ist es, die Dimensionalität der Feature-Map zu reduzieren, um Overfitting zu vermeiden und die Berechnungsgeschwindigkeit zu verbessern. Max-Pooling ist die gängige Methode, bei der die Feature-Map in Teilbereiche (üblicherweise 2×2) unterteilt und nur die Maximalwerte beibehalten werden.
3. Vollständig verbundene Schichten: Alle Neuronen der vorherigen Schichten sind mit den nächsten Schichten verbunden. Das CNN klassifiziert das Label anhand der Merkmale aus den Faltungsschichten und reduziert sie mit der Pooling-Schicht.

CNN-Architektur

• Faltungsschicht: Wendet 14 5×5-Filter an (z. B.tracting 5×5-Pixel-Teilbereiche), mit ReLU-Aktivierungsfunktion
• Pooling-Ebene: Führt Max-Pooling mit einem 2×2-Filter und einer Schrittweite von 2 aus (wodurch festgelegt wird, dass sich die gepoolten Bereiche nicht überschneiden)
• Faltungsschicht: Wendet 36 5×5-Filter mit ReLU-Aktivierungsfunktion an
• Pooling Schicht #2: Führt erneut Max Pooling mit einem 2×2 Filter und einer Schrittweite 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 gelöscht wird)
• Dichte Schicht (Logits-Schicht): 10 Neuronen, eines für jede Ziffernzielklasse (0–9).

Es gibt drei wichtige Module zur Erstellung eines CNN:

• conv2d(). Konstruiert eine zweidimensionale Faltungsschicht mit der Anzahl der Filter, der Filterkerngröße, der Auffüllung und der Aktivierungsfunktion als Argumente.
• max_pooling2d(). Erstellt eine zweidimensionale Pooling-Schicht unter Verwendung des Max-Pooling-Algorithmus.
• dicht(). Konstruiert eine dichte Ebene mit den verborgenen Ebenen und Einheiten

Sie werden eine Funktion zum Erstellen des CNN definieren. Sehen wir uns im Detail an, wie die einzelnen Bausteine ​​konstruiert werden, bevor wir fortfahren.ping Alles zusammen in der Funktion.

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. Dazu können Sie das Modul tf.reshape verwenden. In diesem Modul müssen Sie den umzuformenden Tensor und die Form des Tensors deklarieren. Das erste Argument sind die Merkmale der Daten, die im Argument der Funktion definiert werden.

Ein Bild hat eine Höhe, eine Breite und einen Kanal. Der MNIST-Datensatz besteht aus monochromen Bildern der Größe 28×28. Wir setzen die Batchgröße im Formargument auf -1, sodass sie die Form von features["x"] annimmt. Der Vorteil besteht darin, dass die Batchgröße als Hyperparameter optimiert werden kann. Bei einer Batchgröße von 7 enthält der Tensor 5,488 Werte (28×28×7).

Schritt 3: Faltungsschicht

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

Die erste Faltungsschicht besteht aus 14 Filtern mit einer Kernelgröße von 5×5 und gleichem Padding. Gleiches Padding bedeutet, dass sowohl der Ausgabetensor als auch der Eingabetensor die gleiche Höhe und Breite aufweisen. TensorFlow fügt den Zeilen und Spalten Nullen hinzu, um die gleiche Größe zu gewährleisten.

Sie verwenden die ReLU-Aktivierungsfunktion. Die Ausgabegröße beträgt [28, 28, 14].

Schritt 4: Pooling-Schicht

Der nächste Schritt nach der Faltung ist die Pooling-Berechnung. Diese reduziert die Dimensionalität der Daten. Sie können das Modul `max_pooling2d` mit einer Größe von 2×2 und einem Stride von 2 verwenden. Die vorherige Schicht dient als Eingabe. Die Ausgabegröße beträgt dann [Batchgröße, 14, 14, 14].

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

Schritt 5: Zweite Faltungsschicht und Pooling Ebene

Die zweite Faltungsschicht wendet 36 Filter an, was zu einer Ausgabegröße von [Batchgröße, 14, 14, 36] führt. Die Pooling-Schicht verwendet dasselbe 2×2-Fenster und denselben Schritt von 2 wie zuvor, halbiert also jede räumliche Achse, und die Ausgabegröße beträgt [Batchgröße, 7, 7, 36].

conv2 = tf.layers.conv2d(
      inputs=pool1,
      filters=36,
      kernel_size=[5, 5],
      padding="same",
      activation=tf.nn.relu)
pool2 = tf.layers.max_pooling2d(inputs=conv2, pool_size=[2, 2], strides=2)

Schritt 6: Dichte Schicht

Anschließend muss die vollständig verbundene Ebene definiert werden. Die Feature-Map muss vor der Verbindung mit der dichten Ebene abgeflacht werden. Hierfür kann das Modul `reshape` mit einer Größe von 7x7x36 verwendet werden.

Die dichte Schicht verbindet 1,764 Neuronen. Sie verwenden eine ReLU-Aktivierungsfunktion. Zusätzlich fügen Sie einen Dropout-Regularisierungsterm mit einer Rate von 0.3 hinzu, was bedeutet, dass 30 Prozent der Aktivierungen auf 0 gesetzt werden. Beachten Sie, dass der Dropout nur während der Trainingsphase stattfindet. Die Funktion `cnn_model_fn` verfügt über das Argument `mode`, mit dem Sie festlegen können, ob das Modell trainiert oder evaluiert werden soll, wie im folgenden TensorFlow-Beispiel zur CNN-Bildklassifizierung gezeigt.

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-Schicht

Im TensorFlow-Beispiel zur Bildklassifizierung können Sie schließlich die letzte Schicht mit der Vorhersage des Modells definieren. Die Ausgabegröße entspricht der Batchgröße plus 10, der Gesamtzahl der Zielklassen.

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

Sie können ein Wörterbuch erstellen, das die Klassen und die Wahrscheinlichkeit jeder Klasse enthält. Die Funktion `tf.argmax()` gibt den Index des höchsten Werts in der Logit-Schicht zurück. 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")  }			

Das Vorhersagewörterbuch soll nur dann zurückgegeben werden, wenn der Modus auf „Vorhersage“ gesetzt ist. Fügen Sie diesen Code hinzu, um die Vorhersagen anzuzeigen.

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

Der nächste Schritt besteht in der Berechnung des Modellverlusts. Im letzten Tutorial haben Sie gelernt, dass die Verlustfunktion für ein Multiklassenmodell die Kreuzentropie ist. Der Verlust lässt sich einfach mit dem folgenden Code berechnen:

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

Der letzte Schritt des TensorFlow-CNN-Beispiels besteht in der Optimierung des Modells, d. h. in der Ermittlung der optimalen Gewichtswerte. Dazu wird ein Gradientenabstiegsverfahren mit einer Lernrate von 0.001 verwendet. 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 haben die CNN-Implementierung abgeschlossen. Sie möchten jedoch die Leistungsmetriken im Auswertungsmodus anzeigen lassen. Die Leistungsmetrik für ein Multiklassenmodell ist die Genauigkeit. TensorFlow verfügt über ein Genauigkeitsmodul, das zwei Argumente benötigt: die Labels und die vorhergesagten Werte.

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 es zum Trainieren und Bewerten des Modells zu verwenden.

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)

Hinweis zur zusammengesetzten Funktion: Die obenstehende, umschlossene Version verwendet 32 ​​Filter in der ersten Faltungsschicht und einen Dropout-Wert von 0.4, während die schrittweisen Codebeispiele 14 Filter und 0.3 verwenden. Beide Varianten laufen, aber wählen Sie ein Wertepaar und behalten Sie es bei, damit die ausgegebenen Formen mit der Schichttabelle übereinstimmen.

Die folgenden Schritte sind die gleichen wie in den vorherigen Tutorials.

Zunächst definieren Sie einen Schätzer mit dem CNN-Modell zur Bildklassifizierung.

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

Da das Training eines CNN sehr lange dauert, erstellt man einen Logging-Hook, um die Werte der Softmax-Schichten alle 50 Iterationen zu speichern.

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

Sie können das Modell nun schätzen. Legen Sie eine Batchgröße von 100 fest und mischen Sie die Daten. Beachten Sie, dass wir 16,000 Trainingsschritte festgelegt haben, was viel Zeit in Anspruch nehmen kann. Haben Sie Geduld.

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

Nachdem das Modell trainiert wurde, können Sie es auswerten und die Ergebnisse ausdrucken.

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

Die Auswertung gibt den wiederhergestellten Prüfpunkt, den Schritt, bei dem er gestoppt wurde, und das endgültige Metrikenwörterbuch aus.

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}

Mit der aktuellen Architektur meldet das Auswertungswörterbuch eine Genauigkeit von 0.9689286, was etwa 97 % entspricht. Sie können die Architektur, die Batchgröße und die Anzahl der Iterationen anpassen, um die Genauigkeit zu verbessern. Das CNN hat deutlich besser abgeschnitten als ein künstliche neuronale Netz Oder logistische Regression: Im Tutorial zu künstlichen neuronalen Netzen erzielten Sie eine Genauigkeit von 96 %, die niedriger ist als die des CNN. Die Leistung des CNN ist bei größeren Bilddatensätzen sowohl hinsichtlich der Rechengeschwindigkeit als auch der Genauigkeit beeindruckend.

Häufig gestellte Fragen