Über diesen Artikel

Fortsetzung des vorherigen Artikels .

Ich möchte Bilder mithilfe des Convolutional Neural Network (CNN) klassifizieren. In Teil 1 dieses Artikels haben wir handgeschriebene numerische Bilder mithilfe eines neuronalen Netzwerks klassifiziert. CNN ermöglicht eine genauere Klassifizierung.

Was ist ein Faltungs-Neuronales Netzwerk (CNN)?

Es ist eines der am häufigsten verwendeten Deep-Learning-Modelle bei der Arbeit mit Bildern. Neben dem üblichen neuronalen Netz Es wird "Faltungs-Neuronales Netzwerk" genannt, weil es einen Prozess namens "Faltung" hinzufügt.

Was ist "Faltvorgang"?

In den letzten Jahren ist die Bildqualität von Smartphone-Kameras gestiegen, und eine Kamera hat mehrere MB. Wenn Sie dies für dieses Lernen verwenden, wird es viel Zeit in Anspruch nehmen, da es zu viel Kapazität hat. Um die Effizienz des Lernens zu erhöhen, müssen Sie die Größe des Bildes reduzieren.

Es reicht jedoch nicht aus, nur die Kapazität zu reduzieren. Wenn Sie es verkleinern und die Funktionen des Bildes verschwinden Ich weiß nicht, was das Bild ist und es macht keinen Sinn.

__Falten ist der Vorgang des Komprimierens unter Beibehaltung der Eigenschaften der ursprünglichen Bilddaten.

Insbesondere ist das Verfahren wie folgt.

Das Bild wird in der "Faltschicht" in Teile zerlegt, die als "Kernel" bezeichnet werden.
Erstellen Sie eine "Feature Map", indem Sie mehrere "Kernel" multiplizieren.
Verkleinern Sie die erstellte "Feature Map" mit dem "Pooling Layer".

Konvertieren Sie es schließlich in eindimensionale Array-Daten und Der Fluss ist mit einem neuronalen Netzwerk zu lernen.

Über die Bauumgebung

In diesem Artikel wird es in einer Google Colaboratory-Umgebung ausgeführt. Außerdem ist die Version von Tensorflow 1.13.1. Wenn Sie ein Downgrade durchführen möchten, können Sie den folgenden Befehl verwenden. !pip install tensorflow==1.13.1

Bibliothek importieren

Ich werde diesmal auch tensorflow.keras verwenden.

from tensorflow.keras.datasets import cifar10
from tensorflow.keras.layers import Activation, Dense, Dropout, Conv2D, Flatten, MaxPool2D
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

Aufbereitung von Bilddaten

Bilddaten werden mit der cifar10-Bibliothek heruntergeladen. (train_images, train_labels) ist das Trainingsbild und die korrekte Bezeichnung (test_images, test_labels) ist das Bild und die korrekte Bezeichnung für die Überprüfung.

(train_images, train_labels), (test_images, test_labels) = cifar10.load_data()

Überprüfen Sie die Form des Datensatzes. Sie können sehen, dass 50.000 32-Pixel-RGB-Bilder (32 x 32 x 3) für das Training und 10.000 für die Überprüfung verfügbar sind.

Lassen Sie uns auch den Inhalt des Bildes überprüfen.

Richtige Antwortbezeichnung des Bildes ↓

Die Bedeutung jeder Zahl ist wie folgt.

Bezeichnung "0": Flugzeug Etikett "1": Automobil Etikett "2": Vogel Etikett "3": Kat.-Nr. Etikett "4": Hirsch Etikett "5": Hund Etikett "6": Frosch Etikett "7": Pferd Etikett "8": Schiff Etikett "9": LKW

Datensatzvorverarbeitung

Der Inhalt von train_images lautet wie folgt Enthält Zahlen von 0 bis 255. (Wegen RGB) Um dies zu normalisieren, teilen Sie es gleichmäßig durch 255.

In einem normalen neuronalen Netzwerk Ich musste die Trainingsdaten in eine Dimension ändern, Da im Faltungsprozess 3D-Daten eingegeben werden müssen, ist nur der Normalisierungsprozess in Ordnung.

train_images = train_images.astype('float32')/255.0
test_images = test_images.astype('float32')/255.0

Ändern Sie außerdem die richtige Antwortbezeichnung in One-Hot-Ausdruck mit to_categorical.

train_labels = to_categorical(train_labels, 10)
test_labels = to_categorical(test_labels, 10)

Modellieren

Modellierung ist der folgende Code.

model = Sequential()

#Erster Faltungsprozess (Conv → Conv → Pool → Dropout)
model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#Zweiter Faltungsprozess (Conv → Conv → Pool → Dropout)
model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#Klassifizierung nach neuronalen Netzen (Abflachen → Dicht → Aussetzer → Dicht)
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

Ich werde jeden erklären. Erstellen Sie zunächst ein sequentielles Modell mit model = Sequential ().

Als nächstes folgt der Faltungsprozess. Diesmal nach zweimaligem Falten, Ich möchte nach einem neuronalen Netzwerk klassifizieren.

