[PYTHON] Erstellt ein Bildunterscheidungsmodell (cifar10) unter Verwendung eines Faltungs-Neuronalen Netzwerks

Einführung

Ich bin Fumio, ein Anfänger im maschinellen Lernen. Ich widme mich dem Spaß am maschinellen Lernen, Programmieren und Lernen jeden Tag.

Ich lerne "Aus Mosaikentfernung lernen: topaktuelles tiefes Lernen", geschrieben von koshian2. Um mein Verständnis für das, was ich gelernt habe, zu vertiefen, möchte ich ein Beispiel für die Anwendung des Convolutional Neural Network (CNN) auf die Bilddiskriminierung zusammenfassen. https://qiita.com/koshian2/items/aefbe4b26a7a235b5a5e

Die Hauptpunkte sind wie folgt.

• Verstehen Sie die Struktur von Faltungs-Neuronalen Netzen.
• Schichtfaltung + 1 Schicht dicht Erstellen Sie insgesamt 10 Schichten Faltungsmodell für neuronale Netze.
• Das Modell bestimmt den CIFAR-10-Datensatz.

Faltungsstruktur des neuronalen Netzwerks

Das Faltungs-Neuronale Netzwerk (CNN) ist ein Vorwärtsausbreitungsnetzwerk, das zwei Arten von Schichten enthält, die Faltungsschicht und die Pooling-Schicht, und wird auf die Bilderkennung angewendet.

• Ein neuronales Netzwerk vom Forward-Propagation-Typ hat keine Schleifenverbindung zum Netzwerk, und das Signal breitet sich nur in eine Richtung aus, z. B. Eingangsschicht → Zwischenschicht → Ausgangsschicht. Andererseits sind rekursive neuronale Netze das Gegenteil und reversibel.

Datensatz laden

cifar10.ipynb

import matplotlib.pyplot as plt

cifar_classes = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]

(X_train, y_train),(X_test,y_test) = tf.keras.datasets.cifar10.load_data()
print(X_train.shape,y_train.shape)
print(X_test.shape,y_test.shape)

Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz 170500096/170498071 [==============================] - 13s 0us/step (50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)

Lesen Sie direkt aus dem Keras-Dataset. Wenn Sie die Abmessungen der Trainingsdaten überprüfen, sehen Sie, dass es sich um 50.000 32 x 32 x 3 Daten handelt. Da es sich um ein Farbbild handelt, ist es dreidimensional.

cifar10.ipynb

fig = plt.figure(figsize=(14,14))
for i in range(100):
  ax = plt.subplot(10,10,i+1)
  ax.imshow(X_train[i])
  ax.axis('off')
  ax.set_title(cifar_classes[y_train[i,0]])

Das Bild sieht so aus. Es ist schon von Anfang an verschwommen, aber irgendwie kann ich die Bedeutung jedes Namens und Fotos verstehen. Sie können jedoch feststellen, dass einige Typen schwer zu unterscheiden sind (Hirsche und Pferde, Autos und Lastwagen usw.).

Was ist Pooling?

Pooling in CNN bezieht sich auf das Komprimieren und Downsampling von Informationen. Es wird normalerweise als Pooling-Schicht nach der Faltungsschicht aufgetragen. Die Haupteffekte sind wie folgt.

1. Kann winzige Positionsänderungen verarbeiten
2. Überlernen kann bis zu einem gewissen Grad unterdrückt werden
3. Die Berechnungskosten können reduziert werden

Die Ausgabe in der Pooling-Schicht kann konstant gemacht werden, selbst wenn die Position des Merkmals, die der Positionsänderung in 1 entspricht, geringfügig abweicht. Mit anderen Worten, wenn Sie eine handschriftliche Nummer als Beispiel nehmen, können Sie sie erkennen lassen, dass es sich um dieselbe Nummer handelt, auch wenn sie leicht falsch ausgerichtet ist.

Erstellen Sie ein 10-lagiges neuronales Netzwerkmodell

Um diese CIFAR-10-Unterscheidung vorzunehmen, erstellen wir ein Modell mit 9 Faltungsschichten + 1 Schicht vollständig verbundener Schichten für insgesamt 10 Schichten.

• Convitation (Conv) 64ch-> Batch Normalization (BN) -> Activation (ReLU)) Wiederholung x3-> Pooling
• (Conv 128ch -> BN -> ReLU) repeat x3 -> Pooling
• (Conv 256ch -> BN -> ReLU) repeat x3
• Global Average Pooling -> Dense 10 -> Softmax

Machen Sie Modelle in dieser Reihenfolge. ReLU wird als Aktivierungsfunktion verwendet.

cifar10.ipynb

inputs = layers.Input((32,32,3))
x = inputs

for ch in [64, 128, 256]:
    for i in range(3):
        x = layers.Conv2D(ch, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)
        x = layers.ReLU()(x)
    if ch != 256:
        x = layers.AveragePooling2D()(x)
        
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(10, activation="softmax")(x)
model = tf.keras.models.Model(inputs, x)
model.summary()

conv2d_12 (Conv2D) (None, 8, 8, 256) 590080
batch_normalization_12 (Batc (None, 8, 8, 256) 1024
re_lu_12 (ReLU) (None, 32, 32, 256) 0
average_pooling2d_3 (Average (None, 8, 8, 256) 0
global_average_pooling2d_1 ( (None, 256) 0
dense_1 (Dense) (None, 10) 2570

Ich habe nur den letzten Teil extrahiert, der ausgegeben wird. Die Abmessungen ändern sich wie folgt. (None,32,32,3)→(None,32,32,64)→(None, 16, 16, 128) →(None, 8, 8, 256)→(None, 256)→(None, 10) Sie können sehen, dass sich die Bemaßung beim Durchlaufen der Poolebene halbiert.

Datensatzvorbereitung

cifar10.ipynb

X_train = X_train.astype(np.float32) / 255.0
X_test = X_test.astype(np.float32) / 255.0
y_train = y_train.astype(np.float32)
y_test = y_test.astype(np.float32)

Da die Originaldaten vom Typ unit8 und vom Maßstab [0,255] sind, konvertieren Sie den Datentyp in float32 und den Maßstab in [0,1].

Modelllernen

cifar10.ipynb

model.fit(X_train,y_train, validation_data=(X_test, y_test),epochs=10)

Abhängig von den PC-Spezifikationen kann es lange dauern (meine PC-Spezifikationen dauerten für jede Epoche etwa 10 Minuten). Wir empfehlen daher, dass Sie mit Hilfe von Google Colab fortfahren. 　 Das Bild unten ist das vorhergesagte Ergebnis und die richtige Antwort. Was rot geschrieben ist, ist falsch. Ich habe die Epoche nur 10 Mal genommen, daher lag die falsche Antwortrate bei 38%.

Das vollständige Programm finden Sie hier. https://github.com/Fumio-eisan/cifar10_20200308