[PYTHON] [Erklärung für Anfänger] TensorFlow-Tutorial Deep MNIST

Erklären von Tutorials für TensorFlow-Experten aus Anfängersicht

Ich habe das TensorFlow Expert Tutorial Deep MNIST für Experten ausgeführt. Ich werde aus der Perspektive der Anfänger erklären. Es gibt viele Teile, denen es an Genauigkeit mangelt, aber ich lege Wert auf Klarheit. Es war sehr schwierig im Vergleich zum Tutorial für Anfänger: Schädel: ^{* Es wurde ein Code hinzugefügt, damit das Bild ausgegeben werden kann, und ein Bild der Faltungs- / Pooling-Verarbeitung (27.07.2017) </ sup> veröffentlicht}

Referenzlink

• TensorFlow unter Windows Easy für Python-Anfänger installieren
• [Erklärung für Anfänger] Grundlegende Syntax und Konzept von TensorFlow
• [Erklärung für Anfänger] TensorFlow-Tutorial MNIST (für Anfänger)
• TensorFlow API-Memo
• [Einführung in TensorBoard] Visualisieren Sie die TensorFlow-Verarbeitung, um das Verständnis zu vertiefen
• [Einführung in TensorBoard: image] TensorFlow Visualisieren Sie die Bildverarbeitung, um das Verständnis zu vertiefen
• [Einführung in TensorBoard: Projector] Lassen Sie die TensorFlow-Verarbeitung cool aussehen
• TensorFlow Tutorial MNIST (für Anfänger) mit TensorBoard visualisiert
• Yuki Kashiwagis Gesichtszüge zum Verständnis von TensorFlow [Teil 1]

Überblick über die Verarbeitung

Neulich war der Inhalt beeindruckend, aber das Foto war beeindruckend ["Ich habe seit fast 80 Jahren nichts mehr gegessen und die indischen Asketen erstaunt."] Ich werde es sinnlich erklären, ohne mathematische Formeln zu verwenden, indem ich das Bild in verwende (ich habe es verwendet, weil das Bild sehr leicht zu verstehen war). Das TensorFlow Expert Tutorial Deep MNIST für Experten besteht hauptsächlich aus ** Faltung **, ** Pooling **, ** eng gekoppelt ** Es besteht aus drei Prozessen. Die Beurteilung des Bildes nach jedem Vorgang ist in der folgenden Abbildung dargestellt.

Eine etwas detailliertere Verarbeitungsübersicht

Die folgenden zwei Youtube-Videos waren sehr einfach zu verstehen, daher werde ich einen Link (auf Englisch) veröffentlichen.

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

Als Erklärungsblog auf Japanisch "Mathematischer Hintergrund von TensorFlow Tutorial-Deep MNIST für Experten (Teil 1)" Ich verstand es, als ich es betrachtete. Wunderbar.

wird bearbeitet

Die folgende Abbildung zeigt den gesamten Prozess mit Tensor. Dieses Mal können Sie sehen, dass der zweischichtige (mehrschichtige) Falt- und Pooling-Prozess ausgeführt wird. An der Menge an Tensor können Sie erkennen, dass Sie durch Falten und Verwenden von Filtern "Features" und durch Pooling "grobe Features" finden können.

Es sieht so aus, wenn der tatsächliche Übergang zur zweiten Ebene durch ein Bild dargestellt wird.

Die Erläuterung des Faltvorgangs wird ausführlich im Artikel "[Erklärung für Anfänger] Einführung in den Faltvorgang (in TensorFlow erläutert)" beschrieben. Die Erläuterung des Pooling-Prozesses wird ausführlich im Artikel "[Erklärung für Anfänger] Einführung in den Pooling-Prozess (in TensorFlow erklärt)" beschrieben. Die Erklärung der Bildausgabe wurde ausführlich in dem Artikel "[Einführung in TensorBoard: image] TensorFlow Visualisieren der Bildverarbeitung zur Vertiefung des Verständnisses" geschrieben.

Das Diagramm von TensorBoard ist in der folgenden Abbildung dargestellt. Die Verarbeitung beginnt mit der Eingabe unten. Die exakt eng gekoppelte Schicht ist in fc1_layer und fc2_layer unterteilt.

Code

Stellen Sie abschließend die Code-Ausgabe an TensorBoard. Bei der Ausführung auf einem 2-Kern-PC war die CPU fast sofort aufgebraucht, wie in der folgenden Abbildung gezeigt, und während der Ausführung konnte keine andere Verarbeitung auf dem PC ausgeführt werden. Bitte beachten Sie, dass es einige Zeit dauern wird, bis der Vorgang abgeschlossen ist. Ich bin mir über die Genauigkeit etwas unsicher. Ich wäre Ihnen dankbar, wenn Sie auf Fehler hinweisen könnten.

import tensorflow as tf
sess = tf.InteractiveSession()
#MNIST-Daten lesen
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)

