J'ai essayé "MNIST For ML Beginners" qui est écrit dans le tutoriel TensorFlow pour les débutants en apprentissage automatique. J'ai donc implémenté la reconnaissance numérique de MNIST, qui s'écrit Hello World of Machine Learning. MNIST est un ensemble de données d'images manuscrites. Ici, les images de nombres manuscrits de 0 à 9 sont lues et classées par opportunité d'apprentissage. L'exemple de code sur Github de TensorFlow semble difficile, mais lorsque je n'ai essayé que l'implémentation nécessaire, c'était vraiment simple et pouvait être implémenté en 20 lignes.
Cloud9 Python 2.7.6 Sample Codes : GitHub La construction de l'environnement est "Utiliser TensorFlow dans l'environnement de développement intégré au cloud Cloud9 ~ Get Started ~" L’utilisation de base de TesorFlow est «Utilisation de TensorFlow dans l’environnement de développement intégré au cloud Cloud9 - Principes d’utilisation-» Voir
Il est situé sur Github, mais ce qui suit est le code implémenté.
mnist_softmax_train.py
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
# Download gz files to MNIST_data directory
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
# Initializing
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 28*28])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
W = tf.Variable(tf.zeros([28*28, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
sess.run(tf.initialize_all_variables())
# Making model
y = tf.matmul(x, W) + b
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y, y_))
# Training
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
for i in range(1000):
batch = mnist.train.next_batch(100)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
# Evaluating
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
# Save train data
saver = tf.train.Saver()
saver.save(sess, 'param/softmax.param')
Lorsque je l'exécute, il semble que la précision soit d'environ 92% comme décrit dans le tutoriel.
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
Je reçois des données. J'ai créé un répertoire appelé MNIST_data et y ai téléchargé 4 fichiers. Le contenu est une boîte noire, vous devez donc le vérifier.
sess = tf.InteractiveSession()
x = tf.placeholder(tf.float32, shape=[None, 28*28])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
W = tf.Variable(tf.zeros([28*28, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
sess.run(tf.initialize_all_variables())
C'est le processus d'initialisation. x contient les données d'image (28 pixels x 28 pixels) et y_ contient l'étiquette (0-9) de l'image. Puisqu'il s'agit d'un espace réservé, je l'attribuerai plus tard. W et b sont des paramètres, où W est le poids de chaque pixel de l'image et b est la section.
y = tf.matmul(x, W) + b
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y, y_))
y est une expression qui calcule la valeur prédite à partir des paramètres et x. La formule suivante est la régression softmax. La régression logistique est un modèle qui prédit 0 et 1, mais il est étendu pour pouvoir prédire plusieurs étiquettes (0 à 9 dans ce cas). Le didacticiel comprenait également des formules détaillées, je pense donc que vous devez également l'étudier.
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
for i in range(1000):
batch = mnist.train.next_batch(100)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
GradientDescentOptimizer est une méthode de descente de gradient probabiliste. Les premières données téléchargées avec mnist.train.next_batch sont acquises dans l'ordre et affectées à la variable avec feed_dict = {x: batch [0], y_: batch [1]}. Nous recherchons la solution optimale en l'exécutant à plusieurs reprises.
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
Nous vérifions l'exactitude de y (valeur prédite) et y_ (valeur réelle) à l'aide de données de test.
saver = tf.train.Saver()
saver.save(sess, 'param/softmax.param')
C'est le processus de sauvegarde des paramètres appris. Vous pouvez maintenant classer les images plus tard en utilisant uniquement les paramètres.
Vous avez appris les données numériques manuscrites ci-dessus. En utilisant ce paramètre, j'ai essayé de classer les données manuscrites que j'ai écrites. Mes données manuscrites sont également sur Github, mais c'est un bmp en noir et blanc. Je le charge avec parsebmp.py. Les données MNIST sont entraînées avec des valeurs numériques de 0 à 1, mais ce processus est facile avec seulement des données 0 et 1. Quand je l'ai déplacé, il était précis à 60%. C'est loin d'être 92%, mais on peut dire que cela peut être jugé dans une certaine mesure. ⇒ Un prétraitement était nécessaire pour prédire les données manuscrites. Pour plus de détails, reportez-vous à l'article Prédire vos données manuscrites avec TensorFlow.
mnist_softmax.py
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
import sys
import numpy as np
import parsebmp as pb
def whatisit(file, sess):
print("File name is %s" % file)
data = pb.parse_bmp(file)
# Show bmp data
for i in range(len(data)):
sys.stdout.write(str(int(data[i])))
if (i+1) % 28 == 0:
print("")
# Predicting
d = np.array([data])
result = sess.run(y, feed_dict={x: d})
# Show result
print(result)
print(np.argmax(result, 1))
if __name__ == "__main__":
# Restore parameters
x = tf.placeholder(tf.float32, shape=[None, 28*28])
y_ = tf.placeholder(tf.float32, shape=[None, 10])
W = tf.Variable(tf.zeros([28*28, 10]), name="W")
b = tf.Variable(tf.zeros([10]), name="b")
y = tf.matmul(x, W) + b
sess = tf.InteractiveSession()
saver = tf.train.Saver()
saver.restore(sess, 'param/softmax.param')
# My data
whatisit("My_data/0.bmp", sess)
whatisit("My_data/1.bmp", sess)
whatisit("My_data/2.bmp", sess)
whatisit("My_data/3.bmp", sess)
whatisit("My_data/4.bmp", sess)
whatisit("My_data/5.bmp", sess)
whatisit("My_data/6.bmp", sess)
whatisit("My_data/7.bmp", sess)
whatisit("My_data/8.bmp", sess)
whatisit("My_data/9.bmp", sess)
Tout d'abord, j'ai implémenté le code en regardant le tutoriel. C'est vraiment facile à mettre en œuvre, mais je pense que vous devez comprendre les points suivants.
--Contenu des données d'utilisation
Aussi, pour bien le comprendre, j'aimerais pouvoir saisir mes propres données manuscrites et faire des prédictions. Je pense que cela conduira à une utilisation pratique. ⇒ J'ai essayé de prédire mes données manuscrites le 27/03/2017.
--2018 / 06/12: Ajout de la prédiction des données manuscrites --2017 / 03/27: Ajout de la façon de sauvegarder les paramètres et le contenu prédit de vos propres données manuscrites --2016 / 10/30: Nouveau poste
Recommended Posts