[PYTHON] [Explication pour les débutants] Tutoriel TensorFlow Deep MNIST

Expliquer les didacticiels pour les experts TensorFlow du point de vue d'un débutant

J'ai lancé le tutoriel TensorFlow Expert Deep MNIST for Experts. J'expliquerai du point de vue des débutants. Il y a de nombreuses parties qui manquent de précision, mais je donne la priorité à la clarté. C'était très difficile par rapport au tutoriel du débutant: crâne: ^{* Ajout d'un code pour que l'image puisse être sortie, et publication d'une image de traitement de convolution / mise en commun (2017/7/27) </ sup>}

Lien de référence

• Installer TensorFlow sur Windows Easy pour les débutants Python
• [Explication pour les débutants] Syntaxe et concept de base de TensorFlow
• [Explication pour les débutants] Tutoriel TensorFlow MNIST (pour les débutants)
• Mémo API TensorFlow
• [Introduction à TensorBoard] Visualisez le traitement TensorFlow pour approfondir la compréhension
• [Introduction à TensorBoard: image] TensorFlow Visualisez le traitement d'image pour approfondir la compréhension
• [Introduction à TensorBoard: Projecteur] Rendre le traitement TensorFlow cool
• TensorFlow Tutorial MNIST (pour les débutants) visualisé avec TensorBoard
• Les traits du visage de Yuki Kashiwagi pour comprendre TensorFlow [Partie 1]

Aperçu du traitement

L'autre jour, le contenu était impressionnant, mais la photo était impressionnante "Je n'ai pas mangé depuis près de 80 ans et j'ai étonné les médecins ascétiques indiens" Je vais l'expliquer sensuellement sans utiliser de formules mathématiques, en utilisant l'image en (je l'ai utilisée car l'image était très facile à comprendre). Le didacticiel TensorFlow Expert Deep MNIST for Experts est principalement ** convolution **, ** pooling **, ** étroitement couplé ** Il se compose de trois processus. Comment juger l'image par chaque processus est comme indiqué dans la figure ci-dessous.

Un aperçu du traitement un peu plus détaillé

Les deux vidéos Youtube suivantes étaient très faciles à comprendre, je publierai donc un lien (en anglais).

• A friendly introduction to Convolutional Neural Networks and Image Recognition
• How Convolutional Neural Networks work

En outre, en tant que blog d'explication en japonais, "Mathematical background of TensorFlow Tutorial-Deep MNIST for Experts (1)" J'ai compris en le regardant. Merveilleux.

En traitement

La figure ci-dessous montre l'ensemble du processus utilisant Tensor. Cette fois, vous pouvez voir que le processus de pliage et de regroupement à deux couches (multicouche) est effectué. Vous pouvez voir à partir de la quantité de Tensor que vous pouvez «trouver des fonctionnalités» en pliant et en utilisant des filtres, et des «fonctionnalités grossières» en regroupant.

Cela ressemble à ceci lorsque la transition réelle jusqu'à la deuxième couche est représentée par une image.

L'explication du processus de convolution a été écrite en détail dans l'article "[Explication pour les débutants] Introduction au processus de convolution (expliqué dans TensorFlow)". L'explication du processus de pooling a été écrite en détail dans l'article "[Explication pour les débutants] Introduction au processus de pooling (expliqué dans TensorFlow)". L'explication de la sortie d'image a été écrite en détail dans l'article [Introduction à TensorBoard: image] Traitement d'image TensorFlow Visualize pour approfondir la compréhension.

Le graphique de TensorBoard est illustré dans la figure ci-dessous. Le traitement commence à partir de l'entrée ci-dessous. La couche étroitement couplée exacte est divisée en fc1_layer et fc2_layer.

code

Enfin, placez la sortie de code dans TensorBoard. Lorsqu'il était exécuté sur un PC à 2 cœurs, le processeur était presque immédiatement épuisé, comme indiqué dans la figure ci-dessous, et aucun autre traitement ne pouvait être effectué sur le PC pendant l'exécution. Veuillez noter que cela prendra un certain temps pour terminer le processus. Je ne suis pas sûr de l'exactitude. Je vous serais reconnaissant de bien vouloir signaler toute erreur.

