[PYTHON] Deep Learning 2 durch Implementierung gelernt (Bildklassifizierung)

Einführung

In der Fortsetzung von Deep Learning 1 wird die handschriftliche Zeichenerkennung von mnist durchgeführt. Im vorherigen Artikel finden Sie die Grundstruktur des Deep Learning.

Implementierung

Daten herunterladen und visualisieren

Dieses Mal werden wir einen öffentlich verfügbaren Datensatz namens mnist für maschinelles Lernen herunterladen, um das Modell zu trainieren und zu testen. Sie können das tatsächlich vorhandene Bild auch beschriften und laden. Lassen Sie uns zunächst die heruntergeladenen Daten herunterladen und visualisieren.

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
a = np.arange(100)
sns.heatmap(a.reshape((10,10)))

Durch die Erstellung einer Heatmap konnten wir die Sequenz einfach visualisieren. Laden Sie jetzt die Daten für die handschriftliche Zeichenerkennung von mnist herunter und visualisieren Sie sie.

from tensorflow.keras.datasets import mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

Jetzt haben Sie die Trainingsbilder (60000, 28, 28) in train_images. Dies bedeutet 60.000 Schattenbilder mit 28 x 28 Pixel. Je nach Ausgabemethode handelt es sich um ein Schwarzweißbild. Werfen wir einen Blick auf das Bild im Inneren.

sns.heatmap(train_images[1210])
print(train_labels[1210])

Jetzt können Sie sehen, dass sich im Bild eine 5 befindet und eine Beschriftung wie 5.

Erstellen wir nun die Daten, um aus diesen Rohdaten zu lernen. Bei einer Klassifizierung mit mehreren Klassen wie dieser Zeit kann die Eingabe unverändert bleiben. Wenn die Ausgabe jedoch eine Zahl auf dem Etikett ist, sinkt die Genauigkeit erheblich, da Sie sich Sorgen um 7 oder 9 und Ausgabe 8 machen Es kann sein. Daher ist die Ausgabe so viele wie die Anzahl der Beschriftungen, und was ausgegeben wird, ist die Wahrscheinlichkeit, dass die Eingabe diese Beschriftung ist. Daher wird die folgende Vorverarbeitung durchgeführt.

train_x = train_images.reshape(60000,28,28,1)
train_y = np.zeros((60000,10))
test_x = test_images.reshape((10000,28,28,1))
test_y = np.zeros((10000,10))
for i in range(60000):
  train_y[i][train_labels[i]]=1.0
for i in range(10000):
  test_y[i][test_labels[i]]=1.0

Das Eingabe- / Ausgabeformat ist jetzt vollständig. Test_images enthält übrigens 10000 Datenblätter.

Modellbildung

from keras import layers
from keras import models
from keras import optimizers
model = models.Sequential()
model.add(layers.Conv2D(16,(3,3),padding="same",activation="relu",input_shape = (28,28,1)))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Conv2D(32,(3,3),padding="same",activation="relu"))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Flatten())
model.add(layers.Dense(128,activation = "relu"))
model.add(layers.Dense(128,activation = "relu"))
model.add(layers.Dense(10,activation = "softmax"))
model.compile(loss = "categorical_crossentropy",optimizer="adam",metrics=["accuracy"])

Eine Ebene, die beim letzten Mal nicht verwendet wurde, wurde angezeigt. Ebenen.Conv2D.

Faltschicht

Bei der Verarbeitung eines Bildes im Bereich der Bildverarbeitung kann der Effekt der Unschärfe erhalten werden, indem sein eigener Pixelwert auf den Durchschnitt der umgebenden Pixelwerte geändert wird. Es gibt viele andere Prozesse, die den Wert aller Pixel für Pixel in der Nähe aktualisieren. Mit einem Kernel ist das ganz einfach. https://deepage.net/deep_learning/2016/11/07/convolutional_neural_network.html Diese Seite erklärt die Faltschicht auf leicht verständliche Weise, aber auch hier ist es so, als würde man ein großes Bild mit einer speziellen Pipette auf das nächste Papier kopieren, und die Pipette saugt Farbe an. Manchmal rutschen einige der Farben um mich herum zusammen. Übertragen Sie dann die gewichtete Summe des Sushi auf das nächste Papier (zu diesem Zeitpunkt hat dies keinen Einfluss auf die umgebenden Farben). Der Kernel repräsentiert das Gewicht der Pipette. Da es dann schwierig ist, die Kante einzufärben, wird es als Null-Auffüllung bezeichnet, um das Bild mit 0 zu begrenzen und dann diese Arbeit auszuführen, und Auffüllung = "gleich" im Code wird mit Null begrenzt, um die Bildgröße nicht zu ändern. Es bedeutet, es zu nehmen. Hier ist zu sehen, dass durch Erhöhen der Anzahl von Tropfern ein Bild erhalten werden kann, das einen anderen Effekt auf das Bild hat. Das erste Argument von Conv2D entspricht der Anzahl der zu vergrößernden Bilder. Das nächste Argument ist die Größe des Kernels.

