CNN-Bildklassifizierung in TensorFlow mit Schritten und Beispielen

Was ist Convolutional Neural Network?

Faltungs-Neuronales Netz, auch bekannt als Convnets oder CNN, ist eine bekannte Methode in Computer Vision-Anwendungen. Es handelt sich um eine Klasse tiefer neuronaler Netzwerke, die zur Analyse visueller Bilder verwendet werden. Diese Art von Architektur ist vorherrschend, um Objekte aus einem Bild oder Video zu erkennen. Sie wird in Anwendungen wie Bild- oder Videoerkennung, neuronaler Sprachverarbeitung usw. verwendet.

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 Convnet-Architektur kann in der folgenden Abbildung 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 Reihe von Pixeln mit Höhe und Breite. Ein Graustufenbild hat nur einen Kanal, während das Farbbild drei Kanäle hat (jeweils einen für Rot, Grün und Blau). Ein Kanal wird ü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 wiederzugeben. Beispielsweise zeigt ein Pixel mit dem Wert 0 eine weiße Farbe an, während ein Pixel mit einem Wert nahe 255 dunkler ist.

Werfen wir einen Blick auf ein im gespeichertes Bild MNIST-Datensatz. Das Bild unten zeigt, wie das Bild der linken Seite in einem Matrixformat dargestellt wird. Beachten Sie, dass die ursprüngliche Matrix auf einen Wert zwischen 0 und 1 standardisiert wurde. Für dunklere Farben beträgt der Wert in der Matrix etwa 0.9, während weiße Pixel einen Wert von 0 haben.

Faltungsoperation

Die kritischste Komponente im Modell ist die Faltungsschicht. Dieser Teil zielt darauf ab, die Größe des Bildes zu reduzieren, um die Berechnung der Gewichte zu beschleunigen 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. 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 lernen.

Komponenten des Convolutional Neural Network (ConvNet oder CNN)

Es gibt vier Komponenten eines Convnets

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 analysiert. Das bedeutet, dass das Netzwerk spezifische Muster innerhalb des Bildes lernt und es ü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 Dimension von 3×3, und multipliziert ihn mit einem Filter. Die Ausgabe der elementweisen Multiplikation wird als Merkmalskarte bezeichnet. Dieser Schritt wird wiederholt, bis das gesamte Bild gescannt ist. Beachten Sie, dass die Größe des Bildes nach der Faltung reduziert wird.

Unten befindet sich ein URL um in Aktion zu sehen, wie die Faltung funktioniert.

Es stehen zahlreiche Kanäle zur Verfügung. Nachfolgend haben wir einige der Kanäle aufgelistet. Sie sehen, dass jeder Filter einen bestimmten Zweck hat. Beachten Sie, im Bild unten; Der Kernel ist ein Synonym für den Filter.

Arithmetik hinter der Faltung

Die Faltungsphase wendet den Filter auf eine kleine Pixelanordnung im Bild an. Der Filter bewegt sich entlang des Eingabebildes in einer allgemeinen Form von 3×3 oder 5×5. Das bedeutet, dass das Netzwerk diese Fenster über das gesamte Eingabebild schiebt und die Faltung berechnet. Das folgende Bild zeigt, wie die Faltung funktioniert. Die Größe des Patches beträgt 3×3 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 verfügt über eine 5×5-Funktionskarte und einen 3×3-Filter. Es gibt nur ein Fenster in der Mitte, in dem der Filter ein 3×3-Raster anzeigen kann. Die Ausgabe-Feature-Map wird zusammen mit einer 3×3-Dimension um zwei Kacheln verkleinert.

Um die gleiche Ausgabedimension wie die Eingabedimension zu erhalten, müssen Sie eine Auffüllung hinzufügen. Beim Auffüllen wird auf jeder Seite der Matrix die richtige Anzahl an Zeilen und Spalten hinzugefügt. Dadurch kann die Faltung jede Eingabekachel zentrieren. Im Bild unten hat die Eingabe-/Ausgabematrix die gleiche Dimension 5×5

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

1. Tiefe: Definiert die Anzahl der Filter, die während der Faltung angewendet werden. 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 folgende Bild zeigt die Operationen, die in einer Situation mit drei Filtern durchgeführt werden

2. Schreiten: Definiert die Anzahl der „Pixelsprünge“ zwischen zwei Slices. Wenn der Schritt gleich 1 ist, bewegen sich die Fenster mit einer Pixelbreite von eins. Wenn der Schritt gleich zwei ist, springen die Fenster um 2 Pixel. Wenn Sie den Schritt vergrößern, erhalten Sie kleinere Feature-Maps.

