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

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.

多クラス分類.png

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)".

フェーズ.png

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é **".

イメージ.png

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

無題.png

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

Recommended Posts

Challenge classification des images par TensorFlow2 + Keras 2 ~ Regardons de plus près les données d'entrée ~
Défi la classification des images par TensorFlow2 + Keras 4 ~ Prédisons avec un modèle entraîné ~
Challenge classification des images par TensorFlow2 + Keras 1-Move pour le moment-
Challenge classification des images par TensorFlow2 + Keras 3 ~ Visualiser les données MNIST ~
Regardez de plus près le tutoriel Kaggle / Titanic
Jetons un coup d'œil à la carte des fonctionnalités de YOLO v3
Défiez la classification des images avec TensorFlow2 + Keras CNN 1 ~ Bougez pour le moment ~
Défiez la classification des images par TensorFlow2 + Keras 5 ~ Observez les images dont la classification échoue ~
Challenge classification des images par TensorFlow2 + Keras 7-Compréhension des types de couches et des fonctions d'activation-
Jetons un coup d'œil au code Scapy. Comment traitez-vous la structure?
Regardons le diagramme de dispersion avant l'analyse des données
Défiez la classification des images par TensorFlow2 + Keras 6-Essayez le prétraitement et la classification des images préparées par vous-même-
Jetez un œil à l'arborescence des exceptions intégrée à Python
Convertissez les données d'image (png) à portée de main en une image .pbm
Défiez la classification des images avec TensorFlow2 + Keras 9-Apprentissage, sauvegarde et chargement de modèles-
Jetez un œil à l'arborescence des exceptions intégrée dans Python 3.8.2
Jetez un œil au modèle Django.
Jetons un coup d'œil à l'incendie de forêt sur la côte ouest des États-Unis avec des images satellites.
Jetons un coup d'œil au code Scapy. Surcharge des méthodes spéciales __div__, __getitem__.
Juge Yosakoi Naruko par classification d'image de Tensorflow.