Lire l'exemple de keras mnist

Quand je pensais toucher le Deep Learning à la mode récemment, on m'a conseillé d'essayer d'abord d'exécuter mnist avec keras, alors je l'ai essayé. Bien que cela ait fonctionné pour le moment, j'ai peu de connaissances en python et je suis un débutant en apprentissage automatique, donc je ne comprends pas même si je regarde le code. Alors, j'ai essayé de savoir ce qui m'intéressait. J'espère que cela sera utile pour des personnes similaires.

Qu'est-ce que Keras

https://keras.io/ja/

Keras est une bibliothèque de réseau neuronal de haut niveau écrite en Python qui peut être exécutée sur TensorFlow, CNTK ou Theano. Keras a été développé dans le but de permettre des expériences rapides. Minimiser le délai entre l'idée et le résultat est la clé d'une bonne recherche.

C'est comme une bibliothèque où vous pouvez facilement essayer l'apprentissage en profondeur sans connaître TensorFlow ou Theano. Il existe également un document japonais, il est donc facile de commencer.

Qu'est-ce que mnist

Un ensemble de données de ** nombres manuscrits ** de 28x28 pixels, images en noir et blanc. Chaque pixel prend une valeur de 0 (blanc) à 255 (noir). Contient 60 000 images d'apprentissage et 10 000 images de test. Cette documentation keras explique également: https://keras.io/ja/datasets/#mnist Il y a diverses autres choses telles que «l'ensemble de données sur le rendement du prix des maisons de Boston» qui m'intéressent.

Déplacer l'échantillon

J'ai déposé cet échantillon sur github et l'ai déplacé. https://github.com/fchollet/keras/blob/master/examples/mnist_mlp.py

Je vais l'expliquer petit à petit.

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

↑ ʻepochs` est le nombre de fois "combien de fois les données d'entraînement sont entraînées". 20 fois dans le cas ci-dessus. L'explication sur cette page était facile à comprendre → Quel est le nombre d'époques

Lecture et formatage des données

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

↑ Cette ligne téléchargera le jeu de données mnist de quelque part. Pratique! Les données d'image commencent par «x_» et les étiquettes de 0 à 9 commencent par «y_».

Ensuite, les données d'image lues seront transformées en une forme qui peut être entrée dans le réseau. Le même traitement est appliqué à chacune des données d'apprentissage et des données de test.

x_train = x_train.reshape(60000, 784) #Convertir un tableau bidimensionnel en tableau unidimensionnel
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32')   #Convertir le type int en type float32
x_test = x_test.astype('float32')
x_train /= 255                        # [0-255]La valeur de[0.0-1.0]Conversion en
x_test /= 255
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

Ensuite, les données d'étiquette sont également converties. J'utilise la fonction to_categorical de Keras pour convertir une valeur entière en un tableau de classes binaires. La documentation keras est ici [https://keras.io/ja/utils/#to_categorical). Par exemple, la valeur «5» est convertie en tableau «[0, 0, 0, 0, 0, 1, 0, 0, 0, 0]».

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

Construction de modèles

Maintenant que les données sont prêtes, construisons le modèle. Préparez une boîte appelée Sequential et ajoutez-y chaque couche avec ʻadd`. Dans l'exemple ci-dessous, 3 «Dense» et 2 «Dropout» sont ajoutés.

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'])

Examinons de plus près Dense et Dropout.

** Dense ** est une couche de réseau neuronal entièrement connectée. La documentation keras est ici [https://keras.io/ja/layers/core/#dense). Spécifiez le nombre de dimensions de la sortie avec le premier argument. Le nombre de dimensions de l'entrée est spécifié par input_shape (sinon c'est le même que la sortie). Dans l'échantillon Dense(512, activation='relu', input_shape=(784,)) Par conséquent, l'entrée est de 784 dimensions (= 28x28) et la sortie est de 512 dimensions.

** Dropout ** est une couche qui définit la valeur d'entrée sur 0 à un taux spécifié. Dans l'exemple, il s'agit de Dropout (0.2), donc vous pouvez voir que 20% de l'entrée est rejetée. Il semble être efficace pour empêcher le surapprentissage. La documentation keras est ici [https://keras.io/ja/layers/core/#dropout).

Dans Dense, la fonction d'activation est spécifiée par l'argument d'activation. L'exemple de code utilise relu et softmax.

ReLU: lorsque l'entrée est égale ou inférieure à 0, la sortie est également 0, et lorsque l'entrée est supérieure à 0, elle est sortie telle quelle. Lorsqu'elle est écrite dans la formule, $ f (x) = max (0, x) $, et lorsqu'elle est représentée graphiquement, cela ressemble à ceci est.

Softmax: une fonction dans laquelle la valeur de chaque composant est comprise entre 0 et 1 et la somme de chaque composant est 1. L'explication de ce site est facile à comprendre.

Ceci termine la construction du modèle.

Apprentissage

Ensuite, entraînez le modèle avec le nombre d'époques spécifié.

history = model.fit(x_train, y_train,  #Données d'image et d'étiquette
                    batch_size=batch_size,
                    epochs=epochs,     #Spécifier le nombre d'époques
                    verbose=1,         #Spécification de la sortie du journal.S'il vaut 0, aucun journal ne sera généré.
                    validation_data=(x_test, y_test))

Évaluation

Évaluez la précision du modèle entraîné.

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

Résultat d'exécution

Une fois exécuté, le journal suivant sera généré. Vous pouvez voir que la précision augmente petit à petit au fur et à mesure que l'époque progresse.

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
…(réduction)…
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