[PYTHON] Notes supplémentaires pour TensorFlow MNIST pour les débutants en ML

TensorFlow MNIST For ML Beginners est un tutoriel pour la reconnaissance d'image de nombres manuscrits à l'aide de TensorFlow. Tutoriel TensorFlow --MNIST pour les débutants en ML (Traduction) --Qiita a une traduction en japonais disponible.

En ce qui concerne la façon de penser, je pense que l'explication du problème d'identification multi-classes par la reconnaissance de caractères manuscrits de TensorFlow Kotohajime (MNIST) est facile à comprendre.

Données d'image MNIST

Les données d'image MNIST sont une image manuscrite de 28 pixels x 28 pixels numérotée de 0 à 9 et un ensemble de données d'étiquette correspondant. Par exemple, dans le cas de l'image ci-dessous, le fichier image et les informations d'étiquette "7" forment un ensemble.

Afficher les données d'image lues par le programme

Pour le moment, si vous exécutez le code suivant, la première image de l'image d'apprentissage de MNIST sera sortie comme dans l'exemple ci-dessus. Il y a beaucoup de longues introductions, mais les 5 dernières lignes sont le code d'affichage des images. Même si vous développez le fichier d'archive téléchargé directement avec input_data, vous pouvez simplement vérifier l'image. .. ..

mnist_picture_sample.py

"""This is a test program."""
# -*- coding: utf-8 -*-

import time
import numpy as np
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
import matplotlib.cm as cm
from matplotlib import pylab as plt

#Heure de début
START_TIME = time.time()
print("Heure de début: " + str(START_TIME))

#Lire les données MNIST
#Images de formation 55000(Il semble y avoir une théorie selon laquelle il y a 60000 cas)
#10000 images de vérification
#Les données d'apprentissage et les données de test sont définies avec 0 à 9 images et les étiquettes correspondantes (0 à 9), respectivement.
#La taille de l'image est 28px X 28px(=784)
# mnist.train.images[55000, 784]Tableau de
# mnist.train.lables lire_data_une des méthodes des ensembles_chaud T/Comme suit par F
#   one_hot =Si vrai: [55000, 10]Lorsque l'image des images correspondantes est "3" dans le tableau de[0,0,0,1,0,0,0,0,0,0]
#                         np.argmax([0,0,0,1,0,0,0,0,0,0])⇒ Peut être converti en 3
#   one_hot =Si faux: [55000, 1]Lorsque l'image des images correspondantes est "3" dans le tableau de, 3
# mnist.test.images[10000, 784]Tableau de, mnist.test.étiquettes[10000, 10]Le contenu est mnist.Similaire au train

print("---Commencer à lire les données MNIST---")
is_one_hot = True
mnist = input_data.read_data_sets("MNIST_data/", one_hot=is_one_hot)
print("---Fin de la lecture des données MNIST---")

###Vérifiez le numéro de la première image###
# one_hot=Si vrai
if is_one_hot == True:
    label = np.argmax(mnist.train.labels[0])
else:
    label = mnist.train.labels[0]

###Vérifiez le nombre d'images d'entraînement###
print('mnist.train.images = ' + str(len(mnist.train.images)))
###Vérifiez le nombre d'images de vérification###
print('mnist.test.images = ' + str(len(mnist.test.images)))

#Affichage des données d'image stockées dans un tableau
#Même si vous regardez les informations (disposition) de l'image 28x28 numériquement, ce n'est pas clair, alors laissez-le en commentaire
#print(mnist.train.images[0].reshape(28, 28))

#Heure de fin
END_TIME = time.time()
print("Heure de fin: " + str(END_TIME))
print("Temps requis: " + str(END_TIME - START_TIME))

#Afficher la première image de l'image d'apprentissage sous forme d'image en niveaux de gris
plt.imshow(mnist.train.images[0].reshape(28, 28), cmap = cm.Greys_r)
plt.title(str(label))
plt.axis('off')
plt.show()
plt.close()

Si vous modifiez le processus de «# Afficher la première image de l'image d'entraînement sous forme d'image en niveaux de gris» comme suit, 10 images du début de l'image d'apprentissage seront produites.

#Afficher les 10 premières images de l'image d'apprentissage sous forme d'images en niveaux de gris
#Réservez une zone de sortie d'image de 2 lignes x 5 colonnes
fig, axarr = plt.subplots(2, 5)

