Challenge classification des images par TensorFlow2 + Keras 2 ~ Regardons de plus près les données d'entrée ~

introduction

Essayons ** la classification des images numériques manuscrites (MNIST) ** avec ** TensorFlow2 + Keras ** dans l'environnement Google Colaboratory (+ approfondir la compréhension de Python et du deep learning). Dernière fois a un exemple de code tiré du [Tutoriel HP officiel] de TensorFlow (https://www.tensorflow.org/tutorials/quickstart/beginner) Je suis arrivé au point où je l'ai essayé.

• Classification des images de défi par la série TensorFlow2 + Keras
• 1. Déplacer pour le moment
• 2. Examinez de plus près les données d'entrée
• 3. Visualiser les données MNIST
• 4. Prédisons avec le modèle entraîné
• 5. Observez les images dont la classification échoue
• 6. Essayez de prétraiter et de classer les images préparées vous-même
• 7. Comprendre les types de couches et les fonctions d'activation
• 8. Sélectionnez l'algorithme d'optimisation et la fonction de perte
• 9. Essayez d'apprendre, d'enregistrer et de charger le modèle

Selon "Illustrated Rapid Learning DEEP LEARNING (Auteur: Tomoaki Masuda)", ** MNIST ** a les origines suivantes. Bien qu'elles ne soient pas directement liées ici, les données brutes sont disponibles sur http://yann.lecun.com/exdb/mnist/.

L'un des NIST (base de données du National Institute of Standards and Technology) avait un ensemble de données avec des chiffres écrits à la main par le personnel du US Census Bureau et des lycéens. "M" NIST est une version modifiée de celui-ci qui est plus facile à utiliser avec l'apprentissage automatique.

Cette fois, nous expliquerons le contenu des ** données d'entraînement ** (x_train, y_train) et ** données de test ** (x_test, y_test) dans l'exemple de code affiché la dernière fois. Regardez de plus près ou utilisez matplotlib pour le visualiser.

Tout d'abord, j'organiserai "** problème de classification multi-classes " et " apprentissage profond **" (confirmer le positionnement des données d'entraînement et des données de test).

Problème de classification multi-classes

La reconnaissance des nombres manuscrits fait partie du ** problème de classification multi-classes **. Le problème de la classification multi-classes est le problème de la prédiction de la ** catégorie (classe) des données d'entrée **. Les catégories sont données à l'avance telles que «chien», «chat» et «oiseau» dans le paramètre de problème **, et pour les données d'entrée (par exemple, image), elles sont «chien», «chat» et «oiseau». Parmi ceux-ci, le problème est de savoir à quelle catégorie il appartient.

Différentes approches ont été proposées pour le problème de classification multi-classes, mais ici nous allons le résoudre en utilisant ** deep learning ** (deep learning).

L'apprentissage en profondeur

L'apprentissage profond appartient à une technique appelée ** apprentissage automatique supervisé **. L'apprentissage automatique supervisé est composé en gros de ** 2 étapes ** appelées "phase d'apprentissage" et "phase de prédiction (phase d'inférence, phase d'application)".

Tout d'abord, dans la ** phase d'apprentissage , un grand nombre de paires de ** données d'entrée ** et de ** données de réponse correcte ** (= données de l'enseignant, données de réponse correctes, valeur de réponse correcte, étiquette de réponse correcte) sont données au modèle. Laissez-les apprendre leurs relations. L'ensemble de paires de ces données d'entrée et des données de réponse correctes est appelé ** données d'entraînement ** (= données d'entraînement). Et le modèle entraîné à l'aide des données d'entraînement est appelé " modèle entraîné **".

Dans la ** phase de prédiction ** suivante, des ** données d'entrée inconnues ** sont fournies au modèle entraîné pour ** prédire la sortie ** (Predict). Pour les problèmes multi-classes, la catégorie (par exemple "chien") est la sortie prédictive.

Ensuite, le processus de ** Evaluate ** consiste à mesurer "les performances du modèle entraîné". Dans l'évaluation, tout d'abord, ** les données d'entrée et les données de réponse correctes différentes de celles utilisées pour l'apprentissage sont préparées, et parmi celles-ci, seules les données d'entrée ** sont données au modèle entraîné pour obtenir des données de prédiction. Ensuite, répondez aux données de prédiction obtenues en utilisant les données de réponse correctes, notez-les et utilisez-les comme valeur d'évaluation. En tant qu'indices d'évaluation spécifiques, en plus du ** taux de réponse correcte ** (précision) et de la ** valeur de la fonction de perte ** (perte) apparus la dernière fois, divers éléments tels que le taux de précision et le taux de rappel sont disponibles selon les besoins. Sera adopté.

Données d'entraînement MNIST, données de test

