[Traduisez approximativement le didacticiel TensorFlow en japonais] 1. MNIST pour les débutants en ML

MNIST pour les débutants en apprentissage automatique

introduction

Je publierai un mémorandum sur TensorFlow, une bibliothèque d'apprentissage en profondeur que Google a commencé à fournir. TensorFlow a une explication détaillée du didacticiel, j'ai donc essayé de le traduire en japonais. ・ À propos de TensorFlow-> http://www.tensorflow.org/ ・ Traduction originale de cette époque-> http://www.tensorflow.org/tutorials/mnist/beginners/index.md Veuillez noter que certaines traductions peuvent sembler étranges car elles sont en japonais authentique.

Ce tutoriel correspond au chapitre 2 du livre "Deep Learning" de M. Okaya, vous voudrez peut-être le lire ensemble.

Ensuite, le modèle créé cette fois est un modèle appelé Soft max Regression.

Données MNIST

Lisez les données MNIST.

import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

Les données téléchargées sont divisées en deux parties. 60 000 points de données d'entraînement (mnist.train) et 10 000 points de données de test (minist.test).

Toutes les données MNIST se composent de deux éléments: une image numérique manuscrite et les données d'étiquette correspondantes. Ici, l'image manuscrite est appelée xs et les données d'étiquette sont appelées ys. (ex, mnist.train.images et mnist.train.labels)

Chaque image manuscrite 28 pixels x 28 pixels = 784 nombres En d'autres termes, c'est une chaîne de nombres (vecteur).

Cela correspond à jeter les informations bidimensionnelles. La méthode la plus difficile intègre également cette information bidimensionnelle, mais cette fois je ne la considérerai pas jusqu'à présent.

En conséquence de ce qui précède, mnist.train.images devient un tenseur (matrice à n dimensions), et sa forme est [60000,784].

Les données d'étiquette correspondantes sont exprimées sous la forme d'un "vecteur à un seul point". ex, 0 -> [1,0,0,0,0,0,0,0,0,0,0] 3 -> [0,0,0,1,0,0,0,0,0,0,0] Ainsi mnist.train.labels est un tableau de [6000,10].

Régression Softmax

La régression Softmax est un modèle naturel et simple. Softmax est utile si vous souhaitez donner des probabilités à une cible et des probabilités à d'autres cibles également. (Exemple: cette image a 80% de chances d'être 9, 5% probablement 8 ...)

Pour calculer qu'une image donnée appartient à une classe particulière, nous calculons la somme pondérée des valeurs de pixel. Ce poids a du sens. La partie rouge représente «poids négatif» et la partie bleue représente «poids positif». (* Le bleu ressemble à un nombre ..?)

Exécuter la régression

Pour des calculs python efficaces, nous nous appuyons généralement sur des bibliothèques telles que Numpy qui permettent d'effectuer des calculs lourds en dehors de python. Cependant, quand je reviens à python, cela coûte beaucoup de calcul. Si vous souhaitez faire des GPU ou différents calculs parallèles, ceux-ci sont très défavorables.

TensorFlow vous permet d'écrire tous les graphiques des instructions associées complètement en dehors de python, au lieu de laisser une instruction lourde être effectuée indépendamment de python.

frais généraux .. Coûts de gestion du matériel et des programmes

Tout d'abord, importez tensorflow.

import tensorflow as tf

Décrivez les instructions interdépendantes décrites ci-dessus en manipulant des variables symboliques.

x = tf.placeholder("float",[None,784])

x n'est pas une valeur spécifique, on l'appelle un espace réservé. Il s'agit de la valeur que vous entrez lorsque vous demandez à TensorFlow d'effectuer le calcul.

La valeur d'entrée de l'image MNIST a été convertie en un vecteur de 784 dimensions. Celles-ci sont exprimées sous la forme d'un tenseur bidimensionnel de [None, 784].

