[PYTHON] Classification d'image MNIST (numéro manuscrit) avec Perceptron multicouche

introduction

En tant qu'exercice dans "Learn from Mosaic Removal: Cutting-edge Deep Learning" écrit par koshian2, il y avait une classification MNIST par perceptron multicouche. Cette fois, je voudrais le résumer pour approfondir ma compréhension. https://qiita.com/koshian2/items/aefbe4b26a7a235b5a5e

Les principaux points sont les suivants.

• Classification du MNIST par perceptron multicouche
• Signification des variables explicatives dans la classification d'images
• Fonction d'activation dans la couche intermédiaire
• Différence de fonction de perte selon la tâche

Qu'est-ce que le Perceptron multicouche?

Un perceptron multicouche est un réseau qui possède une couche appelée ** couche intermédiaire ** entre la couche d'entrée et la couche de sortie.

Une méthode appelée méthode du carré minimum est connue pour effectuer une régression, et une méthode de régression logistique est connue pour effectuer une classification. Ces méthodes posent le problème que même si le nombre de données est augmenté, la précision ne peut pas être améliorée. Afin de profiter de ce grand nombre de données, le perceptron multicouche est une méthode pour améliorer la précision en insérant une couche appelée couche intermédiaire entre la couche d'entrée et la couche de sortie.

À propos du contenu du programme

Acquisition des données MNIST

mnist.ipynb

import tensorflow as tf
import tensorflow.keras.layers as layers

(X_train,y_train),(X_test,y_test)=tf.keras.datasets.mnist.load_data()
#X_train,y_train: données d'entraînement
#X_test, y_test: données de test

J'ai lu les données d'entraînement et de test directement à partir de l'ensemble de données keras. J'utilise souvent la fonction train_test_split pour classer les données de test à partir des données d'entraînement principales, mais cette fois, c'est facile à lire sans faire cela.

Confirmation des dimensions

mnist.ipynb

print(X_train.shape,y_train.shape)
print(X_test.shape,y_test.shape)

(60000, 28, 28) (60000,) (10000, 28, 28) (10000,)

Vous pouvez voir qu'il existe 60 000 données d'image d'entraînement 28x28 et 10 000 données d'image de test 28x28.

Définition du modèle de perceptron multicouche

mnist.ipynb

inputs = layers.Input((28,28))
x = layers.Flatten()(inputs)
x = layers.BatchNormalization()(x)
x = layers.Dense(128, activation='relu')(x)
x = layers.Dense(10, activation="softmax")(x)
outputs = x
model = tf.keras.models.Model(inputs, outputs)

Ce que j'entends par cette description est la suivante.

1. Défini comme une couche d'entrée 28x28
2. Dimensions des niveaux 28 × 28 à 784
3. Convertissez 784 dimensions en couche intermédiaire de 128 dimensions par la fonction ReLU
4. Convertir en 10 dimensions par la fonction softmax comme couche de sortie

J'ai trouvé que c'était très simple à comprendre car si vous voulez modifier le calque, vous n'avez qu'à changer une ligne.

Compiler le modèle

mnist.ipynb

model.compile('adam', 'sparse_categorical_crossentropy',['sparse_categorical_crossentropy'])

Ici, la méthode d'optimisation, la fonction de perte et la fonction d'évaluation sont déterminées.

La méthode d'optimisation est une méthode pour trouver la valeur d'un paramètre qui rend la valeur de la fonction de perte aussi petite que possible. Cette fois, nous appliquons la méthode Adam couramment utilisée.

https://www.slideshare.net/MotokawaTetsuya/optimizer-93979393 https://qiita.com/ZoneTsuyoshi/items/8ef6fa1e154d176e25b8

La fonction de perte utilise l'entropie croisée catégorique. Cette formule ressemble à ceci:

Où $ N $ est le nombre d'échantillons et $ M $ est le nombre de classes. MNIST prédit la probabilité de chaque classe. La fonction d'erreur gérée par la méthode dite des moindres carrés convient pour prédire les prix, mais je ne suis pas habitué à traiter des probabilités.

Enfin, il y a la fonction d'évaluation. C'est une fonction utile pour visualiser la progression de l'entraînement qui n'est pas utilisée pour l'optimisation.

Exécution du programme d'entraînement / de prédiction et ses résultats de prédiction

mnist.ipynb

#Formation modèle
model.fit(X_train,y_train, validation_data=(X_test, y_test),epochs=10)

#Prédiction de modèle
y_pred_prob= model.predict(X_test)
y_pred = np.argmax(y_pred_prob, axis=-1)

#Sortie de résultat
fig = plt.figure(figsize=(14,14))
for i in range(100):
    ax = fig.add_subplot(10,10,i+1)
    ax.imshow(X_test[i],cmap="gray")
    ax.set_title(y_pred[i])
    ax.axis("off")

Pour les prédictions de modèle, la valeur prédite est une probabilité. Par conséquent, prenez argmax (valeur d'index qui maximise la probabilité) pour convertir en étiquette (0-9).

Vous pouvez voir que la prédiction fonctionne. La méthode ci-dessus est la classification d'image de MNIST par le modèle de perceptron multicouche.

J'aimerais apprendre et expérimenter d'autres cas et articles, etc., car la méthode de construction multicouche et la compilation de modèles sont encore profondes.

Le code complet est affiché ici. https://github.com/Fumio-eisan/minist_mlp20200307