Einführung

Dieser Artikel ist der dritte Artikel, der für alle drei Male geplant ist. Dieser Artikel ist nur eine zeilenweise Erklärung von mnist_transfer_cnn.py. Es gibt einige Überschneidungen mit dem vorherigen, aber bitte beachten Sie, dass ein Teil des Inhalts möglicherweise dupliziert wird, um das Lesen des Artikels zu erleichtern. 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.)

[Für KI-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: 28px * 28px Farbe: schwarz und weiß Datengröße: 70.000 Blatt (60.000 Trainingsdaten, 10.000 Testdatenbilder und Etiketten sind verfügbar)

Was ist Feinabstimmung?

Verwenden Sie die Parameter eines vorhandenen guten Modells als Anfangswerte, um eine andere Aufgabe zu erledigen. Auf diese Weise können Sie die Berechnungskosten senken und die Genauigkeit verbessern.

Apropos Zeit

Erstellen Sie ein Modell zur Klassifizierung von 0-4 Bildern (erstellen Sie die zugrunde liegenden Gewichte).
Legen Sie das Gewicht der Ebene fest, die die Merkmale des Bildes des erstellten Modells extrahiert, damit es nicht geändert werden kann.
Trainieren Sie 5 bis 9 Bilder (vollständig verbundene Ebene = aktualisieren Sie nur das Gewicht des zu klassifizierenden Teils)
Schließlich wird ein Modell fertiggestellt, das 5 Arten handgeschriebener Zeichen von 5 bis 9 als Eingabe empfängt und diese in 5 Typen von 5 bis 9 klassifiziert.

*** Da wir trainiert haben, Bilder von 5 bis 9 zu klassifizieren, können wir Bilder von 0 bis 4 nicht klassifizieren, wenn das Modell diesmal endgültig fertiggestellt ist. *** ***

Codebeschreibung

Vorbereitung

'''Trains a simple convnet on the MNIST dataset.
Gets to 99.25% test accuracy after 12 epochs
(there is still a lot of margin for parameter tuning).
16 seconds per epoch on a GRID K520 GPU.
'''
'''Transfer learning toy example.
1 - Train a simple convnet on the MNIST dataset the first 5 digits [0..4].
2 - Freeze convolutional layers and fine-tune dense layers
   for the classification of digits [5..9].
Get to 99.8% test accuracy after 5 epochs
for the first five digits classifier
and 99.2% for the last five digits after transfer + fine-tuning.
'''

#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 datetime
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K

#Holen Sie sich die aktuelle Zeit
now = datetime.datetime.now

#Konstante
batch_size = 128   #Chargengröße. Datengröße auf einmal zu lernen
num_classes = 5    #Anzahl der zu klassifizierenden Etiketten. Dieses Mal werden wir handgeschriebene Bilder in 5 Typen von 5 bis 9 klassifizieren.
epochs = 5         #Anzahl der Epochen. Wie oft müssen alle Daten gelernt werden?
img_rows, img_cols = 28, 28  #Anzahl der Dimensionen des Eingabebildes
filters = 32       #Anzahl der Faltfilter
pool_size = 2      #Maximale Poolgröße
kernel_size = 3    #Klappfilter(Kernel)Größe
#Datenform
if K.image_data_format() == 'channels_first':
    input_shape = (1, img_rows, img_cols)
else:
    input_shape = (img_rows, img_cols, 1)

In Bezug auf das Datenformular sind die Details [Für AI-Anfänger] mnist_cnn.py wird Zeile für Zeile erklärt (lernen Sie MNIST mit Keras) Überprüfen. Es wird im Datenvorverarbeitungsteil beschrieben.

Es wird festgestellt, dass das Bildformat unterschiedlich ist, je nachdem, ob das Keras-Backend Theano (canal_first) oder Tensorflow (channel_last) ist. Diesmal ist es Tensorflow, also wird es (28, 28, 1) sein.

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

#Erstellen Sie Datensätze, die durch Beschriftung 5 oder mehr oder weniger getrennt sind
#Trainingsbild mit einem Etikettenwert von weniger als 5
x_train_lt5 = x_train[y_train < 5]
#Trainingsetikett mit einem Etikettenwert von weniger als 5
y_train_lt5 = y_train[y_train < 5]
#Testbild mit einem Etikettenwert von weniger als 5
x_test_lt5 = x_test[y_test < 5]
#Testetikett mit einem Etikettenwert von weniger als 5
y_test_lt5 = y_test[y_test < 5]

#Trainingsbild mit einem Etikettenwert von 5 oder mehr
x_train_gte5 = x_train[y_train >= 5]
#Ein Datensatz von Trainingsetiketten mit einem Etikettenwert von 5 oder mehr minus 5.(5-9 ⇒ 0-4)
y_train_gte5 = y_train[y_train >= 5] - 5
#Testbild mit einem Etikettenwert von 5 oder mehr
x_test_gte5 = x_test[y_test >= 5]
#Datensatz von Testetiketten mit einem Etikettenwert von 5 oder mehr minus 5.(5-9 ⇒ 0-4)
y_test_gte5 = y_test[y_test >= 5] - 5

Um ein Modell zu erstellen, das Bilder von 0 bis 4 klassifiziert, teilen wir es zunächst in Daten von 0 bis 4 und Daten von 5 bis 9 auf.

Ändern Sie als Nächstes für die Daten 5 bis 9 die Beschriftung von 5 auf 9 auf 0 auf 4.

Modelldefinition

#Modelldefinition(.add()Muster, die keine Methoden verwenden)

#Lernen Sie Funktionen mit Faltung
feature_layers = [
    #Faltschicht (Filter: 32 Blatt, Filtergröße:(3, 3), Eingangsgröße empfangen:(28, 28, 1))
    Conv2D(filters, kernel_size,
           # padding='valid'Nicht mit 0 auffüllen. 0 Beim Auffüllen'same'Konkretisieren
           padding='valid',
           input_shape=input_shape),
    #Aktivierungsfunktion: Relu
    Activation('relu'),
    #Faltschicht (Filter: 32 Blatt, Filtergröße:(3, 3))
    Conv2D(filters, kernel_size),
    #Aktivierungsfunktion: Relu
    Activation('relu'),
    #Pooling-Schicht
    MaxPooling2D(pool_size=pool_size),
    # 0.25 Ausfallchancen
    Dropout(0.25),
    #Konvertieren Sie Daten in eine Dimension
    Flatten(),
]

#Lernen Sie die Klassifizierung in vollständig verbundenen Ebenen
classification_layers = [
    #Vollständig verbundene Schicht (128 Einheiten)
    Dense(128),
    #Aktivierungsfunktion: relu
    Activation('relu'),
    # 0.5 Chance auszusteigen
    Dropout(0.5),
    #Vollständig verbundene Schicht (5 Einheiten)
    Dense(num_classes),
    #Aktivierungsfunktion: Softmax(Aufgrund von Klassifizierungsproblemen)
    Activation('softmax')
]

#Feature in der sequentiellen Klasse_Schichten und Klassifizierung_Instanziieren Sie, was Ebenen passiert hat
model = Sequential(feature_layers + classification_layers)

Dieses Mal wird das Modell im Gegensatz zu Teil 1 und Teil 2 ohne Verwendung der .add () -Methode definiert. In Keras können Sie ein Modell auch definieren, indem Sie eine geordnete Liste von Ebenen an Sequential () übergeben und instanziieren.

Der Grund für das Schreiben auf diese Weise ist, dass *** die Feinabstimmung das Gewicht nur einer bestimmten Schicht während des Lernens nicht ändert (oder ändert) ***. Deshalb wage ich es, es so zu schreiben.

*** Durch Definieren der Ebene zum Extrahieren der Merkmale des Bildes und der Ebene zum separaten Klassifizieren wird es einfach, nur eine der Gewichte zu aktualisieren ***.

Funktion zum Lernen

#Erstellen Sie eine Funktion zum Trainieren
def train_model(model, train, test, num_classes):
    
    #Datenvorverarbeitung
    #Das Datenformat umformen und anpassen
    x_train = train[0].reshape((train[0].shape[0],) + input_shape)  # (30596, 28, 28) -> reshape(30596, 28, 28, 1)
    x_test = test[0].reshape((test[0].shape[0],) + input_shape)     # (5139, 28, 28)  -> reshape(5139, 28, 28, 1)
    #Bilddaten haben einen Wert von 0 bis 255, standardisieren Sie die Daten also durch Teilen durch 255.
    x_train = x_train.astype('float32')
    x_test = x_test.astype('float32')
    # .astype('float32')Konvertieren Sie den Datentyp mit.(Andernfalls sollten Sie eine Fehlermeldung erhalten, wenn Sie brechen)
    x_train /= 255
    x_test /= 255
    print('x_train shape:', x_train.shape)
    print(x_train.shape[0], 'train samples')
    print(x_test.shape[0], 'test samples')

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

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

    #Holen Sie sich Lernstartzeit
    t = now()
    #Lernen
    model.fit(x_train, y_train,       #Trainingsdaten, Etikett
              batch_size=batch_size,  #Chargengröße (128)
              epochs=epochs,          #Anzahl der Epochen (5)
              verbose=1,              #Zeigen Sie den Lernfortschritt in Echtzeit als Balkendiagramm an(Bei 0 verstecken)
              validation_data=(x_test, y_test))  #Testdaten(Um jede Epoche zu testen und den Fehler zu berechnen)
    #Geben Sie die zum Lernen benötigte Zeit aus
    print('Training time: %s' % (now() - t))
    
    #Auswertung
    #Testdaten bestehen(verbose=0 gibt keine Fortschrittsmeldung aus)
    score = model.evaluate(x_test, y_test, verbose=0)
    #Fehler bei der Ausgabeverallgemeinerung
    print('Test score:', score[0])
    #Leistung der Ausgabeverallgemeinerung
    print('Test accuracy:', score[1])

Dieses Mal werden wir zweimal trainieren, um ein Modell zu erstellen, das 5 bis 9 Bilder klassifiziert.

Lernen

#Lernen Sie die oben erstellte Funktion
#Lernen Sie, indem Sie Bildern mit weniger als 5 0-4 Beschriftungen geben(Klassifizieren)
train_model(model,
            (x_train_lt5, y_train_lt5),
            (x_test_lt5, y_test_lt5), num_classes)

# trainable=Falsch, um das Lernen der Ebene zu verhindern
#Feature, das das zu faltende Teil ist_Stellen Sie ein, dass die Parameter von Ebenen nicht aktualisiert und klassifiziert werden sollen_Aktualisieren Sie nur die Parameter von Ebenen
#Damit die Änderungen wirksam werden, kompilieren Sie sie im Modell, nachdem sich die Eigenschaft geändert hat()Müssen anrufen
for l in feature_layers:
    l.trainable = False

#Lernen Sie die oben erstellte Funktion
#Lernen Sie, indem Sie 5 oder mehr Bildern 0-4 Beschriftungen geben(Klassifizieren)
train_model(model,
            (x_train_gte5, y_train_gte5),
            (x_test_gte5, y_test_gte5), num_classes)

Es lernt endlich.

Erstellen Sie ein Modell zur Klassifizierung von 0-4 Bildern (erstellen Sie die zugrunde liegenden Gewichte).
Korrigieren Sie das Gewicht von feature_layers, damit es nicht geändert werden kann
Trainieren Sie 5 bis 9 Bilder (vollständig verbundene Ebene = aktualisieren Sie nur das Gewicht des zu klassifizierenden Teils)
Schließlich ist ein Modell fertiggestellt, das 5 Arten handgeschriebener Zeichen von 5 bis 9 als Eingabe empfängt und sie in 5 Typen von 5 bis 9 klassifiziert!

abschließend

Dies ist das Ende aller drei Artikel mit Quellenkommentaren. Die Erklärung ist beendet, aber als Bonus werde ich einen Artikel darüber veröffentlichen, wie das Modell gespeichert und geladen wird und wie es beim nächsten Mal verwendet wird. Wenn Sie es nur machen und nicht speichern, verschwindet es, obwohl Sie es gemacht haben.

[PYTHON] [Für KI-Anfänger] Ich werde mnist_transfer_cnn.py Zeile für Zeile erklären (MNIST mit Keras lernen)