Tutoriel TensorFlow - TensorFlow Mechanics 101 (Traduction)

Tutoriel TensorFlow (TensorFlow Mechanics 101) https://www.tensorflow.org/versions/master/tutorials/mnist/tf/index.html#tensorflow-mechanics-101 C'est une traduction de. Nous sommes impatients de signaler toute erreur de traduction.

Code: tensorflow / examples / tutorials / mnist /

L'objectif de ce didacticiel est de vous montrer comment utiliser TensorFlow pour entraîner et évaluer un réseau de neurones à action directe simple pour classer des nombres manuscrits à l'aide d'un ensemble de données MNIST (classique). Le public cible de ce didacticiel est celui des personnes ayant une expérience de l'apprentissage automatique qui souhaitent utiliser TensorFlow.

Ces didacticiels ne sont pas destinés à enseigner l'apprentissage automatique en général.

Assurez-vous de suivre la procédure d'installation de TensorFlow (http://www.tensorflow.org/get_started/os_setup.html).

Fichier tutoriel

Dans ce tutoriel, nous ferons référence aux fichiers suivants:

Pour démarrer l'entraînement, exécutez directement le fichier Fully_connected_feed.py:

python fully_connected_feed.py

Préparation des données

MNIST est un problème classique de l'apprentissage automatique. Le problème est de regarder une image de 28 x 28 pixels en niveaux de gris de nombres manuscrits et de déterminer lequel des nombres 0 à 9 l'image représente.

Pour plus d'informations, voir la page MNIST de Yann LeCun (http://yann.lecun.com/exdb/mnist/) ou la visualisation MNIST de Chris Olah (http://colah.github.io/posts/). 2014-10-Visualisation-MNIST /).

Télécharger

Au début de la méthode run_training (), la fonction input_data.read_data_sets () vérifie que les données correctes ont été téléchargées dans le dossier d'entraînement local, décompresse les données et renvoie un dictionnaire d'instances DataSet.

data_sets = input_data.read_data_sets(FLAGS.train_dir, FLAGS.fake_data)

Remarque: l'indicateur fake_data est utilisé pour les tests unitaires et peut être ignoré ici.

Pour plus d'informations sur les données, lisez le didacticiel de téléchargement (http://www.tensorflow.org/tutorials/mnist/download/index.html).

Entrée et espace réservé

La fonction placeholder_inputs () définit deux tf.placeholder qui définissent la forme de l'entrée, telle que batch_size, dans le reste du graphique. ) Créez une opération. L'échantillon d'entraînement réel y est introduit.

images_placeholder = tf.placeholder(tf.float32, shape=(batch_size,
                                                       IMAGE_PIXELS))
labels_placeholder = tf.placeholder(tf.int32, shape=(batch_size))

Dans la boucle d'apprentissage ci-dessous, tous les jeux de données d'image et d'étiquette sont découpés pour s'adapter à batch_size à chaque étape, ajustés à ces espaces réservés, puis sess.run () à l'aide du paramètre feed_dict. Passé à la fonction.

Construire un graphique

Après avoir créé les espaces réservés de données, le graphique est construit à partir du fichier mnist.py selon un modèle en trois étapes: inférence (), loss (), training ().

1. inference () -Créez un graphique qui fait avancer le réseau pour la prédiction.
2. loss () - Ajoute une opération pour générer une perte sur le graphique.
3. training () - Ajouter une opération au graphique pour calculer et appliquer le dégradé.

Inférence

La fonction inference () crée un graphique selon les besoins pour renvoyer un tenseur contenant la sortie prédite.

Cette fonction prend un espace réservé d'image comme entrée. Ensuite, construisez d'abord une couche entièrement connectée avec l'activation ReLu, suivie d'une couche linéaire à 10 nœuds qui identifie le logit de sortie.