#Ausgabeverzeichnis für TensorBoard-Informationen
log_dir = '/tmp/tensorflow/mnist/logs/mnist_expert_images'

#Löschen Sie das angegebene Verzeichnis, falls vorhanden, und erstellen Sie es neu
if tf.gfile.Exists(log_dir):
    tf.gfile.DeleteRecursively(log_dir)
tf.gfile.MakeDirs(log_dir)

# Input placeholders &Bildkonvertierung
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')

    #Bild in 28x28 konvertieren
    x_image = tf.reshape(x, [-1, 28, 28, 1])
    tf.summary.image('preprocess', x_image, 10)

#Funktion, die Variablen verarbeitet und TensorBoard ausgibt
def variable_summaries(var):

    #Variablenübersicht
    with tf.name_scope('summaries'):
        mean = tf.reduce_mean(var)                      #Skalare Ausgabe(durchschnittlich)
        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)             #Skalare Ausgabe(Standardabweichung)
        tf.summary.scalar('max', tf.reduce_max(var))    #Skalare Ausgabe(Maximalwert)
        tf.summary.scalar('min', tf.reduce_min(var))    #Skalare Ausgabe(Mindestwert)
        tf.summary.histogram('histogram', var)          #Histogrammausgabe

#Gewichteter Wert
def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)    #Standardabweichung 0.Normalverteilungs-Zufallszahl von 1
    return tf.Variable(initial)

#Vorspannungswert
def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)             #Anfangswert 0.1 Konstante
    return tf.Variable(initial)

#Faltvorgang
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. Schicht
with tf.name_scope('1st_layer'):

    #1. Faltungsschicht
    with tf.name_scope('conv1_layer'):
        with tf.name_scope('weight'):
            W_conv1 = weight_variable([5, 5, 1, 32])
            variable_summaries(W_conv1)
            
            #Tensor[5,5,1,32]Von[32,5,5,1]Und Bildausgabe
            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)

            #Tensor[-1,28,28,32]Von[-1,32,28,28]Und Auftragsumwandlung,[-1]Wann[-32]Bild zusammenführen und ausgeben
            tf.summary.image('convolved', tf.reshape(tf.transpose(h_conv1,perm=[0,3,1,2]),[-1,28,28,1]), 10)

#1. Pooling-Schicht
    with tf.name_scope('pool1_layer'):    
        h_pool1 = max_pool_2x2(h_conv1)

        #Tensor[-1,14,14,32]Von[-1,32,14,14]Und Auftragsumwandlung,[-1]Wann[32]Bild zusammenführen und ausgeben
        tf.summary.image('pooled', tf.reshape(tf.transpose(h_pool1,perm=[0,3,1,2]),[-1,14,14,1]), 10)

#2. Schicht
with tf.name_scope('2nd_layer'):
    
    #2. Faltungsschicht
    with tf.name_scope('conv2_layer'):
        with tf.name_scope('weight'):
            W_conv2 = weight_variable([5, 5, 32, 64])
            variable_summaries(W_conv2)

            #Tensor[5,5,32,64]Von[32*64,5,5,1]Und Bildausgabe
            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)
            #Tensor[-1,14,14,64]Von[-1,64,14,14]Und Auftragsumwandlung,[-1]Wann[64]Bild zusammenführen und ausgeben
            tf.summary.image('convolved', tf.reshape(tf.transpose(h_conv2,perm=[0,3,1,2]),[-1,14,14,1]), 10)
    
#2. Pooling-Schicht
    with tf.name_scope('pool2_layer'):
        h_pool2 = max_pool_2x2(h_conv2)
        
        #Tensor[-1,7,7,64]Von[-1,64,7,7]Und Auftragsumwandlung,[-1]Wann[64]Bild zusammenführen und ausgeben
        tf.summary.image('pooled', tf.reshape(tf.transpose(h_pool2,perm=[0,3,1,2]),[-1,7,7,1]), 10)

#Eng gekoppelte Schicht
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)

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

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

#Gekreuzte Entropie(Kreuzentropie)Berechnung
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)

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

#Richtige Berechnung der Antwortrate
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)

#Alle Zusammenfassung ausgeben
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(log_dir + '/train', sess.graph) #Trainingsdaten
test_writer  = tf.summary.FileWriter(log_dir + '/test')              #Testdaten

#Initialisieren
tf.global_variables_initializer().run()

#Training / Test wiederholen
for i in range(3000):
    batch = mnist.train.next_batch(50)
    
    #Details zur Trainingsverfolgung alle 100 Male
    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))
    #Alle 100 Male testen
    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)
        
    #Schreiben von Trainingsergebnissen
    summary, _ = sess.run([merged, train_step], feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
    train_writer.add_summary(summary, i)

#Endgültige Ausgabe des Testergebnisses
print('test accuracy %g' % accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

#Schriftsteller geschlossen
train_writer.close()
test_writer.close()