Le code suivant télécharge les données MNIST et les stocke dans chaque variable (x_train, y_train, x_test, y_test) (le programme entier était [précédent](https: // qiita. Voir com / code0327 / items / 7d3c7bd3327ff049243a)).

python

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

Ici, * _train est les données d'entrée et de réponse correcte affectées pour la formation (pour l'apprentissage), et * _test est la donnée d'entrée et de réponse correcte affectée pour le test (pour l'évaluation du modèle). Il y en a 60 000 pour la formation et 10 000 pour les tests.

De plus, x _ *** est les données d'entrée (c'est-à-dire les données représentant une image manuscrite: 256 niveaux de gris de 28x28), et y _ *** est la donnée de réponse correcte (catégorie de "0" à "9"). Est stocké dans un tableau.

Tout d'abord, utilisons len () pour confirmer que chacun est en fait composé de 60 000 et 10 000 données.

python

#Données d'entraînement
print(len(x_train))  #Résultat d'exécution-> 60000
print(len(y_train))  #Résultat d'exécution-> 60000
#Données de test
print(len(x_test))   #Résultat d'exécution-> 10000
print(len(y_test))   #Résultat d'exécution-> 10000

Ensuite, vérifions le ** type ** de chaque donnée.

python

print(type(x_train)) #Résultat d'exécution-> <class 'numpy.ndarray'>
print(type(y_train)) #Résultat d'exécution-> <class 'numpy.ndarray'>
print(type(x_test))  #Résultat d'exécution-> <class 'numpy.ndarray'>
print(type(y_test))  #Résultat d'exécution-> <class 'numpy.ndarray'>

Ensuite, vérifions le contenu de y_train (= données de réponse correctes pour l'entraînement).

python

print(y_train) #Résultat d'exécution-> [5 0 4 ... 5 6 8]

Il a été constaté que la valeur de réponse correcte des 0èmes données est "5", la valeur de réponse correcte des premières données est "0" ... et la valeur de réponse correcte des 59 999ème données est "8".

Ensuite, vérifions le contenu de x_train (= représentant une image manuscrite pour l'entraînement). Afficher tous les éléments serait ridicule, donc seul le premier x_train [0] est ciblé.

python

(x_train, y_train), (x_test, y_test) = mnist.load_data()
print(x_train[0].shape) #Résultat d'exécution-> (28, 28)
print(x_train[0])       #Résultat d'exécution->Voir ci-dessous

Vous pouvez vérifier la taille des données dans numpy.ndarray avec .shape. (28, 28), ce qui signifie que x_train [0] est composé de ** 28 lignes et 28 colonnes tableau bidimensionnel **. De plus, la sortie de print (x_train [0]) ressemble à ceci:

Si vous le regardez avec un œil clair, vous pouvez voir le chiffre manuscrit légèrement déformé "5". Cela correspond au "5" stocké dans y_train [0].

Vous pouvez voir que chaque donnée de pixel est composée de ** valeurs comprises entre ** 0 et 255, 0 étant l'arrière-plan (blanc) et 255 étant le texte le plus sombre (noir).

Je voudrais vérifier toutes les 60 000 données.

python

import numpy as np
print(x_train.min())  #Extraire la valeur minimale#Résultat d'exécution-> 0
print(x_train.max())  #Extraire la valeur maximale#Résultat d'exécution-> 255

Vous pouvez voir que toutes les données sont comprises entre 0 et 255.

Au fait, combien de nombres de «0» à «9» existent dans les 60 000 données d'entraînement? En gros, je pense que 10 modèles de 0 à 9 existent presque uniformément, mais vérifions. Utilisez des pandas pour l'agrégation.

version pandas

import pandas as pd

tmp = pd.DataFrame({'label':y_train})
tmp = tmp.groupby(by='label').size()
display(tmp)
print(f'Nombre total={tmp.sum()}')

Résultat d'exécution

label
0    5923
1    6742
2    5958
3    6131
4    5842
5    5421
6    5918
7    6265
8    5851
9    5949
dtype: int64
Nombre total=60000

Il semble y avoir une certaine variation, comme moins «5» et plus «1».

Vous pouvez le trouver sans utiliser de pandas comme suit.

version numpy

import numpy as np
tmp = list([np.count_nonzero(y_train==p) for p in range(10)])
print(tmp)                #Résultat d'exécution-> [5923, 6742, 5958, 6131, 5842, 5421, 5918, 6265, 5851, 5949]
print(f'Nombre total={sum(tmp)}') #Résultat d'exécution-> Nombre total=60000

la prochaine fois

• Je voulais aller jusqu'à afficher graphiquement les données d'entrée en utilisant matplotlib, mais l'article est devenu long, alors j'aimerais le faire la prochaine fois.