Cliquez ici pour la loterie de Keras à partir de rien [http://qiita.com/Ishotihadus/items/6ecf5684c2cbaaa6a5ef)
À partir de ce moment, la version Keras est 2.0.5, mais cela ne devrait pas poser de problème.
Jusqu'au précédent, Keras était utilisé pour la classification à deux classes.
MNIST
Un ensemble de données dont tous ceux qui ont touché à l'apprentissage automatique ont entendu parler. Abréviation de la base de données modifiée du National Institute of Standards and Technology.
Le nombre 0 à 9 est écrit sur l'image monochrome, et le but est de reconnaître quel numéro de l'image.
28 x 28 pixels, monochrome 8 bits. Bien sûr avec une étiquette. Les données d'entraînement sont de 60 000 et les données de test de 10 000.
Le site officiel est ici. Il existe également un enregistrement du taux d'erreur pour chaque méthode. En regardant cela, je pense que le réseau de neurones n'est pas particulièrement étonnant.
Keras a cette MNIST disponible par défaut. Pratique.
Apprenons avec un réseau normal pour le moment.
Les données MNIST de Keras sont un entier compris entre 0 et 255 pour chaque pixel. C'est gênant, alors divisez par 255,0 pour tenir entre 0 et 1.
De plus, comme il s'agit de données bidimensionnelles (trois dimensions si la direction des données est incluse), chacune est constituée d'une dimension (deux dimensions si la direction des données est incluse) par remodelage. reshape est une fonction qui modifie uniquement la forme du tableau tout en conservant l'ordre et le nombre total de données.
L'étiquette est un tableau d'entiers de 0 à 9, mais il est également transformé en un hot.
Par exemple, si c'est «7», il doit être «[0,0,0,0,0,0,0,1,0,0]».
Notez que y_test n'a pas besoin d'être fait, il est donc omis.
Les données peuvent être téléchargées lors de l'exécution de mnist.load_data ().
from keras.datasets import mnist
from keras.utils import np_utils
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784) / 255.0
x_test = x_test.reshape(10000, 784) / 255.0
y_train = np_utils.to_categorical(y_train, num_classes=10)
Faites un modèle du réseau. Ici, un réseau neuronal à deux couches de 784-1300-10 est créé. Il existe différentes manières de compter les couches, mais dans No Keras, le processus jusqu'à «recevoir les données de la couche précédente et effectuer un certain traitement (comme l'application d'une fonction d'activation)» est compté comme une couche. Par conséquent, la couche d'entrée n'est pas comptée comme une couche.
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
model = Sequential([
Dense(1300, input_dim=784, activation='relu'),
Dropout(0.4),
Dense(10, activation='softmax')
])
model.compile('adam', 'categorical_crossentropy', metrics=['accuracy'])
Le décrochage est une couche d'abandon. Keras sélectionne au hasard un pourcentage spécifié (40% dans ce cas) des nœuds de la couche précédente (dans ce cas, la couche Dense avec 1300 nœuds) et définit la sortie sur 0. Cela a pour effet d'éviter le surapprentissage.
from keras.callbacks import EarlyStopping
es = EarlyStopping(monitor='val_acc')
model.fit(x_train, y_train, batch_size=100, validation_split=0.2, callbacks=[es])
EarlyStopping
Ici, un nouveau appelé Early Stopping est utilisé. L'apprentissage peut être arrêté automatiquement à un endroit approprié pour éviter le surapprentissage.
Spécifiez les éléments à observer sur le moniteur. J'ai choisi «val_acc» (précision de validation), mais «val_loss» (perte de validation) est plus courante (?).
La valeur de batch_size dans l'argument de fit ci-dessus.
La taille du lot est le nombre de données à calculer en une seule fois. Il peut être égal au nombre total de données d'entraînement, c'est-à-dire 48 000 dans cet exemple (la validation coupe 20%). Si vous réduisez la taille du lot, par exemple, 100 pièces, seules 100 pièces sont traitées dans un calcul, donc dans ce cas, 480 pièces sont calculées au total. Cette unité de calcul de 480 temps est appelée une époque. Si la taille du lot est beaucoup plus petite que le nombre de données, on parle de mini-lot (apprentissage). À propos, lorsque la taille du lot est de 1, on l'appelle stochastique (cela semble peu familier au Japon).
En réduisant la taille du lot, la quantité de mémoire utilisée est réduite. De plus, puisque le nombre de mises à jour de paramètres par époque augmente, la convergence sera plus rapide. Cependant, il existe un inconvénient: si la taille du lot est trop petite, les paramètres seront violents. Par conséquent, la taille du lot doit être bien choisie.
En passant, si vous ne spécifiez pas la taille du lot, ce sera le nombre total de données.
predict = model.predict_classes(x_test)
print(sum(predict == y_test) / 10000.0)
Le taux de réponse correcte devrait être d'environ 98%.
predire_classes est celui qui prédit les classes.
Jouez avec des paramètres tels que le taux d'abandon et la taille du lot.
from keras.datasets import mnist
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers import Dense, Activation, Dropout
from keras.callbacks import EarlyStopping
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784) / 255.0
x_test = x_test.reshape(10000, 784) / 255.0
y_train = np_utils.to_categorical(y_train, num_classes=10)
model = Sequential([
Dense(1300, input_dim=784, activation='relu'),
Dropout(0.4),
Dense(10, activation='softmax')
])
model.compile('adam', 'categorical_crossentropy', metrics=['accuracy'])
es = EarlyStopping(monitor='val_acc')
model.fit(x_train, y_train, batch_size=100, validation_split=0.2, callbacks=[es])
predict = model.predict_classes(x_test)
print(sum(predict == y_test) / 10000.0)
En fait, je voulais traiter avec CNN cette fois et comparer la performance avec celle illustrée ci-dessus, mais elle est devenue plus longue, alors j'ai décidé de le faire la prochaine fois. Je le ferai la prochaine fois.
Recommended Posts