[PYTHON] Lesen Sie das Keras Mnist-Beispiel

Als ich kürzlich daran dachte, das trendige Deep Learning zu berühren, wurde mir geraten, zuerst mnist mit Keras zu betreiben, also habe ich es versucht. Obwohl es vorerst funktioniert hat, habe ich wenig Python-Kenntnisse und bin ein Anfänger im maschinellen Lernen, daher verstehe ich es nicht, selbst wenn ich mir den Code ansehe. Also versuchte ich herauszufinden, woran ich interessiert war. Ich hoffe, es wird für ähnliche Leute hilfreich sein.

Was ist Keras?

https://keras.io/ja/

Keras ist eine in Python geschriebene übergeordnete neuronale Netzwerkbibliothek, die auf TensorFlow, CNTK oder Theano ausgeführt werden kann. Keras wurde mit dem Ziel entwickelt, schnelle Experimente zu ermöglichen. Die Minimierung der Vorlaufzeit von der Idee zum Ergebnis ist der Schlüssel zu guter Forschung.

Es ist wie in einer Bibliothek, in der Sie ohne Kenntnisse von TensorFlow oder Theano ganz einfach tiefes Lernen ausprobieren können. Es gibt auch ein japanisches Dokument, so dass Sie leicht loslegen können.

Was ist mnist

Ein Datensatz mit ** handgeschriebenen Zahlen ** von 28x28 Pixel, Schwarzweißbildern. Jedes Pixel hat einen Wert von 0 (weiß) bis 255 (schwarz). Enthält 60.000 Lernbilder und 10.000 Testbilder. In dieser Keras-Dokumentation wird außerdem Folgendes erläutert: https://keras.io/ja/datasets/#mnist Es gibt verschiedene andere Dinge wie "Bostons Home Price Return Data Set", auf die ich neugierig bin.

Bewegen Sie die Probe

Ich habe diese Probe auf Github fallen lassen und sie verschoben. https://github.com/fchollet/keras/blob/master/examples/mnist_mlp.py

Ich werde es nach und nach erklären.

import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop

batch_size = 128
num_classes = 10
epochs = 20

↑ "Epochen" gibt an, wie oft "die Trainingsdaten wiederholt trainiert werden". 20 mal im obigen Fall. Die Erklärung auf dieser Seite war leicht zu verstehen → [Wie viele Epochen gibt es?) (Http://st-hakky.hatenablog.com/entry/2017/01/17/165137)

Lesen und Formatieren von Daten

# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()

↑ In dieser einen Zeile wird der Mnist-Datensatz von irgendwoher heruntergeladen. Praktisch! Bilddaten beginnen mit "x_" und Beschriftungen 0 bis 9 beginnen mit "y_".

Als nächstes werden die gelesenen Bilddaten in eine Form umgewandelt, die in das Netzwerk eingegeben werden kann. Die gleiche Verarbeitung wird auf alle Trainingsdaten und Testdaten angewendet.

x_train = x_train.reshape(60000, 784) #Konvertieren Sie ein zweidimensionales Array in ein eindimensionales
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')   #Konvertieren Sie den Typ int in den Typ float32
x_test = x_test.astype('float32')
x_train /= 255                        # [0-255]Der Wert von[0.0-1.0]Umstellung auf
x_test /= 255
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

Als nächstes werden auch die Etikettendaten konvertiert. Ich verwende Keras 'to_categorical'-Funktion, um einen ganzzahligen Wert in ein Array von Binärklassen zu konvertieren. Die Keras-Dokumentation finden Sie hier [https://keras.io/ja/utils/#to_categorical]. Zum Beispiel wird der Wert "5" in das Array "[0, 0, 0, 0, 0, 1, 0, 0, 0, 0]" konvertiert.

# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)

Modellbau

Nachdem die Daten fertig sind, erstellen wir das Modell. Bereiten Sie eine Box mit dem Namen "Sequential" vor und fügen Sie jede Ebene mit "add" hinzu. Im folgenden Beispiel werden 3 Denses und 2 Dropouts hinzugefügt.

model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784,)))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))

model.summary()
model.compile(loss='categorical_crossentropy',
              optimizer=RMSprop(),
              metrics=['accuracy'])

Schauen wir uns Dense and Dropout genauer an.

** Dicht ** ist eine vollständig verbundene neuronale Netzwerkschicht. Die Keras-Dokumentation finden Sie hier [https://keras.io/ja/layers/core/#dense]. Geben Sie die Anzahl der Dimensionen der Ausgabe mit dem ersten Argument an. Die Anzahl der Dimensionen der Eingabe wird durch input_shape angegeben (falls nicht angegeben, entspricht sie der Ausgabe). In der Probe Dense(512, activation='relu', input_shape=(784,)) Daher hat die Eingabe 784 (= 28 x 28) Dimensionen und die Ausgabe 512 Dimensionen.

** Dropout ** ist eine Ebene, die den Eingabewert mit einer bestimmten Rate auf 0 setzt. Im Beispiel ist es "Dropout (0.2)", sodass Sie sehen können, dass 20% der Eingabe verworfen werden. Es scheint wirksam zu sein, um Überlernen zu verhindern. Die Keras-Dokumentation finden Sie hier [https://keras.io/ja/layers/core/#dropout].

In Dense wird die Aktivierungsfunktion durch das Aktivierungsargument angegeben. Der Beispielcode verwendet relu und softmax.

ReLU: Wenn die Eingabe 0 oder weniger ist, ist die Ausgabe ebenfalls 0, und wenn die Eingabe größer als 0 ist, wird sie so ausgegeben, wie sie ist. Die Formel lautet $ f (x) = max (0, x) $, und das Diagramm sieht folgendermaßen aus ist.

Softmax: Eine Funktion, bei der der Wert jeder Komponente im Bereich von 0 bis 1 liegt und die Summe jeder Komponente 1 beträgt. Die Erklärung von dieser Site ist leicht zu verstehen.

Damit ist der Modellbau abgeschlossen.

Lernen

Als nächstes trainieren Sie das Modell mit der angegebenen Anzahl von Epochen.

history = model.fit(x_train, y_train,  #Bild- und Etikettendaten
                    batch_size=batch_size,
                    epochs=epochs,     #Angabe der Anzahl der Epochen
                    verbose=1,         #Protokollausgabe angeben.Wenn es 0 ist, wird kein Protokoll ausgegeben.
                    validation_data=(x_test, y_test))

Auswertung

Bewerten Sie die Genauigkeit des trainierten Modells.

score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])

Ausführungsergebnis

Bei der Ausführung wird das folgende Protokoll ausgegeben. Sie können sehen, dass die Genauigkeit im Verlauf der Epoche nach und nach zunimmt.

60000 train samples
10000 test samples
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
dense_1 (Dense)              (None, 512)               401920    
_________________________________________________________________
dropout_1 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 512)               262656    
_________________________________________________________________
dropout_2 (Dropout)          (None, 512)               0         
_________________________________________________________________
dense_3 (Dense)              (None, 10)                5130      
=================================================================
Total params: 669,706.0
Trainable params: 669,706.0
Non-trainable params: 0.0
_________________________________________________________________
Train on 60000 samples, validate on 10000 samples
Epoch 1/20
60000/60000 [==============================] - 9s - loss: 0.2496 - acc: 0.9223 - val_loss: 0.1407 - val_acc: 0.9550
…(Kürzung)…
Epoch 20/20
60000/60000 [==============================] - 8s - loss: 0.0201 - acc: 0.9950 - val_loss: 0.1227 - val_acc: 0.9829
Test loss: 0.122734002527
Test accuracy: 0.9829