Beispielschritt 1

Schritt 2

3. Nullauffüllung: Beim Auffüllen wird auf jeder Seite der Eingabe-Feature-Maps eine entsprechende Anzahl von Zeilen und Spalten hinzugefügt. In diesem Fall hat die Ausgabe die gleiche Dimension wie die Eingabe.

Nichtlinearität (ReLU)

Am Ende der Faltungsoperation wird die Ausgabe einer Aktivierungsfunktion unterzogen, um Nichtlinearität zu ermöglichen. Die übliche Aktivierungsfunktion für Convnet ist Relu. Alle Pixel mit einem negativen Wert werden durch Null ersetzt.

Pooling OperaProduktion

Dieser Schritt ist leicht zu verstehen. Der Zweck des Poolings besteht darin, die Dimensionalität des Eingabebildes zu reduzieren. Die Schritte werden durchgeführt, um die Rechenkomplexität der Operation zu reduzieren. Durch die Verringerung der Dimensionalität muss das Netzwerk weniger Gewichte berechnen, wodurch eine Überanpassung verhindert wird.

In dieser Phase müssen Sie die Größe und die Schrittweite definieren. Eine Standardmethode zum Poolen des Eingabebilds besteht darin, den Maximalwert der Feature-Map zu verwenden. Sehen Sie sich das Bild unten an. Das „Pooling“ durchleuchtet eine Vierer-Submatrix der 4×4-Feature-Map und gibt den Maximalwert zurück. Das Pooling nimmt den Maximalwert eines 2×2-Arrays und verschiebt dieses Fenster dann um zwei Pixel. Wenn beispielsweise die erste Submatrix [3,1,3,2] ist, gibt das Pooling das Maximum zurück, also 3.

Es gibt eine weitere Pooling-Operation wie den Mittelwert.

Dieser Vorgang reduziert die Größe der Feature-Map drastisch.

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:

Das TensorFlow Convolutional Neural Network kompiliert verschiedene Schichten, bevor es eine Vorhersage trifft. 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-Schichten reduzieren die Dimensionalität der Feature-Maps.

Alle diese Schichten z.B.tracDie wesentlichen Informationen werden aus den Bildern extrahiert. Schließlich werden die Merkmalskarten einer primären 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 Convnets vertraut sind, können Sie mit dem Bau eines Convnets beginnen 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:

Schritt 1: Datensatz hochladen

Schritt 2: Eingabeebene

Schritt 3: Faltungsschicht

Schritt 4: Pooling-Schicht

Schritt 5: Zweite Faltungsschicht und Pooling Ebene

Schritt 6: Dichte Schicht

Schritt 7: Logit-Schicht

Schritt 1: Datensatz hochladen

Der MNIST-Datensatz ist mit scikit zum Lernen verfügbar URL. Bitte laden Sie es herunter und speichern Sie es unter Downloads. Sie können es mit fetch_mldata('MNIST original') hochladen.

Erstellen Sie einen Zug-/Testsatz

Sie müssen den Datensatz mit train_test_split aufteilen

Skalieren Sie die Funktionen

Schließlich können Sie das Feature mit MinMaxScaler skalieren, wie in der folgenden Bildklassifizierung anhand des TensorFlow-CNN-Beispiels 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 für die Rohpixel eines Bildes, um Detailmuster zu lernen, im Vergleich zu globalen Mustern mit einem herkömmlichen neuronalen Netz. Um ein CNN zu konstruieren, müssen Sie Folgendes definieren:

1. Eine Faltungsschicht: 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.
2. Pooling-Schicht: Der nächste Schritt nach der Faltung besteht darin, das Feature-Maximum herunterzusampeln. Ziel ist es, 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, die die Feature-Maps in Unterbereiche (normalerweise mit einer Größe von 2 × 2) unterteilt und nur die Maximalwerte behält.
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 definieren eine Funktion zum Erstellen des CNN. Sehen wir uns zunächst im Detail an, wie die einzelnen Bausteine ​​aufgebaut werden, um alles in der Funktion zusammenzufassen.

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 ist ein monochrones Bild mit einer Größe von 28×28. Wir setzen die Stapelgröße im Formargument auf -1, damit sie die Form der Features[„x“] annimmt. Der Vorteil besteht darin, die Hyperparameter der Chargengröße anzupassen. Wenn die Stapelgröße auf 7 eingestellt ist, speist 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 verfügt über 14 Filter mit einer Kernelgröße von 5×5 und der gleichen Polsterung. Die gleiche Auffüllung bedeutet, dass sowohl der Ausgabetensor als auch der Eingabetensor die gleiche Höhe und Breite haben sollten. Tensorflow fügt den Zeilen und Spalten Nullen hinzu, um die gleiche Größe sicherzustellen.

