Einführung

Schön, euch alle zu treffen. Dieser Artikel ist nur eine zeilenweise Erklärung von mnist_mlp.py. Es ist für Leute gedacht, die sich für KI interessieren, diese aber noch nicht berührt haben. Ich denke, wenn Sie dies lesen, sollten Sie in der Lage sein, den grundlegenden Lernfluss des tiefen Lernens zu verstehen. (Ursprünglich wurde es im eigenen Haus erstellt, um es für Schulungen zu verwenden.)

Alle drei Zeiten sind geplant.

[Für AI-Anfänger] Erklären Sie mnist_mlp.py Zeile für Zeile (lernen Sie MNIST mit Keras)
[Für KI-Anfänger] Erklären Sie mnist_cnn.py Zeile für Zeile (lernen Sie MNIST mit Keras)
[Für KI-Anfänger] Erklären Sie mnist_transfer_cnn.py Zeile für Zeile (lernen Sie MNIST mit Keras)

Informationen zur Funktionsprüfungsmethode

Da MNIST ein Image ist, ist es besser, eine GPU zu haben, um diesen Code auszuführen (es ist ein bisschen schmerzhaft für eine CPU). Die empfohlene Methode ist die Verwendung von Google Colaboratory. Es gibt nur zwei Dinge zu tun. · Öffnen Sie ein neues Python 3-Notizbuch · Aktivieren Sie die GPU zur Laufzeit Sie können jetzt die GPU verwenden. Fügen Sie einfach den Code in die Zelle ein und führen Sie ihn aus (Verknüpfung ist STRG + EINGABETASTE), und es wird funktionieren.

Über Mnist

Ein Datensatz handgeschriebener Textbilder, der häufig in Tutorials zum maschinellen Lernen verwendet wird. Inhalt: Handschriftliche Zeichen von 0 bis 9 Bildgröße: 28pix * 28pix Farbe: schwarz und weiß Datengröße: 70.000 Blatt (60.000 Trainingsdaten, 10.000 Testdatenbilder und Etiketten sind verfügbar)

Was ist mlp

Mehrschichtiges Perzeptron, ein mehrschichtiges Perzeptron. Obwohl mnist Bilddaten sind, können sie als mlp trainiert werden, indem die Form der Bilddaten von (28, 28) auf (784,) geändert wird. (Die Genauigkeit ist für CNN höher, was in Teil 2 beschrieben wird.)

Über mnist_mlp.py

Dies ist der Code zum Erstellen eines Modells, das die handgeschriebenen Zeichen von mnist mithilfe von Keras und TensorFlow beurteilt. Empfängt 10 Arten handgeschriebener Zeichen von 0 bis 9 als Eingabe und erstellt ein Modell, das sie in 10 Typen von 0 bis 9 klassifiziert.

Codebeschreibung

Vorbereitung

'''Trains a simple deep NN on the MNIST dataset.
Gets to 98.40% test accuracy after 20 epochs
(there is *a lot* of margin for parameter tuning).
2 seconds per epoch on a K520 GPU.
'''

#Kein spezieller Code erforderlich (erforderlich, wenn Python Version 3, aber Code in Python 2 geschrieben ist)
from __future__ import print_function

#Importieren Sie die erforderlichen Bibliotheken
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop

#Geben Sie zuerst die Konstanten zusammen an
batch_size = 128  #Chargengröße. Datengröße auf einmal zu lernen
num_classes = 10  #Anzahl der zu klassifizierenden Etiketten. Dieses Mal werden wir handgeschriebene Bilder in 10 Typen von 0 bis 9 klassifizieren.
epochs = 20       #Anzahl der Epochen. Wie oft müssen alle Daten gelernt werden?

Datenvorverarbeitung

#Lesen Sie die wichtigsten Daten und Zugdaten(60.000 Fälle)Und Testdaten(10.000 Fälle)Teilen in
(x_train, y_train), (x_test, y_test) = mnist.load_data()

'''Formen Sie das Datenformat neu und passen Sie es an, damit es als Eingabedaten in mlp verwendet werden kann
x_train：(60000, 28, 28) ->(60000, 784) 28pix*28 Pixel Bilder hintereinander
x_test：(10000, 28, 28) ->(10000, 784) 28pix*28 Pixel Bilder hintereinander'''
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)

#Bilddaten haben einen Wert von 0 bis 255, standardisieren Sie die Daten also durch Teilen durch 255.
# .astype('float32')Konvertieren Sie den Datentyp mit.(Andernfalls sollten Sie eine Fehlermeldung erhalten, wenn Sie brechen)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255

