Ich werde ein Memorandum über TensorFlow veröffentlichen, eine Bibliothek für tiefes Lernen, die Google bereitgestellt hat. TensorFlow hat eine detaillierte Erklärung des Tutorials, daher habe ich versucht, es ins Japanische zu übersetzen. ・ Über TensorFlow-> http://www.tensorflow.org/ ・ Originalübersetzung dieser Zeit-> http://www.tensorflow.org/tutorials/mnist/pros/index.md Da ich eine echte japanische Person bin, kann es zu seltsamen Übersetzungen oder Fehlübersetzungen kommen. Bitte tun Sie dies auf eigenes Risiko. [Referenz [Das TensorFlow-Tutorial grob ins Japanische übersetzen] 1. MNIST Für ML-Anfänger]
Dieses Tutorial wird leichter zu verstehen sein, wenn Sie Kapitel 6 von Mr. Okayas Buch "Deep Learning" lesen. In diesem Artikel werden auch Fachbegriffe wie Schritt und Polsterung erwähnt, daher sind Referenzmaterialien unerlässlich.
Dann ist das diesmal erstellte Modell ein Modell, das als Convolutional Neural Network (CNN) bezeichnet wird.
Führen Sie das Skript aus, um das MNIST-Dataset abzurufen.
import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
TensorFlow nutzt ein hocheffizientes C ++ - Backend, um eigene Berechnungen durchzuführen. Diese Verbindung zum Backend wird als Sitzung bezeichnet. TensorFlow wird häufig verwendet, um zuerst ein Diagramm zu erstellen und dann eine Sitzung auszuführen.
Hier verwenden wir jedoch die nützliche InteractiveSession-Klasse, die TensorFlow mehr Flexibilität beim Schreiben von Code bietet. Dies ist nützlich, wenn Sie wie iPython interaktiv arbeiten. Wenn Sie InteractiveSession nicht verwendet haben, muss der Benutzer vor dem Starten der Sitzung das gesamte Berechnungsdiagramm erstellen und dann das Diagramm ausführen.
import tensorflow as tf
sess = tf.Interactive Session()
Computation Graph Mit TensorFlow können Sie ein "Diagramm" schreiben, um alle interagierenden Anweisungen außerhalb von Python auszuführen, anstatt eine einzelne schwere Anweisung unabhängig außerhalb von Python auszuführen. Ähnliche Techniken werden in Theano und Torch verwendet.
Die Rolle des Python-Codes besteht also darin, dieses externe Berechnungsdiagramm zu erstellen und Anweisungen zu geben, welcher Teil dieses Diagramms ausgeführt werden soll.
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
sess.run(tf.initialize_all_variables())
y = tf.nn.softmax(tf.matmul(x,W) + b)
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
for i in range(1000):
batch = mnist.train.next_batch(50)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
print accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels})
Die korrekte MNIST-Antwortrate von 91% ist peinlich schlecht. Wir werden ein kleines Faltungsnetzwerk aufbauen und eine korrekte Antwortrate von 99,2% anstreben.
Um ein CNN zu erstellen, müssen Sie viele Gewichte und Vorurteile festlegen. Im Allgemeinen sollten Gewichte mit einem geringen Rauschen initialisiert werden, um die Symmetrie zu brechen und Nullgradienten zu vermeiden. Da wir diesmal ReLU-Neuronen verwenden, ist es auch eine gute Idee, jedes Element mit einer anfänglichen Verzerrung mit einem leicht positiven Wert zu initialisieren (um "tote Neuronen" zu vermeiden). Anstatt dies jedes Mal zu wiederholen, wenn Sie ein Modell erstellen, erstellen wir zwei praktische Funktionen, die dies für Sie erledigen.
def weight_vairable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.variable(0.1, shape=shape):
return tf.Variable(initial)
TensorFlow bietet Ihnen ein hohes Maß an Flexibilität beim Falten und Poolen. Wie gehe ich mit Grenzen um? Wie lang sollte die Folie sein? Verwenden wir in diesem Beispiel die banalste. Dieser CNN macht einen Schritt von 1 und verwendet eine Null-Auffüllung, sodass die Ausgabe dieselbe Größe wie die Eingabe hat. Pooling ist ein einfaches altes Max-Pooling, das sich über 2 * 2 Blöcke erstreckt. Um Ihren Code sauber zu halten, fügen wir diese Operationen in einer Funktion zusammen.
def conv2d(x,W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1], padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1], strides=[1,2,2,1],padding='SAME')
Wir können bereits die erste Stufe ausführen. Zuerst erfolgt eine Faltung, gefolgt von maximalem Pooling. Convolution berechnet 32 Features für jeden 5x5-Patch (* Bedeutet das, dass 32 Zahlen für einen 5x5-Patch zurückgegeben werden?). Die Form des Gewichtstensors ist [5,5,1,32]. Die ersten beiden Dimensionen sind die Patchgröße, dann die Anzahl der Eingangskanäle und schließlich die Anzahl der Ausgangskanäle. Bereiten Sie auch einen Bias-Vektor vor. Jedes Element dieses Vektors wird jedem Ausgangskanal gegeben.
w_conv1 = weight_variable([5,5,1,32])
b_conv1 = bias_variable([32])
Um diese Schicht anzupassen, formen Sie zuerst den x-Vektor in einen 4-dimensionalen Tensor. Die zweite und dritte Dimension entsprechen der Breite und Höhe des Bildes, und die vierte Dimension entspricht dem Farbkanal.
x_image = tf.reshape(x,[-1,28,28,1])
Lassen Sie uns nun x_image mit einem Gewichtstensor falten, Bias hinzufügen, es der ReLU-Funktion zuweisen und den maximalen Pool erhalten.
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1)+b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
Die zweite Ebene benötigt 64 Funktionen für einen 5x5-Patch.
W_conv2 = weight_variable([5,5,32,64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2)+b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
Die Bildgröße ist jetzt auf 7x7 gesunken. Fügen Sie eine vollständig verbundene Ebene mit 1024 Neuronenelementen hinzu und lassen Sie das gesamte Bild verarbeiten. Tensol aus der Poolschicht Konvertieren Sie die Menge in einen Stapel von Vektoren, multiplizieren Sie sie mit der Gewichtsmatrix, addieren Sie Bias und weisen Sie sie ReLU zu.
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+t_fc1)
Wenden Sie vor der Leseebene ein Dropout an, um Probleme beim Überlernen zu vermeiden. Verwenden Sie eine Wahrscheinlichkeitsverteilung, um die Ausgabe des Neurons während des Ausfalls zu speichern und einen Platzhalter für diese Wahrscheinlichkeitsverteilung bereitzustellen. (Ich verstehe die Bedeutung nicht gut) Auf diese Weise können Sie den Ausfall während des Trainings ein- und während des Tests ausschalten. Zusätzlich zur Maskierung der Neuronenausgabe skaliert der Befehl tf.nn.dropout von TensorFlow automatisch (..?). Dadurch kann der Dropout nur ohne zusätzliche Skalierung arbeiten. (.. ??)
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
Fügen Sie zum Schluss die Softmax-Ebene hinzu.
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2)+b_fc2)
Die Unterschiede zum oben erwähnten einschichtigen Softmax-Netzwerk sind wie folgt.
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
correct_prediction = tf.equal(tf.argmax(y_conv,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
sess.run(tf.initialize_all_variables())
for i in range(20000):
batch = mnist.train.next_batch(50)
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})
Recommended Posts