Sie nutzen 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. Die Pooling-Berechnung reduziert die Dimensionalität der Daten. Sie können das Modul max_pooling2d mit einer Größe von 2×2 und einer Schrittweite von 2 verwenden. Sie verwenden die vorherige Ebene als Eingabe. Die Ausgabegröße beträgt [batch_size, 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 hat 32 Filter mit einer Ausgabegröße von [batch_size, 14, 14, 32]. Die Pooling-Schicht hat die gleiche 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 der Verbindung mit der dichten Ebene abgeflacht werden. Sie können das Modul Reshape mit einer Größe von 7*7*36 verwenden.

Die dichte Schicht wird 1764 Neuronen verbinden. 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, wie im folgenden TensorFlow-Beispiel für die 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

Schließlich können Sie im TensorFlow-Bildklassifizierungsbeispiel die letzte Ebene mit der Vorhersage des Modells definieren. Die Ausgabeform entspricht der Stapelgröße und 10, der Gesamtzahl der Bilder.

# 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. Das Modul tf.argmax() gibt den höchsten Wert zurück, wenn die Logit-Schichten vorhanden sind. 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 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 darin, das Modell zu optimieren, also 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 CNN fertig. Sie möchten jedoch die Leistungskennzahlen während des Bewertungsmodus anzeigen. Die Leistungsmetrik für ein Mehrklassenmodell sind die Genauigkeitsmetriken. Tensorflow verfügt über ein Genauigkeitsmodul mit zwei Argumenten, 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 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)

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

Das Training eines CNN dauert viele Male. Daher erstellen Sie einen Logging-Hook, um die Werte der Softmax-Ebenen 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 sind bereit, das Modell zu 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 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 nun trainiert ist, 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)

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 erreichen Sie eine Genauigkeit von 97 %. Sie können die Architektur, die Batch-Größ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 niedriger ist als beim CNN. Die Leistungen des CNN sind bei einem größeren Bild beeindruckend kompensieren, sowohl im Hinblick auf die Geschwindigkeitsberechnung als auch auf die Genauigkeit.

Zusammenfassung

Ein Convolutional Neural Network eignet sich sehr gut zur Bildauswertung. Diese Art von Architektur ist vorherrschend, um Objekte aus einem Bild oder Video zu erkennen.

Um ein TensorFlow-CNN zu erstellen, müssen Sie sieben Schritte ausführen:

Schritt 1:: Datensatz hochladen:

Der MNIST-Datensatz ist mit Scikit zum Lernen verfügbar. Bitte laden Sie es herunter und speichern Sie es unter Downloads. Sie können es mit fetch_mldata('MNIST original') hochladen.

Schritt 2:: Eingabeebene:

Dieser Schritt formt die Daten neu. Die Form entspricht der Quadratwurzel der Anzahl der Pixel. Wenn ein Bild beispielsweise 156 Pixel hat, ist die Form 26×26. Sie müssen angeben, ob das Bild farbig ist oder nicht. Wenn ja, dann haben Sie 3 für die Form – 3 für RGB –, andernfalls 1.

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

Schritt 3:: Faltungsschicht

Als nächstes müssen Sie die Faltungsschichten erstellen. Sie wenden verschiedene Filter an, damit das Netzwerk wichtige Funktionen lernen kann. Sie legen die Größe des Kernels und die Anzahl der Filter fest.

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

Schritt 4:: Pooling-Schicht

Im dritten Schritt fügen Sie eine Pooling-Schicht hinzu. Diese Schicht verringert die Größe der Eingabe. Dies geschieht, indem der Maximalwert einer Untermatrix verwendet wird. Wenn die Untermatrix beispielsweise [3,1,3,2] ist, gibt das Pooling das Maximum zurück, also 3.

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

Schritt 5:: Faltungsschicht hinzufügen und Pooling Ebene

In diesem Schritt können Sie beliebig viele Convolutional Layers und Pooling Layers hinzufügen. Google verwendet eine Architektur mit mehr als 20 Faltungsschichten.

Schritt 6:: Dichte Schicht

Schritt 6 glättet den vorherigen, um eine vollständig verbundene Ebene 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 7:: Logit-Schicht

Der letzte Schritt ist die Vorhersage.

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