#Définir une image dans chaque zone de sortie
for idx in range(10):
    ax = axarr[int(idx / 5)][idx % 5]
    ax.imshow(mnist.train.images[idx].reshape(28, 28), cmap = cm.Greys_r)

    label = ''
    if IS_ONE_HOT == True:
        label = np.argmax(mnist.train.labels[idx])
    else:
        label = mnist.train.labels[idx]
    ax.set_title(str(label))
    ax.axes.get_xaxis().set_visible(False)
    ax.axes.get_yaxis().set_visible(False)
#Sortie d'une image
plt.show()
plt.close()

Le résultat de l'exécution ressemble à ceci.

D'une manière ou d'une autre, l'image de "7" au début ne ressemble qu'à "wo". .. .. Au contraire, il semble que «4» ressemble plus à «7». .. ..

Code de travail pour TensorFlow MNIST pour les débutants en ML

Essayez le tutoriel TensorFlow (1) | mwSoft Je vais essayer de terminer le code publié et de l'exécuter. Je vais.

mnist_beginner.py

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Lecture des données
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#espace réservé prêt
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])

#poids et biais
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

#Utiliser la régression Softmax
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Entropie croisée
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

#L'optimiseur de descente de dégradé que j'ai utilisé plus tôt, cette fois_Utiliser l'entropie
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Initialisation
# initialize_all_la méthode des variables est 2017/3/Il semble qu'il sera supprimé après 2
# global_variables_Passez à l'initialiseur.
# (2017/6 Pas actuellement supprimé)
#init = tf.initialize_all_variables()
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

#Apprentissage
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

#Prédite par les données de test
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#Modifié pour afficher les résultats
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

Si vous l'exécutez à plusieurs reprises, le résultat changera un peu, mais vous pouvez confirmer qu'il est (probablement) reconnu avec une probabilité d'environ 90%.

Ensuite, la suite du code principal du Didacticiel Try TensorFlow (1) | mwSoft est expliquée par "# Les résultats peuvent être affichés. Si vous l'ajoutez sous "Modifier", vous pouvez également voir la valeur du biais et ce qu'est le poids.

・ ・ ・
#Modifié pour afficher les résultats
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

#Affichage de la valeur du biais
print(sess.run(b))

#Importation de la bibliothèque requise pour le dessin d'image
import matplotlib.cm as cm
from matplotlib import pylab as plt

#Contenu des poids
weights = sess.run(W)
f, axarr = plt.subplots(2, 5)
for idx in range(10):
    ax = axarr[int(idx / 5)][idx % 5]
    ax.imshow(weights[:, idx].reshape(28, 28), cmap = cm.Greys_r)
    ax.set_title(str(idx))
    ax.axes.get_xaxis().set_visible(False)
    ax.axes.get_yaxis().set_visible(False)
plt.show()
plt.close()

#Affichage du taux de réponse correct pour chaque valeur numérique
corrects = sess.run(correct_prediction, feed_dict={x: mnist.test.images, y_: mnist.test.labels})
for i in range(10):
    positive = sum(mnist.test.labels[corrects][:, i] == 1)
    all = sum(mnist.test.labels[:, i] == 1)
    print(i, positive / all)

#Affichage de l'image correcte
f, axarr = plt.subplots(5, 8)
for idx, img in enumerate(mnist.test.images[corrects][0:40]):
        ax= axarr[int(idx / 8)][idx % 8]
        ax.imshow(img.reshape(28, 28), cmap = cm.Greys_r)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
plt.show()
plt.close()

#Affichage d'une image incorrecte
f, axarr = plt.subplots(5, 8)
for idx, img in enumerate(mnist.test.images[~ corrects][0:40]):
        ax = axarr[int(idx / 8)][idx % 8]
        ax.imshow(img.reshape(28, 28), cmap = cm.Greys_r)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
plt.show()
plt.close()

Reconnaissez l'image que vous avez écrite à la main

Lorsque j'exécute le code ci-dessus, il semble que Tensorflow puisse être utilisé pour reconnaître les images de caractères manuscrits à environ 90%, mais je peux comprendre d'une manière ou d'une autre.

Quel est le numéro de moi-même:? PC: "3".