#Geben Sie die Anzahl der Daten aus und überprüfen Sie sie
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

#Beschriften Sie die Daten eins-hot-Vektorisieren
'''one-hot-Das Bild des Vektors sieht so aus
label  0 1 2 3 4 5 6 7 8 9
0:    [1,0,0,0,0,0,0,0,0,0]
8:    [0,0,0,0,0,0,0,0,1,0]'''
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

Informationen zur Standardisierung: Der Wert jedes Pixels im Bild beträgt 0 bis 255. Dies ist ein Bild, das dies in 0 ~ 1 konvertiert. Beim maschinellen Lernen mit Bildern wird der Wert durch Teilen durch 255 standardisiert.

Über One-Hot-Vector: Dieses Mal gibt es 10 Arten von Beschriftungen von 0 bis 9, die jeweils durch eine Zahl von 0 bis 9 dargestellt werden. Die Zahlen auf dem Etikett selbst sind jedoch bedeutungslos, da ich sie nur in 10 Typen einteilen möchte. Daher wird es durch einen Ein-Hot-Vektor so konvertiert, dass nur 0 und 1 welches Label darstellen können.

Modelldefinition

#Sequentielle Klasse instanziieren
model = Sequential()

#Mittelschicht
#Vollständig verbundene Schicht hinzugefügt (512 Einheiten, Aktivierungsfunktion: Relu, empfangende Eingangsgröße: 784)
model.add(Dense(512, activation='relu', input_shape=(784,)))  
# 0.2 Chance auszusteigen
model.add(Dropout(0.2))
#Vollständig verbundene Schicht hinzugefügt (512 Einheiten, Aktivierungsfunktion: Relu, empfangene Eingangsgröße wird automatisch bestimmt)
model.add(Dense(512, activation='relu'))
# 0.2 Chance auszusteigen
model.add(Dropout(0.2))

#Ausgabeschicht
#Vollständig verbundene Schicht hinzugefügt (10 Einheiten, Aktivierungsfunktion: SoftMax, empfangene Eingangsgröße wird automatisch bestimmt)
model.add(Dense(num_classes, activation='softmax'))

#Visualisieren Sie die Struktur des Modells
model.summary()

Das sequentielle Modell ist ein Modell, das durch Stapeln von DNN-Schichten erstellt wird. Sie müssen input_shape nur für die allererste Ebene angeben. Da die Aktivierungsfunktion der Ausgabeschicht diesmal ein mehrwertiges Klassifizierungsmodell ist, wird Softmax verwendet.

Lernen

#Richten Sie den Lernprozess ein
model.compile(
              #Stellen Sie die Verlustfunktion ein. Diesmal ist es eine Klassifizierung, also kategorisch_crossentropy
              loss='categorical_crossentropy',
              #Geben Sie den Optimierungsalgorithmus an. Optimieren Sie die Lernrate usw.
              optimizer=RMSprop(),
              #Bewertungsfunktion angeben
              metrics=['accuracy'])

#Lernen
history = model.fit(
                    #Trainingsdaten, Etikett
                    x_train, y_train, 
                    #Chargengröße (128)
                    batch_size=batch_size,
                    #Anzahl der Epochen (20)
                    epochs=epochs,
                    #Zeigen Sie den Lernfortschritt in Echtzeit als Balkendiagramm an(Bei 0 verstecken)
                    verbose=1,
                    #Testdaten(Um jede Epoche zu testen und den Fehler zu berechnen)
                    validation_data=(x_test, y_test))

Geben Sie nach der Definition des Modells die Verlustfunktion und den Optimierungsalgorithmus an und kompilieren Sie. Übergeben Sie dann die Daten zum Training an das Modell. Um ein besseres Modell zu erstellen, müssen verschiedene Änderungen wie Optimierungsalgorithmus, Stapelgröße, Anzahl der Epochen usw. ausprobiert werden.

Auswertung

#Testdaten bestehen(verbose=0 gibt keine Fortschrittsmeldung aus)
score = model.evaluate(x_test, y_test, verbose=0)
#Fehler bei der Ausgabeverallgemeinerung
print('Test loss:', score[0])
#Leistung der Ausgabeverallgemeinerung
print('Test accuracy:', score[1])

Verwenden Sie nach dem Lernen die Testdaten, um zu bewerten, wie viel Leistung Sie erzielt haben. Je geringer der Verlust und je höher die Genauigkeit, desto besser das Modell.

[PYTHON] [Für KI-Anfänger] Erklären Sie mnist_mlp.py Zeile für Zeile (lernen Sie MNIST mit Keras)