pooling Ich denke, es gibt etwas, das als maximales Pooling geschrieben wurde. Dies ist eine Art Pooling und eine Methode zum Verkleinern von Bildern. 2x2pixel wird als 1pixel angesehen, und das Bild wird verkleinert, indem der Maximalwert in 2x2 angenommen wird. Dies erleichtert die Handhabung der riesigen Dimensionseingabe von Bildern.

softmax Dies ist die Aktivierungsfunktion, die dieses Mal zum ersten Mal angezeigt wurde. Bei der Klassifizierung mehrerer Klassen sollte die Summe der letzten 10-dimensionalen Vektoren 1 sein, da die Wahrscheinlichkeit für jedes Label ausgegeben werden sollte. Softmax macht das gut.

categorical_crossentropy Dies nutzt nicht den Unterschied in der Ausgabe, sondern verwendet eine Kreuzentropie, die zum Lernen im Bereich von 0 bis 1 geeignet ist. Der Verlust, der gegeben wird, wenn 1 als 0,1 beurteilt wird, ist größer als der Verlust, wenn 1 als 0,9 beurteilt wird, was für ein solches Klassifizierungsproblem geeignet ist.

Ausbildung

history = model.fit(train_x,train_y,steps_per_epoch=10,epochs = 10)

Sie können sehen, dass Sie jetzt trainieren. Selbst wenn Sie nichts tun, wird das Protokoll ausgegeben und Sie können sehen, dass die Genauigkeit am Ende des Lernens ohne Trainingsdaten auf 95% oder mehr gestiegen ist.

Übrigens wird der Rückgabewert von model.fit im Verlauf gespeichert, aber Sie können diesen verwenden, um den Lernstatus darzustellen. Zum Beispiel, wenn Sie den Übergang der richtigen Antwortrate sehen möchten

plt.plot(history.history['accuracy'])

Jetzt können wir den Lernprozess visualisieren. Lesen Sie das Keras-Dokument und spielen Sie mit dem Code, um ihn zu verstehen.

Überprüfung

Unabhängig davon, wie viel Trainingsdaten zu Ergebnissen führen, sind sie bedeutungslos, es sei denn, sie können außerhalb der Trainingsdaten verwendet werden. Es gab eine Möglichkeit, dies gleichzeitig mit dem Training zu tun, aber dieses Mal werden wir das Modell nach dem Lernen überprüfen.

model.evaluate(test_x,test_y)

[Verlust, korrekte Antwortrate]. Es ist ersichtlich, dass ähnliche Ergebnisse mit Testdaten erhalten werden.

Am Ende

Dieses Mal habe ich das sogenannte Faltungs-Neuronale Netz in möglichst einfacher Form implementiert. Da die Bildgröße jedoch 28 x 28 beträgt, kann sie auch in der vollständig verbundenen Ebene problemlos erlernt werden. Daher kann es interessant sein, dieses Modell zu implementieren und die Ergebnisse anzuzeigen. Wenn es vollständig kombiniert ist, werden Computermaterialien für $ O (n ^ 4) $ verwendet, sodass keine großen Datenmengen verarbeitet werden können (100x100 ist wahrscheinlich zu viel?). In der Faltung gibt es jedoch nur Variablen für den Kernel, sodass es auch mit 1024x1024 problemlos funktioniert. (gerade rechtzeitig).

Nächstes Mal werde ich mich mit dem generierten Modell befassen. Implementieren Sie vorerst ein normales GAN mit Code, der so einfach wie möglich zu verstehen ist.