[PYTHON] Challenge classification des images par TensorFlow2 + Keras 3 ~ Visualiser les données MNIST ~

introduction

Il s'agit d'un mémo d'étude (3e) sur la classification des images (environnement Google Colaboratory) utilisant TensorFlow2 + Keras. Le sujet est la classification des images numériques manuscrites (MNIST), qui est un élément standard.

• 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

Dernière fois a acquis les données MNIST et confirmé la structure et le contenu des données. Les données d'entrée correspondant aux données d'image des nombres manuscrits étaient de ** 28 x 28 pixels en 256 niveaux de gris **. Le type de ces données est un tableau bidimensionnel de numpy.ndarray, et j'ai réussi à obtenir le contenu (image image) simplement en faisant print tel quel, mais cette fois en utilisant matplotlib, comme suit Je voudrais l'afficher proprement.

Normalisation des données

Les données MNIST utilisaient des valeurs entières de 0 à 255 pour représenter une échelle de gris de 256 étapes (une échelle de gris avec le blanc attribué à 0 et le noir attribué à 255) (voir la dernière fois pour plus de détails) (https: /). /qiita.com/code0327/items/2c969ca4675d5a3691ef#_reference-e5aaa86657d6319bbb0d)). Cependant, dans l'exemple de code de classification d'images utilisant TensorFlow (voir [Tutoriel] sur le site officiel (https://www.tensorflow.org/tutorials/quickstart/beginner)), pour la commodité de l'apprentissage automatique, 0.0 est comme suit. ** La normalisation ** est appliquée de sorte qu'elle soit dans la plage de ~ 1,0.

import tensorflow as tf
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0 #Processus de normalisation

À partir de maintenant, je voudrais continuer avec des données normalisées de 0,0 à 1,0.

Affichage pour le moment

Je voudrais sortir le premier x_train [0] des données d'entrée pour l'entraînement sous forme d'image en échelle de gris. Ces données seront une image représentant "5" tel que stocké dans les données de réponse correctes y_train [0].

python

import matplotlib.pyplot as plt
plt.figure(dpi=96)
plt.imshow(x_train[0],interpolation='nearest',vmin=0.,vmax=1.,cmap='Greys')

