[PYTHON] Code für TensorFlow MNIST Anfänger / Experte mit japanischen Kommentaren
TensorFlow Tutorial MNIST-Code mit japanischen Kommentaren, die von vielen Leuten geschrieben wurden, war während des Lernens sehr nützlich, daher habe ich meinen eigenen zusammengefasst. (Wenn Sie Fehler finden, würde ich mich freuen, wenn Sie sie auf mm hinweisen könnten)
# coding: utf-8
#Daten lesen
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
#Laden Sie den Tensorfluss als tf
import tensorflow as tf
# y = softmax(x*W + b)Definieren
##x[?, 784]Definiert als Tensor von(Keiner bedeutet, dass ich nicht weiß, wie viele)
x = tf.placeholder(tf.float32, [None, 784])
##W.[784, 10]Definiert als Tensor von. 784 jedes Pixel x jede Zahl von 0 bis 9.
W = tf.Variable(tf.zeros([784, 10]))
##b[10](InitialisierenSiemitallenNullen)Definiert als Tensor von. Vorspannung für jeden Wert von 0 bis 9
b = tf.Variable(tf.zeros([10]))
##Wenden Sie jede definierte Variable auf die Formel an
##matmul ist eine Funktion, die Matrizen integriert
y = tf.nn.softmax(tf.matmul(x, W) + b)
# y_(Etikette)Zu[?, 10]Definiert als Tensor von
y_ = tf.placeholder(tf.float32, [None, 10])
# cross_Entropie definieren
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y), reduction_indices=[1]))
# cross_Definieren Sie Schritte zur Optimierung der Entropie mithilfe des Gradientenabfalls
train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
#Variablen initialisieren
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
#Führen Sie das Lernen in einem Mini-Batch durch. Nehmen Sie zufällig 100 Teile aus den Trainingsdaten und wiederholen Sie den Vorgang, um 1000-mal zu optimieren
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})
#Berechnen Sie die richtige Antwortrate, indem Sie das Vorhersageergebnis mit dem Etikett vergleichen
##Holen Sie sich das Vorhersageergebnis als Matrix
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
##Berechnen Sie die Trefferquote
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
#Führen Sie das Lernen durch und geben Sie die Trefferquote aus
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
Erfassung
Hier ist für die grundlegenden Operationen von Tensorflow wie die Verarbeitung von redu_xxxxx leicht zu verstehen.
Dies ist leicht zu verstehen, wenn Sie sich zuerst das Netzwerkdiagramm ansehen, bevor Sie sich den Code ansehen.
Nach dem Definieren aller Netzwerke wird die Berechnung durch Rückausbreitung am Ende durchgeführt.
# coding: utf-8
#Laden des Tensorflusses
import tensorflow as tf
#Daten lesen
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MNIST_data',one_hot=True)
#Starten Sie eine interaktive Sitzung
sess = tf.InteractiveSession()
# x, y_Platzhalter definieren
x = tf.placeholder(tf.float32,shape=[None,784])
y_ = tf.placeholder(tf.float32,shape=[None,10])
#Funktion definieren
##Verarbeitungsfunktion für die Gewichtsinitialisierung
def weight_variable(shape):
#Initialisiert mit ausgeschnittener linker und rechter Seite der Normalverteilung
initial = tf.truncated_normal(shape,stddev=0.1)
return tf.Variable(initial)
##Verarbeitungsfunktion für die Vorspannungsinitialisierung
def bias_variable(shape):
initial = tf.constant(0.1,shape=shape)
return tf.Variable(initial)
##Zweidimensionale Tatami-Prospekt-Verarbeitungsfunktion(Schritt 1,Keine Polsterung)
def conv2d(x, W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
##Pooling-Funktion
def max_pool_2x2(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
#Erstes Mal
##W für die erste Faltung verwendet(Gewichteter Wert)
## ([width, height, input, filters]28 × 28 Bild 1(input)5 für jedes Blatt(width)×5(height)32 Typen(filters)Jeweils mit dem Falzfilter falten)
W_conv1 = weight_variable([5,5,1,32])
##Wird in der ersten Faltung verwendet. B.(vorspannen)
b_conv1 = bias_variable([32])
#Bild eingeben. Ich lege es zum Falten wieder in den Tensor.
# -Der Wert 1 wird zur Laufzeit dynamisch bestimmt, indem auf Umformen gesetzt wird.
x_image = tf.reshape(x, [-1,28,28,1])
#1. Faltung
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1) + b_conv1)
#1. Pooling
h_pool1 = max_pool_2x2(h_conv1)
#Zweites Mal
##W für die zweite Faltung verwendet(Gewichteter Wert)
## ([width, height, input, filters]Falten Sie für 32 14x14-Bilder jeweils 64 Arten von 5x5-Faltfiltern.)
W_conv2 = weight_variable([5,5,32,64])
##Wird für die zweite Faltung verwendet. B.(vorspannen)
b_conv2 = bias_variable([64])
##Zweite Faltung unter Verwendung der Tensorausgabe aus dem ersten Pooling
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
##Zweites Pooling
h_pool2 = max_pool_2x2(h_conv2)
#Vollständig verbundene Schicht(Fügen Sie alle Eingänge in die Softmax-Funktion ein)
##W wird in der vollständig verbundenen Schicht verwendet(Gewichteter Wert)
W_fc1 = weight_variable([7*7*64,1024])
##Wird in der vollständig verbundenen Schicht verwendet. B.(vorspannen)
b_fc1 = bias_variable([1024])
##H Ausgang in der zweiten Faltung_Konvertieren Sie pool2 in einen zweidimensionalen Tensor
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
##Geben Sie das Ergebnis in der vollständig verbundenen Ebene aus
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1) + b_fc1)
## DropOut(Verarbeitung zur Unterdrückung von Überlernen)
keep_prob = tf.placeholder(tf.float32)
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
##W wird für Drop-Out zur vollständig verbundenen Ebene verwendet(Gewichteter Wert)
W_fc2 = weight_variable([1024,10])
##Wird in Drop Out für vollständig verbundene Ebenen verwendet. B.(vorspannen)
b_fc2 = bias_variable([10])
#Endgültige Prognose ausgeben
y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2
#Ich möchte das Kreuz minimieren_Entropie definieren
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_conv,y_))
#Definieren Sie Minimierungsschritte mit Adam Optimizer
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
#Dieser Bereich ist der gleiche wie Beginer
correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
sess.run(tf.initialize_all_variables())
#Führen Sie das Lernen in einem Mini-Batch durch(Nehmen Sie zufällig 50 und wiederholen Sie die Optimierung 50 Mal)
for i in range(20000):
batch = mnist.train.next_batch(50)
#Ausgabefortschritt alle 100 Male
if i%100 == 0:
train_accuracy = accuracy.eval(feed_dict={x:batch[0],y_:batch[1],keep_prob:1.0})
print("step %d, training accuracy %g"%(i,train_accuracy))
train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})
print("test accuracy %g"%accuracy.eval(feed_dict={x: mnist.test.images, y_:mnist.test.labels, keep_prob: 1.0}))
Erfassung
Hier war sehr hilfreich für das Verständnis des Faltungsnetzwerks.
Recommended Posts