Qu'est-ce que MNIST

Tout d'abord, j'expliquerai brièvement le MNIST à utiliser cette fois. MNIST est le nom d'un ensemble de données d'image de nombres manuscrits (0-9). Le contenu du jeu de données MNIST utilisé cette fois est ・ Train: 55000 feuilles ・ Validationm: 5000 feuilles ・ Test: 10000 feuilles Il se compose d'un total de 70 000 feuilles et est un ensemble d'images numériques manuscrites et d'étiquettes de réponses correctes.

train est la formation, la validation est la formation d'hyperparamètres, le test est utilisé pour vérifier l'exactitude du modèle créé, et ce code n'utilise pas de données de validation.

Informations sur l'image

Une image est une image grise 28 * 28 (= 1 canal) Untitled Diagram (1).png

Modèle de création

Le modèle créé cette fois est le suivant

La profondeur de couche est un modèle simple avec seulement deux couches, une couche d'entrée et une couche de sortie. Le nombre de neurones dans la couche d'entrée est de 784 en longueur x largeur x nombre de canaux (28 * 28 * 1) lorsque l'image MNIST est convertie en un tableau unidimensionnel, et la sortie est de 0 à 9, pour un total de 10 La méthode de conversion vers ce tableau unidimensionnel ignore la relation et la forme des informations de pixels adjacents, mais cette fois nous utiliserons cette méthode. La prochaine fois, j'aimerais faire une estimation en utilisant la méthode utilisant CNN.

Code source

`mnist_for_ml_beginners`


#Importer TensorFlow
import tensorflow as tf
#Importation de Numpu depuis la bibliothèque pour le calcul numérique
import numpy as np
#tensorflow.contrib.learn.python.learn.datasets.mnist.fonction py lire_data_Importer des ensembles
from tensorflow.contrib.learn.python.learn.datasets.mnist import read_data_sets

#Lire les données MNIST
mnist = read_data_sets("MNIST_data/", one_hot=True)

#Variables d'entrée(Le nombre de données:Nne données d'entrée:784 pièces)
x = tf.placeholder("float", [None, 784])

#Variables de poids(Initialiser avec 0)
W = tf.Variable(tf.zeros([784, 10]))
#Variable de biais(Initialiser avec 0)

b = tf.Variable(tf.zeros([10]))

#production(Effectuer une régression softmax après avoir calculé le produit interne de x et W et ajouté le biais)
#La valeur totale de la sortie devient 1 en utilisant la fonction softmax.(=Peut être exprimé sous forme de probabilité)
y = tf.nn.softmax(tf.matmul(x, W) + b)

#Variables pour les étiquettes correctes(1 valeur sur 10 est 1 et les autres sont 0)
y_ = tf.placeholder("float", [None, 10])

#Calculer l'erreur d'entropie croisée(Plus la valeur de y correspondant à l'étiquette de réponse correcte est élevée, plus il est proche de 0)
cross_entropy = -tf.reduce_sum(y_ * tf.log(y))

#Minimiser l'erreur d'entropie croisée en utilisant la descente de gradient
#Le taux d'apprentissage est de 0.001(Hyper paramètres)
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

#Démarrez le modèle créé dans la session
sess = tf.Session()
#Initialisation
#tf.initialize_all_variables() ->  tf.global_variables_initializer()
sess.run(tf.global_variables_initializer())

#Commencez à apprendre 1000 fois
for i in range(1000):
    #Le traitement par lots(Obtenir au hasard 100 du train)
    batch_xs, batch_ys = mnist.train.next_batch(100)
    #feet_Dans dict x et y_Remplacer la valeur par un espace réservé
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})


#Évaluer le modèle
#argmax(y,1) :Calculer l'indice de la plus grande valeur en y
#tf.equal(,) :True si les valeurs correspondent, False sinon
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))

#tf.cast() :Convertir le type booléen en type float(True =1, False =0)
#tf.reduce_mean() :Calculer la valeur moyenne
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

#Calcul de la précision(=Utilisez le test de Mnist)
print (sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))

La précision du résultat d'exécution était d'environ 92%

en conclusion

Ce que j'ai appris cette fois ・ L'entrée x et l'étiquette correcte y_ sont des espaces réservés ・ Le poids W et la polarisation b sont variables Utiliser.

Et si vous implémentez ce code, il calculera également à l'aide du GPU.J'ai donc trouvé qu'il s'agissait d'une bibliothèque que vous pouvez facilement essayer d'apprentissage automatique.J'aimerais donc continuer à essayer diverses choses en utilisant TensorFlow à l'avenir.

Le site que j'ai utilisé comme référence

[PYTHON] Tutoriel TensorFlow -MNIST pour les débutants en ML