In oben erwähnte ich, dass das Dokument des Deep Learning Framework "TensorFlow" schwierig ist. In diesem Artikel möchte ich versuchen, MNIST (Handwritten Number Classification Problem) mithilfe des zweischichtigen Netzwerks von TensorFlow zu lösen.
Wenn man sich das TensorFlow-Tutorial ansieht, scheint es einen ziemlich technischen Levelsprung zu geben, zuerst mit "MNIST für Anfänger" und dann mit "Deep MNIST für Experten".
Wäre es nicht besser, es Schritt für Schritt zu verstehen, indem Sie ein MLP-Modell (Multi-Layer Network) anstelle von plötzlich CNN (Convolutional Neural Net) einfügen? In diesem Artikel habe ich einen Tutorial-Code erstellt, der eine solche Lücke füllt. Die Funktionen sind wie folgt.
(Was Sie tun, befindet sich möglicherweise in der Nähe des Beispielcodes "mnist.py" für das vollständig verbundene Modell im GitHub TensorFlow-Repository. Wir haben jedoch einen kurzen Code angestrebt, der für Sie leicht verständlich ist.)
Im Folgenden möchte ich mir den Code für jedes Teil ansehen.
import tensorflow as tf
# Import data
import input_data
mnist = input_data.read_data_sets("../MNIST_data/", one_hot=True)
Zunächst den Import des erforderlichen Moduls. Wenn dies zutrifft, wäre es möglicherweise besser gewesen, "input_data.py" zu lesen, aber da es ziemlich viele Funktionen enthält, diesmal ohne den Inhalt zu analysieren Ich entschied mich, dies als Black Box zu verwenden.
Als nächstes werden die zu verwendenden Variablen vorbereitet.
# Variables
x = tf.placeholder("float", [None, 784])
y_ = tf.placeholder("float", [None, 10])
w_h = tf.Variable(tf.random_normal([784, 625], mean=0.0, stddev=0.05))
w_o = tf.Variable(tf.random_normal([625, 10], mean=0.0, stddev=0.05))
b_h = tf.Variable(tf.zeros([625]))
b_o = tf.Variable(tf.zeros([10]))
"x" und "y_" sind Platzhalter zum Speichern von Trainingsdaten (Testdaten), und "w_h, w_o, b_h, b_o" sind Lernparameter (Gewicht und Vorspannung, verborgene Schicht und Ausgabeschicht). Die zufällige Initialisierung erfolgt mit "tf.random_normal ()", wodurch Zufallszahlen mit normaler Verteilung generiert werden. Die Parameter der Zufallszahl wurden gemäß dem groben Standard "kleiner Wert" auf Mittelwert = 0,0 und stddev = 0,05 eingestellt. (Für Bias mit Null initialisieren.)
# Create the model
def model(X, w_h, b_h, w_o, b_o):
h = tf.sigmoid(tf.matmul(X, w_h) + b_h)
pyx = tf.nn.softmax(tf.matmul(h, w_o) + b_o)
return pyx
y_hypo = model(x, w_h, b_h, w_o, b_o)
# Cost Function basic term
cross_entropy = -tf.reduce_sum(y_*tf.log(y_hypo))
Dies ist der wichtige Teil dieses Codes, der das Modell des neuronalen Netzwerks beschreibt.
Die verborgene Ebene berechnet einen linearen Prädiktor aus dem Wert der Eingabeebene und fügt ihn in die Sigmoid-Funktion ein.
\textbf{u} ^{(h)} = \textbf{w} ^{(h)} \textbf{z} ^{(i)} + \textbf{b}^{(h)}
\textbf{z} ^{(h)} = f^{(h)}(\textbf{u}^{(h)})
f^{(h)} \ : \ Sigmoid()\ ...\ \texttt{activation function}
Die Ausgabeebene berechnet einen linearen Prädiktor aus dem Wert der verborgenen Ebene und fügt ihn in die Softmax-Funktion ein.
\textbf{u} ^{(o)} = \textbf{w} ^{(o)} \textbf{z} ^{(h)} + \textbf{b}^{(o)}
\textbf{z} ^{(o)} = f^{(o)} (\textbf{u} ^{(o)})
f^{(o)} \ :\ Softmax()\ ...\ \texttt{activation function}
(Das Obige ist der Inhalt von def model ())
Berechnen Sie mit diesem Modell den Wert "y_hypo" Ihres eigenen Modells und ermitteln Sie den Kreuzentropiewert zusammen mit dem Trainingsdatenetikett "y_". (Dies ist der Hauptteil der Kostenfunktion.)
Als nächstes wird der Regularisierungsterm berechnet.
# Regularization terms (weight decay)
L2_sqr = tf.nn.l2_loss(w_h) + tf.nn.l2_loss(w_o)
lambda_2 = 0.01
Für den Regularisierungsterm verwendeten wir die Quadratnorm (L2_sqr) (Gewichtsdämpfung). TensorFlow unterstützt "tf.nn.l2_loss ()", um dies zu berechnen.
# the loss and accuracy
loss = cross_entropy + lambda_2 * L2_sqr
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.argmax(y_hypo,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
Hier werden die Definition des Optimierers und die zugehörigen numerischen Werte berechnet. Der Optimierer wertet eine Kostenfunktion mit einem regulären hinzugefügten Begriff aus. Wir haben die Methode Gradient Descent Optimize gewählt und die Lernrate auf 0,001 festgelegt. Zusätzlich wird die Formel zur Beurteilung des Klassifizierungsergebnisses und zur Berechnung seiner Genauigkeit beschrieben.
# Train
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
print('Training...')
for i in range(20001):
batch_xs, batch_ys = mnist.train.next_batch(100)
train_step.run({x: batch_xs, y_: batch_ys})
if i % 2000 == 0:
train_accuracy = accuracy.eval({x: batch_xs, y_: batch_ys})
print(' step, accurary = %6d: %6.3f' % (i, train_accuracy))
Starten Sie nach dem Initialisieren der Variablen eine Sitzung und lernen Sie die Parameter anhand der Trainingsdaten. Dieses Mal wird die Berechnung der vorbestimmten Anzahl von Wiederholungen (20.000 Mal +) durchgeführt, ohne eine Konvergenzbeurteilung oder eine vorzeitige Beendigung durchzuführen.
Nach Abschluss des Trainings wird die Genauigkeit des Klassifikators anhand der Testdaten berechnet.
# （with tf.Session() as sess:Wird drinnen sein)
# Test trained model
print('accuracy = ', accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}))
Der oben erläuterte Code wird zusammengefasst und erneut veröffentlicht. (Ungefähr 60 Codezeilen.)
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
# Import data
import input_data
mnist = input_data.read_data_sets("../MNIST_data/", one_hot=True)
# Variables
x = tf.placeholder("float", [None, 784])
y_ = tf.placeholder("float", [None, 10])
w_h = tf.Variable(tf.random_normal([784, 625], mean=0.0, stddev=0.05))
w_o = tf.Variable(tf.random_normal([625, 10], mean=0.0, stddev=0.05))
b_h = tf.Variable(tf.zeros([625]))
b_o = tf.Variable(tf.zeros([10]))
# Create the model
def model(X, w_h, b_h, w_o, b_o):
h = tf.sigmoid(tf.matmul(X, w_h) + b_h)
pyx = tf.nn.softmax(tf.matmul(h, w_o) + b_o)
return pyx
y_hypo = model(x, w_h, b_h, w_o, b_o)
# Cost Function basic term
cross_entropy = -tf.reduce_sum(y_*tf.log(y_hypo))
# Regularization terms (weight decay)
L2_sqr = tf.nn.l2_loss(w_h) + tf.nn.l2_loss(w_o)
lambda_2 = 0.01
# the loss and accuracy
loss = cross_entropy + lambda_2 * L2_sqr
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
correct_prediction = tf.equal(tf.argmax(y_hypo,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
# Train
init = tf.initialize_all_variables()
with tf.Session() as sess:
sess.run(init)
print('Training...')
for i in range(20001):
batch_xs, batch_ys = mnist.train.next_batch(100)
train_step.run({x: batch_xs, y_: batch_ys})
if i % 2000 == 0:
train_accuracy = accuracy.eval({x: batch_xs, y_: batch_ys})
print(' step, accurary = %6d: %6.3f' % (i, train_accuracy))
# Test trained model
print('accuracy = ', accuracy.eval({x: mnist.test.images, y_: mnist.test.labels}))
(Hinweis: Die ersten drei Zeilen from __future__ ... sind Anweisungen zur Kompatibilität mit Python-3.)
Die Situation, in der dieser Code ausgeführt wird, ist wie folgt.
Training...
step, accurary = 0: 0.130
step, accurary = 2000: 0.900
step, accurary = 4000: 0.910
step, accurary = 6000: 0.930
step, accurary = 8000: 0.920
step, accurary = 10000: 0.960
step, accurary = 12000: 0.950
step, accurary = 14000: 0.950
step, accurary = 16000: 0.960
step, accurary = 18000: 0.960
step, accurary = 20000: 0.960
accuracy = 0.9546
Die Genauigkeit der Klassifizierung der Testdaten betrug 95,46%. Wie erwartet lag der Wert fast zwischen dem von der Softmax-Funktion berechneten Wert (91%) und der Genauigkeit des Faltungs-Neuronalen Netzes (99,2%). (Es gibt das Gefühl, ein wenig zu zielen.)
(Ich lerne noch, aber ich hoffe, ich kann den TensoFlow-Code teilen, während ich ihn nach und nach ausprobiere.)
--TensorFlow-Dokumentation http://www.tensorflow.org/
Recommended Posts