Chaque couche est créée sous un [tf.name_scope] unique (http://www.tensorflow.org/api_docs/python/framework.html#name_scope). tf.name_scope agit comme un préfixe pour les éléments créés dans cette portée.

with tf.name_scope('hidden1'):

Dans le cadre défini, les pondérations et les biais utilisés à chaque couche sont recherchés en tant qu'instances tf.Variable. Généré en forme:

weights = tf.Variable(
    tf.truncated_normal([IMAGE_PIXELS, hidden1_units],
                        stddev=1.0 / math.sqrt(float(IMAGE_PIXELS))),
    name='weights')
biases = tf.Variable(tf.zeros([hidden1_units]),
                     name='biases')

Par exemple, s'il est créé dans la portée hidden1, le nom unique donné à la variable poids serait "hidden1 / weights".

Chaque variable reçoit une opération d'initialisation dans le cadre de sa construction.

Dans les cas les plus courants comme celui ci-dessus, les poids sont initialisés avec tf.truncated_normal pour donner la forme du tenseur bidimensionnel. tenir. La première dimension est le nombre d'unités dans la couche à partir de laquelle les poids sont combinés, et la seconde dimension est le nombre d'unités dans la couche auquel les poids sont combinés. Dans le premier calque nommé hidden1, le poids est [IMAGE_PIXELS, hidden1_units] car il combine l'entrée d'image et le calque hidden1. L'initialiseur tf.truncated_normal produit une distribution aléatoire avec une moyenne et un écart type donnés.

Et le biais est initialisé avec tf.zeros pour s'assurer que tout commence avec des valeurs nulles. Sa forme est simplement le nombre d'unités dans le calque auquel il est lié.

Trois opérations principales sur le graph-wrapping deux [tf.matmul] pour les couches cachées (http://www.tensorflow.org/api_docs/python/math_ops.html#matmul) tf.nn.relu et tf.matmul pour logit, à leur tour, tf connecté avec des espaces réservés d'entrée ou des tenseurs de sortie pour chaque couche Créé avec une instance .Variable.

hidden1 = tf.nn.relu(tf.matmul(images, weights) + biases)

hidden2 = tf.nn.relu(tf.matmul(hidden1, weights) + biases)

logits = tf.matmul(hidden2, weights) + biases

Enfin, il renvoie un tenseur logit contenant la sortie.

Perte

La fonction loss () construit davantage le graphique en ajoutant les opérations de perte requises.

Tout d'abord, la valeur de labels_placeholder est convertie en un entier 64 bits. Il crée ensuite automatiquement des étiquettes 1-hot à partir de labels_placeholder et [tf.nn.sparse_softmax_cross_entropy_with_logits](https: // www.) Pour comparer ces 1-hot labels avec le logit de sortie de la fonction inference (). tensorflow.org/versions/master/api_docs/python/nn.html#sparse_softmax_cross_entropy_with_logits) L'opération est ajoutée.

labels = tf.to_int64(labels)
cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(
    logits, labels, name='xentropy')

Ensuite, comme perte totale, tf.reduce_mean pour obtenir la moyenne des valeurs d'entropie croisée le long de la dimension du lot (première dimension). ) Utilisez le.

loss = tf.reduce_mean(cross_entropy, name='xentropy_mean')

Il renvoie ensuite un tenseur contenant la valeur de la perte.

Remarque: l'entropie croisée est une idée basée sur la théorie de l'information qui montre à quel point il est mauvais de croire aux prédictions de réseau neuronal pour une vérité donnée. Consultez le billet de blog sur le théorème de l'information visuelle pour plus d'informations. (Http://colah.github.io/posts/2015-09-Visual-Information/ ）

Entraînement

La fonction training () ajoute les opérations nécessaires pour minimiser la perte due à la méthode de descente de gradient.

Tout d'abord, prenez le tenseur de perte de la fonction loss () et passez-le à tf.scalar_summary. Cette opération, lorsqu'elle est utilisée avec SummaryWriter (voir ci-dessous), produit une valeur récapitulative dans le fichier d'événements. Ici, nous publions un instantané de la valeur de la perte chaque fois que le résumé est exporté.

tf.scalar_summary(loss.op.name, loss)

Ensuite, instanciez tf.train.GradientDescentOptimizer. tf.train.GradientDescentOptimizer applique le gradient en fonction du taux d'apprentissage demandé.

optimizer = tf.train.GradientDescentOptimizer(learning_rate)

Générez ensuite une variable qui contiendra les compteurs pour les étapes d'entraînement globales et utilisez l'opération minimiser (). .. L'opération minimiser () met à jour les poids entraînables du système et incrémente les étapes. Par convention, cette opération est appelée train_op et est effectuée par une session TensorFlow pour déclencher une étape complète d'entraînement (voir ci-dessous).

global_step = tf.Variable(0, name='global_step', trainable=False)
train_op = optimizer.minimize(loss, global_step=global_step)

Renvoie un tenseur contenant la sortie de l'opération d'entraînement.

Formation modèle

Une fois le graphe construit, il peut être entraîné et évalué de manière itérative dans une boucle contrôlée par le code utilisateur dans Fully_connected_feed.py.

Graphique

La fonction run_training () commence par la commande python with, qui est un [tf.Graph] global (http://www.tensorflow.org/api_docs/python/framework.html) qui par défaut pour toutes les opérations construites. #Graph) Indique qu'il sera associé à une instance.

with tf.Graph().as_default():

tf.Graph est une collection d'opérations qui peuvent être effectuées ensemble en tant que groupe. La plupart du temps, vous utilisez TensorFlow, vous ne comptez que sur un seul graphique par défaut.

Une utilisation plus complexe avec plusieurs graphiques est possible, mais au-delà de la portée de ce simple tutoriel.

session

Une fois que vous êtes prêt à construire et à générer toutes les opérations dont vous avez besoin, créez une tf.Session pour exécuter le graphique. Je vais.

sess = tf.Session()

Vous pouvez également le générer dans un bloc with pour la portée:

with tf.Session() as sess:

Un argument Session vide indique que vous souhaitez attacher (ou créer) à la session locale par défaut si elle n'a pas été créée.

Immédiatement après la création de la session, toutes les instances de tf.Variable sont appelées individuellement en appelant sess.run (). Il est initialisé par l'opération d'initialisation de.

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

La méthode sess.run () exécute le sous-ensemble complet des graphiques qui correspondent aux opérations passées en paramètres. Je vais. Dans ce premier appel, l'opération d'initialisation est tf.group, qui contient uniquement des initialiseurs de variables. Aucun des autres graphiques n'est exécuté ici, cela se fait dans la boucle d'apprentissage ci-dessous.

Boucle d'entraînement

Après avoir initialisé les variables dans la session, vous pouvez commencer l'entraînement.

Le code utilisateur contrôle la formation étape par étape. Voici la boucle la plus simple pour faire une formation utile:

for step in xrange(FLAGS.max_steps):
    sess.run(train_op)

Cependant, la boucle de ce tutoriel est un peu compliquée. En effet, à chaque étape, vous devez découper les données d'entrée pour qu'elles correspondent aux espaces réservés précédemment générés.

Flux graphique

Créez un dictionnaire de flux à chaque étape. Ce dictionnaire contient l'ensemble d'échantillons utilisé dans l'étape d'apprentissage et est saisi par les espaces réservés qui le représentent.

La fonction fill_feed_dict () interroge le DataSet donné pour obtenir le prochain ensemble d'images et d'étiquettes batch_size. Le tenseur qui correspond à l'espace réservé est rempli avec l'image ou l'étiquette suivante.

images_feed, labels_feed = data_set.next_batch(FLAGS.batch_size,
                                               FLAGS.fake_data)

Crée un objet de dictionnaire python avec l'espace réservé comme clé et le tenseur d'alimentation correspondant comme valeur.

feed_dict = {
    images_placeholder: images_feed,
    labels_placeholder: labels_feed,
}

Ce dictionnaire est passé au paramètre feed_dict de la fonction sess.run () pour fournir un échantillon d'entrée pour les étapes d'apprentissage.

Vérifier l'état

Le code spécifie deux valeurs à récupérer dans l'appel à exécuter: [train_op, loss].

for step in xrange(FLAGS.max_steps):
    feed_dict = fill_feed_dict(data_sets.train,
                               images_placeholder,
                               labels_placeholder)
    _, loss_value = sess.run([train_op, loss],
                             feed_dict=feed_dict)

Puisqu'il y a deux valeurs à récupérer, sess.run () renvoie un taple avec deux éléments. Chaque tenseur de la liste de valeurs extraite qui correspond au tableau numpy dans le taple renvoyé sera rempli avec la valeur de ce tenseur au cours de cette étape d'apprentissage. Puisque train_op est une opération sans valeur de sortie, l'élément correspondant du taple renvoyé est None, il est donc rejeté. Cependant, la valeur du tenseur de perte sera NaN si le modèle diverge pendant l'entraînement, alors capturez-le pour la journalisation.

Même si la formation réussit sans devenir NaN, la boucle de formation affichera un bref texte d'état toutes les 100 étapes pour informer l'utilisateur de l'état de la formation.

if step % 100 == 0:
    print 'Step %d: loss = %.2f (%.3f sec)' % (step, loss_value, duration)

Visualisation de l'état

Tous les résumés (dans ce cas, un seul) sont des graphiques car ils publient les fichiers d'événements utilisés par TensorBoard. Collecté en une seule opération lors de la phase de construction de.

summary_op = tf.merge_all_summaries()

Ensuite, une fois la session créée, vous pouvez instancier tf.train.SummaryWriter pour écrire un fichier d'événements contenant le graphique lui-même et les valeurs de résumé.

summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph)

Enfin, le fichier d'événements est mis à jour avec une nouvelle valeur récapitulative à chaque exécution de summary_op, et la sortie est transmise à la fonction add_summary () de l'écrivain.

summary_str = sess.run(summary_op, feed_dict=feed_dict)
summary_writer.add_summary(summary_str, step)

Une fois le fichier d'événement écrit, TensorBoard peut être exécuté sur le dossier de formation pour afficher les valeurs récapitulatives.

Remarque: Pour plus d'informations sur la création et l'exécution de Tensorboard, consultez le didacticiel inclus Tensorboard: Training Visualization (http://www.tensorflow.org/how_tos/summaries_and_tensorboard/index.html).

Enregistrer le point de contrôle

[Tf.train.Saver](http://www.tensorflow.org/api_docs/python/state_ops.html] pour publier un fichier de point de contrôle qui peut être utilisé pour restaurer le modèle pour une formation et une évaluation supplémentaires. #Saver) est instancié.

saver = tf.train.Saver()

La boucle d'apprentissage appelle périodiquement la méthode saver.save () pour écrire un fichier de point de contrôle dans le répertoire d'apprentissage en utilisant les valeurs actuelles de toutes les variables entraînables.

saver.save(sess, FLAGS.train_dir, global_step=step)

À l'avenir, vous pourrez reprendre l'entraînement à l'aide de la méthode saver.restore (), qui recharge les paramètres du modèle.

saver.restore(sess, FLAGS.train_dir)

Évaluation du modèle

Le code tente d'évaluer le modèle pour chaque ensemble de données d'entraînement et de test toutes les 1000 étapes. La fonction do_eval () est appelée trois fois pour les ensembles de données d'entraînement, de validation et de test.

print 'Training Data Eval:'
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.train)
print 'Validation Data Eval:'
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.validation)
print 'Test Data Eval:'
do_eval(sess,
        eval_correct,
        images_placeholder,
        labels_placeholder,
        data_sets.test)

Notez que les évaluations de data_sets.test sont généralement isolées pour une utilisation plus complexe. En effet, data_sets.test n'est vérifié qu'après une quantité importante d'hypertuning. Évaluez toutes les données pour des problèmes MNIST simples et petits.

Construction du graphe d'évaluation

Avant de pouvoir entrer dans la boucle de formation, nous devons créer une opération Eval. Pour créer une opération Eval, appelez la fonction evaluation () de mnist.py avec les mêmes paramètres logistiques / d'étiquette que la fonction loss ().

eval_correct = mnist.evaluation(logits, labels_placeholder)

La fonction evaluation () génère simplement l'opération tf.nn.in_top_k. tf.nn.in_top_k considère que la sortie de chaque modèle est correcte et marque automatiquement si la vraie étiquette est incluse dans les K principales prédictions de la possibilité. Nous définissons la valeur de K sur 1 car nous ne la considérons correcte que si la prédiction correspond à la vraie étiquette.

eval_correct = tf.nn.in_top_k(logits, labels, 1)

Évaluation de la sortie

Vous pouvez maintenant créer une boucle. La boucle remplit feed_dict et appelle sess.run () pour l'opération eval_correct. L'opération eval_correct évalue le modèle pour un ensemble de données donné.

for step in xrange(steps_per_epoch):
    feed_dict = fill_feed_dict(data_set,
                               images_placeholder,
                               labels_placeholder)
    true_count += sess.run(eval_correct, feed_dict=feed_dict)

La variable true_count regroupe simplement toutes les prédictions que l'opération in_top_k détermine correctement. La précision peut être calculée simplement en divisant cela par le nombre total d'échantillons.

precision = true_count / num_examples
print('  Num examples: %d  Num correct: %d  Precision @ 1: %0.04f' %
      (num_examples, true_count, precision))