import tensorflow as tf
sess = tf.InteractiveSession()
#Lire les données MNIST
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#Répertoire de sortie des informations TensorBoard
log_dir = '/tmp/tensorflow/mnist/logs/mnist_expert_images'

#Supprimez le répertoire spécifié s'il existe et recréez-le
if tf.gfile.Exists(log_dir):
    tf.gfile.DeleteRecursively(log_dir)
tf.gfile.MakeDirs(log_dir)

# Input placeholders &Conversion d'image
with tf.name_scope('input'):
    x  = tf.placeholder(tf.float32, shape=[None, 784], name='x-input')
    y_ = tf.placeholder(tf.float32, shape=[None, 10],  name='y-input')

    #Convertir l'image en 28x28
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    tf.summary.image('preprocess', x_image, 10)

#Fonction qui traite les variables et produit TensorBoard
def variable_summaries(var):

    #Résumé des variables
    with tf.name_scope('summaries'):
        mean = tf.reduce_mean(var)                      #Sortie scalaire(moyenne)
        tf.summary.scalar('mean', mean)
        with tf.name_scope('stddev'):
            stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean)))
        tf.summary.scalar('stddev', stddev)             #Sortie scalaire(écart-type)
        tf.summary.scalar('max', tf.reduce_max(var))    #Sortie scalaire(Valeur maximum)
        tf.summary.scalar('min', tf.reduce_min(var))    #Sortie scalaire(valeur minimum)
        tf.summary.histogram('histogram', var)          #Sortie d'histogramme

#Valeur pondérée
def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)    #Écart type 0.Distribution normale, nombre aléatoire de 1
    return tf.Variable(initial)

#Valeur de biais
def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)             #Valeur initiale 0.1 constante
    return tf.Variable(initial)

#Processus de pliage
def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

# Max Pooling
def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')

#1ère couche
with tf.name_scope('1st_layer'):

    #1ère couche de convolution
    with tf.name_scope('conv1_layer'):
        with tf.name_scope('weight'):
            W_conv1 = weight_variable([5, 5, 1, 32])
            variable_summaries(W_conv1)
            
            #Tenseur[5,5,1,32]De[32,5,5,1]Et sortie d'image
            tf.summary.image('filter', tf.transpose(W_conv1,perm=[3,0,1,2]), 10)

        with tf.name_scope('bias'):            
            b_conv1 = bias_variable([32])
            variable_summaries(b_conv1)
        with tf.name_scope('activations'):            
            h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
            tf.summary.histogram('activations', h_conv1)

            #Tenseur[-1,28,28,32]De[-1,32,28,28]Et la conversion de commande,[-1]Quand[-32]Fusionner et afficher l'image
            tf.summary.image('convolved', tf.reshape(tf.transpose(h_conv1,perm=[0,3,1,2]),[-1,28,28,1]), 10)

#1ère couche de mise en commun
    with tf.name_scope('pool1_layer'):    
        h_pool1 = max_pool_2x2(h_conv1)

        #Tenseur[-1,14,14,32]De[-1,32,14,14]Et la conversion de commande,[-1]Quand[32]Fusionner et afficher l'image
        tf.summary.image('pooled', tf.reshape(tf.transpose(h_pool1,perm=[0,3,1,2]),[-1,14,14,1]), 10)