Je ne peux pas faire quelque chose comme ça. Donc, en utilisant le résultat appris, ajoutez le code pour reconnaître l'image que vous avez préparée sous "# Modifier pour que le résultat puisse être affiché".

・ ・ ・
#Modifié pour afficher les résultats
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

#Chargement d'image
import cv2
import numpy as np

img = input("Veuillez entrer le chemin du fichier image>")
img = cv2.imread(img, cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (28, 28))
ximage = img.flatten().astype(np.float32)/255.0     #Changer de format
ximage = np.expand_dims(ximage, axis=0)             #Permuter les lignes et les colonnes(784, 1) ⇒ (1, 784)Conversion en

#Effectuer la reconnaissance d'image
predict = sess.run(y, feed_dict={x: ximage})
print('Le résultat de la reconnaissance d'image est "' + str(sess.run(tf.argmax(predict[0]))) + '"est')

Lorsque vous exécutez le script après avoir ajouté le code, il doit renvoyer le résultat de la reconnaissance d'image de l'image spécifiée par l'utilisateur.

Scripts d'apprentissage et de reconnaissance d'image séparés

Puisqu'il est inefficace de réapprendre à partir de zéro chaque fois qu'une image est reconnue, le script d'apprentissage enregistre le résultat d'apprentissage dans un fichier et le script de reconnaissance d'image utilise le résultat d'apprentissage pour effectuer la reconnaissance d'image. Je vais le modifier pour qu'il le soit.

Script d'apprentissage

Entrez les deux codes inclus dans "######## D'ici ########" à "######## Jusqu'ici ########" Une fois ajoutés, les résultats d'apprentissage seront enregistrés dans un fichier.

mnist_beginner_learn.py

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Lecture des données
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#espace réservé prêt
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])

#poids et biais
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

#Utiliser la régression Softmax
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Entropie croisée
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

#L'optimiseur de descente de dégradé que j'ai utilisé plus tôt, cette fois_Utiliser l'entropie
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Initialisation
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

########d'ici########
# tf.train.Si vous exécutez la méthode Saver sans argument,
#Tout tf.La variable est enregistrée
saver = tf.train.Saver()
########Jusque là########

#Apprentissage
for i in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

#Prédite par les données de test
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#Modifié pour afficher les résultats
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

########d'ici########
# tf.Enregistrer la variable
#Pour le moment, créez un répertoire ckpt dans le répertoire courant,
#Le fichier est sorti en dessous.
import os
if os.path.exists('ckpt') == False:
    os.mkdir('ckpt')
saver.save(sess, 'ckpt' + os.sep + 'model.ckpt')
########Jusque là########

Script de reconnaissance d'image

Le code principal est le même que le script d'apprentissage. Après initialisation des paramètres, le code à apprendre est réécrit dans le code à charger à partir du fichier.

mnist_predict.py

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

#Lecture des données
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#espace réservé prêt
x = tf.placeholder(tf.float32, [None, 784])
y_ = tf.placeholder(tf.float32, [None, 10])

#poids et biais
W = tf.Variable(tf.zeros([784, 10]))
b = tf.Variable(tf.zeros([10]))

#Utiliser la régression Softmax
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Entropie croisée
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

#L'optimiseur de descente de dégradé que j'ai utilisé plus tôt, cette fois_Utiliser l'entropie
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Initialisation
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)

########Jusqu'à présent, c'est le même que le script d'apprentissage########

#Chargement des résultats d'apprentissage
saver = tf.train.Saver()
sess.run(tf.global_variables_initializer())
ckpt = tf.train.get_checkpoint_state('./ckpt')
saver.restore(sess, ckpt.model_checkpoint_path) #Lecture de données variables

########À partir de maintenant, cela revient à "Reconnaître l'image que vous avez écrite à la main"########
#Chargement d'image
import cv2
import numpy as np

img = input("Veuillez entrer le chemin du fichier image>")
img = cv2.imread(img, cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (28, 28))
ximage = img.flatten().astype(np.float32)/255.0     #Changer de format
ximage = np.expand_dims(ximage, axis=0)             #Permuter les lignes et les colonnes(784, 1) ⇒ (1, 784)Conversion en

#Effectuer la reconnaissance d'image
predict = sess.run(y, feed_dict={x: ximage})
print('Le résultat de la reconnaissance d'image est "' + str(sess.run(tf.argmax(predict[0]))) + '"est')