En fonction de l'environnement d'exécution, ʻinterpolation = 'le plus proche'` peut être omis (vous pouvez l'omettre dans Google Colab., Si vous l'exécutez dans un autre environnement et que la sortie devient floue, spécifiez cette option).

De plus, vmin = 0., Vmax = 1. peut être omis si la valeur minimale de l'élément interne des données pertinentes x_train [?] ʻEst 0.0 et la valeur maximale est 1.0 ( cmap = '. Greys '' attribue le blanc à 0,0 et le noir à 1,0). Sinon, par exemple, si vous exprimez des ** caractères légers ** et que la valeur maximale de l'élément interne de x_train [?] Est 0,7, vous ressentirez des caractères légers à moins que vous ne spécifiiez cette option. Cela ne sera pas reflété.

Vous pouvez modifier la ** palette de couleurs ** utilisée pour la sortie en modifiant la valeur de l'argument de mot-clé cmap. Vous pouvez consulter la liste des cartes de couleurs fournies en tant que préréglages dans matplotlib Reference. Par exemple, si vous définissez cmap = 'Greens', la sortie sera la suivante (0.0 sera également vert clair).

Vous pouvez également personnaliser la carte des couleurs. Pour la méthode spécifique, reportez-vous à "Je veux produire une carte de chaleur magnifiquement personnalisée de la matrice de corrélation. Matplotlib ed. @ Qiita".

Sortie côte à côte d'images manuscrites pour des numéros spécifiques

Si vous souhaitez vérifier la manière dont les données manuscrites existent pour un numéro spécifique (par exemple, "7"), vous pouvez les générer avec le code suivant.

python

import numpy as np
import matplotlib.pyplot as plt
x_subset = x_train[ y_train == 7 ]   # (1)
fig, ax = plt.subplots(nrows=8, ncols=8, figsize=(5, 5), dpi=120)
for i, ax in enumerate( np.ravel(ax) ):
  ax.imshow(x_subset[i],interpolation='nearest',vmin=0.,vmax=1.,cmap='Greys')
  ax.tick_params(axis='both', which='both', left=False, 
                 labelleft=False, bottom=False, labelbottom=False) # (2)

Le résultat de l'exécution est le suivant. Si vous souhaitez afficher une valeur autre que 7, modifiez la valeur de y_train == 7 dans (1) du code ci-dessus. ʻAx.tick_params (...) ʻin (2) sert à effacer les échelles des axes X et Y.

Si vous regardez la liste, vous pouvez voir que même parmi ces 64 feuilles, ** il y en a au moins quelques-unes qui ressemblent à «1» ** (c'est-à-dire qu'elles sont incluses). , Un taux de réponse correct de 1,0000 est extrêmement difficile).

Format et affichage

J'ai trouvé que les données d'entrée peuvent être imagées et sorties avec un code très court.

Ici, quelle est la valeur de l'élément dans quelle ligne et colonne de chaque donnée d'entrée comme suit? Je vais le modifier pour que je puisse confirmer jusqu'à. Les lettres rouges en haut à gauche correspondent aux valeurs des données de réponse correctes correspondantes.

python

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patheffects as pe
import matplotlib.transforms as ts

i = 2 #Index des données à afficher

plt.figure(dpi=120)
plt.imshow(x_train[i],interpolation='nearest',vmin=0.,vmax=1.,cmap='Greys')

h, w = 28, 28
plt.xlim(-0.5,w-0.5) #Plage de dessin dans la direction de l'axe X
plt.ylim(h-0.5,-0.5) #Dans la direction de l'axe Y ...

#
plt.tick_params(axis='both', which='major', 
                left=False, labelleft=False, 
                bottom=False, labelbottom=False)
plt.tick_params(axis='both', which='minor',
                left=False, labelleft=True,
                top=False, labeltop=True, 
                bottom=False, labelbottom=False)

#Réglage de la grille pour chaque axe
plt.gca().set_xticks(np.arange(0.5, w-0.5,1)) #Grille en unités de 1 point
plt.gca().set_yticks(np.arange(0.5, h-0.5,1))
plt.grid( color='tab:green', linewidth=1, alpha=0.5)

#Paramètre d'étiquette pour chaque axe
plt.gca().set_xticks(np.arange(0, w),minor=True)
plt.gca().set_xticklabels(np.arange(0, w),minor=True, fontsize=5)
plt.gca().set_yticks(np.arange(0, h),minor=True)
plt.gca().set_yticklabels(np.arange(0, h),minor=True, fontsize=5)

#Réglage fin de la position de l'étiquette
offset = ts.ScaledTranslation(0, -0.07, plt.gcf().dpi_scale_trans)
for label in plt.gca().xaxis.get_minorticklabels() :
    label.set_transform(label.get_transform() + offset)
offset = ts.ScaledTranslation(0.03, 0, plt.gcf().dpi_scale_trans)
for label in plt.gca().yaxis.get_minorticklabels() :
    label.set_transform(label.get_transform() + offset)

#Les données de réponse correctes sont affichées dans le coin supérieur gauche (bordure blanche)
t = plt.text(1, 1, f'{y_train[i]}', verticalalignment='top', fontsize=20, color='tab:red')
t.set_path_effects([pe.Stroke(linewidth=5, foreground='white'), pe.Normal()])

plt.colorbar( pad=0.01 ) #Affichage de la barre de couleur à droite

Histogramme des valeurs de niveaux de gris

Les données d'entrée se composent de 28 $ \ fois 28 = 784 $ éléments, chacun contenant des valeurs de 0,0 à 1,0, mais j'aimerais créer un histogramme de la façon dont il est distribué.

python

import numpy as np
import matplotlib.pyplot as plt

i = 0 #Index des données à afficher

h = plt.hist(np.ravel(x_train[i]), bins=10, color='black')
plt.xticks(np.linspace(0,1,11))
print(h[0]) #Résultat d'exécution-> [639.  11.   6.  11.   6.   9.  11.  12.  11.  68.]
print(h[1]) #Résultat d'exécution-> [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]

La valeur de retour de plt.hist (...) contient la fréquence de chaque classe. Dans l'exemple ci-dessus, vous pouvez voir qu'il y a 639 pixels avec des valeurs dans la plage $ 0,0 \ le v <0,1 $. Seulement à l'extrême droite, la plage est $ 0,9 \ le v \ le 1,0 $, ce qui inclut des données d'une valeur d'exactement 1,0.

Si vous faites réellement print (h [0] .sum ()), vous obtiendrez 784.0, et vous pouvez voir que les éléments avec une valeur d'exactement 1.0 sont également comptés correctement.

la prochaine fois

• Faites des prédictions en utilisant le modèle entraîné.