[Introduction à TensorBoard: image] TensorFlow Visualisez le traitement d'image pour approfondir la compréhension

Accélérez votre compréhension de TensorFlow avec TensorBoard

Je voulais vérifier le processus de pliage et de mise en commun de TensorFlow, donc je l'ai envoyé à TensorBoard. C'est un mémo de la méthode de confirmation d'image à ce moment-là. En guise de prémisse, veuillez vous référer à [[Introduction to TensorBoard] Visualiser le traitement TensorFlow pour approfondir la compréhension] pour une utilisation de base. Environnement: python3.5 tensorflow1.21

Lien de référence

Logique simple pour TensorBoard (Image)

Afficher les caractères numériques manuscrits (MNIST)

Écrivons un code qui ne regarde que les caractères numériques manuscrits (MNIST).

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/test/tensorboard_image01'

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

#Espace réservé pour mettre les données d'image
x  = tf.placeholder(tf.float32, shape=[None, 784])

#Convertir les images en 28x28 et produire 10 en Tensorboard
_ = tf.summary.image('image', tf.reshape(x, [-1, 28, 28, 1]), 10)
merged = tf.summary.merge_all()

#Obtenir une image minuscule
batch = mnist.train.next_batch(10)

#Courir
summary = sess.run(merged, feed_dict={x: batch[0]})

#Traitement de l'écrivain
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
summary_writer.add_summary(summary)
summary_writer.close()

Puis lancez Tensorboard. Puisque mon environnement est construit avec Anaconda, je démarre d'abord Terminal à partir d'Anaconda Navigator. 30.TensorFlow_Install01.JPG

Ensuite, démarrez Tensorbaord depuis Terminal en spécifiant le répertoire (le répertoire est stocké dans la variable de programme Python log_dir).

tensorboard --logdir=/tmp/tensorflow/mnist/logs/simple01

Après le lancement, ouvrez http: // localhost: 6006 / dans votre navigateur pour afficher l'écran TensorBoard.

TensorBoardBasic00.JPG

Je me fâche avec "Aucune donnée scalaire n'a été trouvée", mais cette fois, il n'y a pas de problème car le scalaire n'est pas sorti et seule la sortie graphique est utilisée. Vous pouvez voir les images en sélectionnant "Images" dans le menu à l'écran. 10.MNIST_Images01.JPG

Afficher l'image du fichier local

La description

Lit et génère un fichier local. Pour la méthode de lecture de fichier local, je me suis référé à l'article "Préparation à la lecture de l'ensemble de données d'origine".

import tensorflow as tf
sess = tf.InteractiveSession()

#Répertoire de sortie des informations TensorBoard
log_dir = '/tmp/tensorflow/test/tensorboard_image02'

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

#Emplacement du fichier("C:\\"Parce que la pièce s'est échappée"\"Notez qu'il y a deux)
jpg = tf.read_file('C:\\Users\yohei.fukuhara\Pictures\Saved Pictures\Sample Pictures\Koala.jpg')

#Décodage de fichier JPEG(tf.image.decode_png et tf polyvalent.image.decode_Il y a aussi une image)
img_raw = tf.image.decode_jpeg(jpg, channels=3)

#Obtenir la taille de l'image(Peut également être confirmé à partir des propriétés du fichier image)
img_shape = tf.shape(img_raw)

#Image de sortie vers Tensorboard
_ = tf.summary.image('local', tf.reshape(img_raw, [-1, img_shape[0], img_shape[1], img_shape[2]]), 1)
merged = tf.summary.merge_all()

#Courir
summary = sess.run(merged)

#Traitement de l'écrivain
summary_writer = tf.summary.FileWriter(log_dir, sess.graph)
summary_writer.add_summary(summary)
summary_writer.close()

Le résultat sortira.

20.Local_Images01.JPG

Tutoriel expert Deep MNIST pour experts

C'est finalement le sujet principal. Nous examinerons le processus de pliage et de mise en commun dans le tutoriel expert. Le code est ci-dessous.

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

résultat Il est regroupé par nom (entrée, 1er_couche, 2e_couche). Voir aussi l'article "[Explication for Beginners] TensorFlow Tutorial Deep MNIST".

30.DeepMNISTImanges01.JPG

Il est bon de pouvoir produire des images selon les étapes de la formation.

30.DeepMNISTImanges02.JPG

Recommended Posts

[Introduction à TensorBoard: image] TensorFlow Visualisez le traitement d'image pour approfondir la compréhension
opencv-python Introduction au traitement d'image
Introduction à Private TensorFlow
[Explication pour les débutants] Introduction au traitement du pliage (expliqué dans TensorFlow)
[Explication pour les débutants] Introduction au traitement du pool (expliqué dans TensorFlow)
Introduction à TensorFlow - Hello World Edition
Introduction à l'analyse d'image opencv python
J'ai essayé de visualiser AutoEncoder avec TensorFlow
Introduction au remplissage d'image Python Remplissage d'image à l'aide d'ImageDataGenerator
Probablement l'introduction la plus simple à TensorFlow
Les débutants lisent "Introduction à TensorFlow 2.0 pour les experts"
Essayez de visualiser vos tweets tout en comprenant BERT Hands-on
Comment utiliser la bibliothèque de traitement d'image basée sur PyTorch "Kornia"