[Pour les débutants en IA] Expliquez mnist_mlp.py ligne par ligne (apprenez MNIST avec Keras)

introduction

Agréable de vous rencontrer tous. Cet article n'est qu'une explication ligne par ligne de mnist_mlp.py. Il est destiné aux personnes intéressées par l'IA mais qui n'y ont pas encore touché. Je pense que si vous lisez ceci, vous devriez être en mesure de comprendre le flux d'apprentissage de base de l'apprentissage profond. (À l'origine, il a été créé en interne avec l'intention de l'utiliser pour la formation)

Les trois temps sont prévus.

1. [Pour les débutants en IA] Expliquez mnist_mlp.py ligne par ligne (apprenez MNIST avec Keras)
2. [Pour les débutants en IA] Expliquez mnist_cnn.py ligne par ligne (apprenez MNIST avec Keras)
3. [Pour les débutants en IA] Expliquez mnist_transfer_cnn.py ligne par ligne (apprenez MNIST avec Keras)

À propos de la méthode de vérification du fonctionnement

Puisque MNIST est une image, il est préférable d'avoir un GPU pour exécuter ce code (c'est un peu pénible pour un CPU). La méthode recommandée consiste à utiliser Google Colaboratory. Il n'y a que deux choses à faire. · Ouvrez un nouveau notebook Python 3 · Activer le GPU à partir du runtime Vous pouvez maintenant utiliser le GPU. Collez simplement le code dans la cellule et exécutez-le (le raccourci est CTRL + ENTRÉE) et cela fonctionnera.

À propos de mnist

Un ensemble de données d'images de texte manuscrit, souvent utilisé dans les didacticiels d'apprentissage automatique. Contenu: caractères manuscrits de 0 à 9 Taille de l'image: 28 pixels * 28 pixels Couleur: noir et blanc Taille des données: 70000 feuilles (60000 données d'entraînement, 10000 images et étiquettes de données de test disponibles)

Qu'est-ce que mlp

Perceptron multicouche, un perceptron multicouche. Bien que mnist soit des données d'image, il peut être formé comme mlp en changeant la forme des données d'image de (28, 28) à (784,). (La précision est plus élevée pour CNN, ce qui sera fait dans la partie 2.)

À propos de mnist_mlp.py

Il s'agit du code pour créer un modèle qui juge les caractères manuscrits de mnist à l'aide de Keras et de TensorFlow. Reçoit 10 types de caractères manuscrits de 0 à 9 en entrée et crée un modèle qui les classe en 10 types de 0 à 9.

Description du code

Préparation

'''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.
'''

#Aucun code spécial nécessaire (requis si Python version 3 mais le code est écrit en Python 2)
from __future__ import print_function

#Importez les bibliothèques requises
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout
from keras.optimizers import RMSprop

#Spécifiez d'abord les constantes ensemble
batch_size = 128  #Taille du lot. Taille des données à apprendre en une seule fois
num_classes = 10  #Nombre d'étiquettes à classer. Cette fois, nous classerons les images manuscrites en 10 types de 0 à 9.
epochs = 20       #Nombre d'époques. Combien de fois pour apprendre toutes les données

Prétraitement des données

#Lire les données mnist et former les données(60000 caisses)Et tester les données(10000 caisses)Diviser en
(x_train, y_train), (x_test, y_test) = mnist.load_data()

'''Remodeler et faire correspondre le format de données afin qu'il puisse être utilisé comme données d'entrée dans mlp
x_train：(60000, 28, 28) ->(60000, 784) 28pix*28pix images d'affilée
x_test：(10000, 28, 28) ->(10000, 784) 28pix*28pix images d'affilée'''
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)

#Les données d'image prennent une valeur de 0 à 255, donc standardisez les données en les divisant par 255.
# .astype('float32')Convertissez le type de données avec.(Sinon, vous devriez obtenir une erreur lorsque vous vous brisez)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255

#Sortez le nombre de données et vérifiez
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')

#Étiqueter les données un-hot-Vectoriser
'''one-hot-L'image du vecteur ressemble à ceci
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)

À propos de la normalisation: la valeur de chaque pixel de l'image est comprise entre 0 et 255. C'est une image qui convertit cela en 0 ~ 1. Lors de l'apprentissage automatique avec des images, la valeur est normalisée en divisant par 255.

À propos d'un vecteur chaud: cette fois, il existe 10 types d'étiquettes de 0 à 9, et chacune est représentée par un nombre de 0 à 9. Cependant, les nombres sur l'étiquette elle-même n'ont aucun sens parce que je veux simplement les classer en 10 types. Par conséquent, par un vecteur chaud, il est converti de sorte que seuls 0 et 1 peuvent représenter quelle étiquette.

Définition du modèle

#Instancier une classe séquentielle
model = Sequential()

#Couche intermédiaire
#Ajout d'une couche entièrement connectée (512 unités, fonction d'activation: Relu, taille d'entrée de réception: 784)
model.add(Dense(512, activation='relu', input_shape=(784,)))  
# 0.2 chances d'abandonner
model.add(Dropout(0.2))
#Ajout d'une couche entièrement connectée (512 unités, fonction d'activation: Relu, la taille d'entrée reçue est automatiquement déterminée)
model.add(Dense(512, activation='relu'))
# 0.2 chances d'abandonner
model.add(Dropout(0.2))

#Couche de sortie
#Ajout d'une couche entièrement connectée (10 unités, fonction d'activation: SoftMax, la taille d'entrée reçue est automatiquement déterminée)
model.add(Dense(num_classes, activation='softmax'))

#Visualisez la structure du modèle
model.summary()

Le modèle séquentiel est un modèle réalisé en empilant des couches de DNN. Vous devez spécifier input_shape uniquement pour la toute première couche. Puisque la fonction d'activation de la couche de sortie est cette fois un modèle de classification à valeurs multiples, softmax est utilisé.

Apprentissage

#Mettre en place le processus d'apprentissage
model.compile(
              #Réglez la fonction de perte. Cette fois, c'est une classification, si catégorique_crossentropy
              loss='categorical_crossentropy',
              #Spécifiez l'algorithme d'optimisation. Ajustez le taux d'apprentissage, etc.
              optimizer=RMSprop(),
              #Spécifier la fonction d'évaluation
              metrics=['accuracy'])

#Apprendre
history = model.fit(
                    #Données d'entraînement, étiquette
                    x_train, y_train, 
                    #Taille du lot (128)
                    batch_size=batch_size,
                    #Nombre d'époques (20)
                    epochs=epochs,
                    #Afficher la progression de l'apprentissage sous forme de graphique à barres en temps réel(Cacher à 0)
                    verbose=1,
                    #données de test(Pour tester chaque époque et calculer l'erreur)
                    validation_data=(x_test, y_test))

Après avoir défini le modèle, spécifiez la fonction de perte et l'algorithme d'optimisation et compilez. Ensuite, transmettez les données au modèle pour l'entraînement. Afin de faire un meilleur modèle, il est nécessaire d'essayer divers changements tels que l'algorithme d'optimisation, la taille du lot, le nombre d'époques, etc.

Évaluation

#Passer les données de test(verbose=0 ne donne pas de message de progression)
score = model.evaluate(x_test, y_test, verbose=0)
#Erreur de généralisation de la sortie
print('Test loss:', score[0])
#Performances de généralisation de sortie
print('Test accuracy:', score[1])

Après l'apprentissage, utilisez les données de test pour évaluer les performances que vous avez obtenues. Plus la perte est faible et plus la précision est élevée, meilleur est le modèle.