Le modèle a également besoin de poids et de biais. La variable est utilisée dans de tels cas. La variable est un tenseur mutable qui «vit» dans le graphique des instructions interactives de TensorFlow.

w = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))

Cette fois, j'ai fait W et b comme Variable qui n'a que 0. Nous apprendrons W et b à partir de maintenant, donc la valeur initiale n'a pas vraiment d'importance.

Vous pouvez maintenant exécuter le modèle!

y = tf.nn.softmax(tf.matmul(x,W)+b)

Il semble que tf.matmul (x, W) est utilisé pour multiplier x et W, b lui est ajouté et le résultat est affecté à la fonction Softmax par tf.nn.softmax. La raison pour laquelle x est un tenseur bidimensionnel est qu'il peut être multiplié par W. (Probablement matmul = matrice multiple)

Apprentissage

Une fonction d'erreur est utilisée pour évaluer quantitativement ce qui constitue une bonne modélisation en tant qu'apprentissage automatique. Cette fois, nous utiliserons une fonction d'erreur appelée entropie croisée. Ici, y est la distribution de probabilité du résultat prédit cette fois, et y est la vraie distribution.

Pour exécuter l'entropie croisée, vous devez d'abord ajouter un nouvel espace réservé pour entrer la bonne réponse.

y_ = tf.placeholder("float",[None,10])

Et vous pouvez exécuter une entropie croisée.

cross_entropy = -tf.reduce_sum(y_*tf.log(y))

tf.log (y) calcule le logarithme de chaque élément de y, calcule la multiplication avec chaque valeur de y_, et enfin tf.reduce_sum ajoute tous les éléments du tenseur.

L'apprentissage est facile avec TensorFlow. TensorFlow connaît l'intégralité du graphique de son calcul, il peut donc utiliser automatiquement l'algorithme de rétropropagation. L'algorithme de rétropropagation révèle efficacement comment les variables affectent la fonction d'erreur à minimiser.

train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

Cette fois, TensorFlow est invité à minimiser cross_entropy à un taux d'apprentissage de 0,01 à l'aide de l'algorithme de descente de gradient. la descente de gradient est une procédure simple et TensorFlow modifie simplement chaque variable légèrement dans le sens d'une erreur plus petite. Mais TensorFlow a beaucoup d'algorithmes d'optimisation et il est très facile de les utiliser.

Avant d'entraîner le modèle, nous devons ajouter une seule instruction pour initialiser les variables définies. (* Pas encore exécuté!)

init = t.initialize_all_bariables()

Enfin, vous pouvez démarrer la session. Exécutons l'instruction pour initialiser la variable.

sess = tf.Session()
sess.run(init)

Et répétez la formation 1000 fois!

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})

À chaque étape de la boucle, nous obtenons un "lot" de 100 points de données aléatoires à partir du jeu de données d'entraînement que nous avons préparé. Puis exécutez train_step, donnez chaque donnée de lot et changez l'espace réservé.

La technique d'utilisation de «petits lots» de données aléatoires est appelée apprentissage stochastique, dans ce cas la descente de gradient stochastique.

Évaluation du modèle créé

Tout d'abord, déterminez ce que vous avez correctement prédit. tf.argmax est une fonction très utile qui renvoie la valeur que le tenseur a le plus grand élément le long d'un axe. Par exemple, tf.argmax (y, 1) renvoie l'étiquette la plus probable pour chaque entrée et tf.argmax (y_, 1) renvoie l'étiquette correcte. Et tf.equal peut être utilisé pour déterminer si notre prédiction était correcte.

correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))

Par conséquent, une liste de valeurs booléennes est renvoyée. Convertissez-le en valeur Float pour faciliter l'utilisation et prenez la moyenne. Par exemple, [True, False, True, True] devient [1,0,1,1] et la moyenne est de 0,75.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

Enfin, nous demandons le taux d'exactitude prédictive des données de test

print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})

Ce résultat sera d'environ 91%.