Ich werde den ersten Faltungsprozess erklären. Erstens mit model.add (Conv2D (32, (3, 3), Aktivierung = 'relu', padding = 'same', input_shape = (32, 32, 3))) Erstellen Sie eine Faltungsebene. Wir übergeben die Anzahl der Kernel, die Kernelgröße, die Aktivierungsfunktion, das Auffüllen und die Eingabegröße an Conv2D. Die Anzahl der Kernel beträgt 32, die Größe ist 3x3, die Aktivierungsfunktion ist relu und das Auffüllen ist der Vorgang, bei dem die erstellte Feature-Map in 0 eingeschlossen wird.

Die durch den obigen Prozess erstellte Feature-Map Mit model.add (Conv2D (32, (3, 3), Aktivierung = 'relu', padding = 'same')) Erstellen Sie außerdem eine Feature-Map, die Features in der Faltungsebene extrahiert.

Als nächstes kommt die Pooling-Schicht. Komprimieren Sie das Bild mit model.add (MaxPool2D (pool_size = (2, 2))). MaxPool2D ist eine Methode namens MAX Pooling. Die Größe ist die Größe nach der Komprimierung.

Schließlich, model.add (Dropout (0.25)) um mit Dropout ungültig zu machen, Der erste Faltungsprozess ist abgeschlossen.

Machen Sie den gleichen Vorgang noch einmal und dann Konvertieren Sie mit model.add (Flatten ()) und in eine Dimension Führt eine Klassifizierungsvorhersage eines normalen neuronalen Netzwerks durch.

Konvertierungsprozess zum TPU-Modell

Vor dem Kompilieren des Modells Konvertieren Sie das erstellte Modell in ein TPU-Modell.

Sie können kompilieren und lernen, wie es ist, Weil das Faltungs-Neuronale Netzwerk einen enormen Rechenaufwand erfordert Es dauert sehr lange, wenn es nicht von TPU verarbeitet wird.

Befolgen Sie zum Konvertieren die folgenden Schritte.

#Umstellung auf TPU-Modell
import tensorflow as tf
import os
tpu_model = tf.contrib.tpu.keras_to_tpu_model(
    model,
    strategy=tf.contrib.tpu.TPUDistributionStrategy(
        tf.contrib.cluster_resolver.TPUClusterResolver(tpu='grpc://' + os.environ['COLAB_TPU_ADDR'])
    )
)

Modell kompilieren

Die Verlustfunktion eignet sich zur Klassifizierung kategorial_crossentopy, Stellen Sie die Aktivierungsfunktion auf Adam (Lernrate ist 0,001) und den Bewertungsindex auf acc (korrekte Antwortrate).

tpu_model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001), metrics=['acc'])

Lernen

Sie lernen mit dem erstellten Modell. Beim Lernen mit dem TPU-Modell ist das erste Mal ziemlich zeitaufwändig, aber das zweite und nachfolgende Mal sind schnell. Wenn Sie mit einem normalen Modell anstelle von TPU trainieren, dauert dies mehr als doppelt so lange.

history = tpu_model.fit(train_images, train_labels, batch_size=128,
    epochs=20, validation_split=0.1)

Grafische Darstellung der Lernergebnisse

Die richtige Antwortrate scheint 90% zu überschreiten. Es ist ziemlich genau.

plt.plot(history.history['acc'], label='acc')
plt.plot(history.history['val_acc'], label='val_acc')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(loc='best')
plt.show()

Bewertung des Lernens

Als ich es mit den Verifizierungsdaten versuchte, fiel die korrekte Antwortrate auf 71,2%. Wenn es sich um ein neues Bild handelt, ist die Genauigkeit nicht so hoch, sodass Raum für Verbesserungen zu bestehen scheint.

test_loss, test_acc = tpu_model.evaluate(test_images, test_labels)
print('loss: {:.3f}\nacc: {:.3f}'.format(test_loss, test_acc ))

Inferenz

Schließlich Schlussfolgerung. Übergeben Sie das Bild und überprüfen Sie, welche Art von Vorhersage gemacht wird. Die TPU von Google Colab besteht aus 8 Kernen. Sie müssen durch eine durch 8 teilbare Zahl lernen. Daher möchte ich die Trainingsdaten auf 16 setzen.

#Anzeige des abgeleiteten Bildes
for i in range(16):
    plt.subplot(2, 8, i+1)
    plt.imshow(test_images[i])
plt.show()

#Anzeige des abgeleiteten Etiketts
test_predictions = tpu_model.predict(test_images[0:16])
test_predictions = np.argmax(test_predictions, axis=1)[0:16]
labels = ['airplane', 'automobile', 'bird', 'cat', 'deer',
        'dog', 'frog', 'horse', 'ship', 'truck']
print([labels[n] for n in test_predictions])

Das Bild ist klein und schwer zu verstehen, Es scheint, dass Sie es vorhersagen können. Das nächste Mal möchte ich dieselben Bilddaten mit einem CNN namens ResNet vorhersagen.

Einführung in die KI-Erstellung mit Python! Teil 3 Ich habe versucht, Bilder mit einem Convolutional Neural Network (CNN) zu klassifizieren und vorherzusagen.