#2ème couche
with tf.name_scope('2nd_layer'):
    
    #2ème couche de convolution
    with tf.name_scope('conv2_layer'):
        with tf.name_scope('weight'):
            W_conv2 = weight_variable([5, 5, 32, 64])
            variable_summaries(W_conv2)

            #Tenseur[5,5,32,64]De[32*64,5,5,1]Et sortie d'image
            tf.summary.image('filter', tf.reshape(tf.transpose(W_conv2,perm=[2,3,0,1]),[-1,5,5,1]), 20)
        with tf.name_scope('bias'):            
            b_conv2 = bias_variable([64])
            variable_summaries(b_conv2)
        with tf.name_scope('activations'):
            h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
            tf.summary.histogram('activations', h_conv2)
            #Tenseur[-1,14,14,64]De[-1,64,14,14]Et la conversion de commande,[-1]Quand[64]Fusionner et afficher l'image
            tf.summary.image('convolved', tf.reshape(tf.transpose(h_conv2,perm=[0,3,1,2]),[-1,14,14,1]), 10)
    
#2ème couche de pooling
    with tf.name_scope('pool2_layer'):
        h_pool2 = max_pool_2x2(h_conv2)
        
        #Tenseur[-1,7,7,64]De[-1,64,7,7]Et la conversion de commande,[-1]Quand[64]Fusionner et afficher l'image
        tf.summary.image('pooled', tf.reshape(tf.transpose(h_pool2,perm=[0,3,1,2]),[-1,7,7,1]), 10)

#Couche étroitement couplée
with tf.name_scope('fc1_layer'):
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
    with tf.name_scope('weight'):
        W_fc1 = weight_variable([7 * 7 * 64, 1024])
        variable_summaries(W_fc1)
    with tf.name_scope('bias'):            
        b_fc1 = bias_variable([1024])
        variable_summaries(b_fc1)
    with tf.name_scope('activations'):
        h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
        tf.summary.histogram('activations', h_fc1)

    #Abandonner
    with tf.name_scope('dropout'):
        keep_prob  = tf.placeholder(tf.float32)
        tf.summary.scalar('dropout_keep_probability', keep_prob)
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

#Lire la couche
with tf.name_scope('fc2_layer'):
    with tf.name_scope('weight'):
        W_fc2 = weight_variable([1024, 10])
        variable_summaries(W_fc2)
    with tf.name_scope('bias'):            
        b_fc2 = bias_variable([10])
        variable_summaries(b_fc2)
    with tf.name_scope('preactivations'):
        y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
        tf.summary.histogram('preactivations', y_conv)

#Entropie croisée(Entropie croisée)Calcul
with tf.name_scope('cross_entropy'):
    cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
    tf.summary.scalar("cross_entropy", cross_entropy)

#Entraînement
with tf.name_scope('train'):
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)

#Calcul du taux de réponse correct
with tf.name_scope('accuracy'):
    correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    tf.summary.scalar('accuracy', accuracy)

#Afficher tout le résumé
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(log_dir + '/train', sess.graph) #Données d'entraînement
test_writer  = tf.summary.FileWriter(log_dir + '/test')              #données de test

#Initialisation
tf.global_variables_initializer().run()

#Répéter l'entraînement / le test
for i in range(3000):
    batch = mnist.train.next_batch(50)
    
    #Détails de la trace d'entraînement toutes les 100 fois
    if i % 100 == 0:
        run_options  = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
        run_metadata = tf.RunMetadata()
        summary, train_accuracy, _   = sess.run([merged, accuracy , train_step],
                                                feed_dict={x: batch[0], y_:batch[1], keep_prob: 1.0},
                                                options=run_options,
                                                run_metadata=run_metadata)
        train_writer.add_run_metadata(run_metadata, 'step%03d' % i)
        train_writer.add_summary(summary, i)
        print('step %d, training accuracy %g' % (i, train_accuracy))
    #Tester toutes les 100 fois
    elif i % 100 == 99:
        summary_test, train_accuracy = sess.run([merged, accuracy], feed_dict={x: mnist.test.images, y_:mnist.test.labels, keep_prob: 1.0})
        test_writer.add_summary(summary_test, i)
        
    #Rédaction des résultats de formation
    summary, _ = sess.run([merged, train_step], feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
    train_writer.add_summary(summary, i)

#Sortie du résultat final du test
print('test accuracy %g' % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

#Rédacteur fermé
train_writer.close()
test_writer.close()