Übersetzte Tutorials für Anfänger und tatsächlich verwendetes TensorFlow in vorherigen und vorherigen Ich habe maschinelles Lernen gemacht. Diesmal habe ich das Tutorial für Expert übersetzt.
Deep MNIST for Experts TensorFlow ist eine leistungsstarke Bibliothek zur Durchführung umfangreicher numerischer Berechnungen. Eine der besten Aufgaben ist das Trainieren und Ausführen tiefer neuronaler Netze. In diesem Tutorial lernen wir die grundlegenden Komponenten des TensorFlow-Modells kennen, während wir einen MNIST-Klassifikator mit tiefer Faltung erstellen.
In dieser Einführung wird davon ausgegangen, dass Sie mit neuronalen Netzen und MNIST-Datensätzen vertraut sind. Wenn Sie diese Hintergründe nicht haben können, lesen Sie die Einführung für Anfänger (https://www.tensorflow.org/versions/master/tutorials/mnist/beginners/index.html). Stellen Sie sicher, dass Sie TensorFlow installieren, bevor Sie beginnen.
Setup Bevor wir unser Modell erstellen, laden wir zuerst das MNIST-Dataset und starten dann eine TensorFlow-Sitzung.
Load MNIST Data Zur Vereinfachung laden wir den MNIST-Datensatz [Skript] automatisch herunter und importieren ihn (https://tensorflow.googlesource.com/tensorflow/+/master/tensorflow/examples/tutorials/mnist/input_data). .py) ist enthalten. Dadurch wird ein Verzeichnis 'MNIST_data' zum Speichern von Datendateien erstellt.
import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
Dieser Mnist ist eine leichtgewichtige Klasse, die eine Reihe von Schulungen, Validierungen und Tests als Array von NumPy speichert. Es bietet auch eine Funktion, die einen kleinen Datenstapel durchläuft, den wir unten verwenden.
Start TensorFlow InteractiveSession TensorFlow verwendet für seine Berechnungen ein hocheffektives C ++ - Backend. Die Verbindung zu diesem Backend wird als Sitzung bezeichnet. Die übliche Verwendung des TensorFlow-Programms besteht darin, zuerst ein Diagramm zu erstellen und es dann in einer Sitzung zu starten.
Hier verwenden wir stattdessen die praktische InteractiveSession-Klasse, die TensorFlow flexibler beim Erstellen Ihres Codes macht. Auf diese Weise können Sie das Diagramm starten und den Prozess zum Erstellen des Berechnungsdiagramms einbinden (https://www.tensorflow.org/versions/master/get_started/basic_usage.html#the-computation-graph). Zu. Dies ist besonders nützlich, wenn Sie in einem bidirektionalen Kontext wie iPython arbeiten. Wenn Sie InteractiveSession nicht verwenden, starten Sie die Sitzung und das Startdiagramm (https://www.tensorflow.org/versions/master/get_started/basic_usage.html#launching-the-graph-in) -a-session) Sie sollten vorher den gesamten Rechengraphen erstellen.
import tensorflow as tf
sess = tf.InteractiveSession()
Für effiziente numerische Berechnungen in Python verwenden wir im Allgemeinen sehr effektiven Code, der in anderen Sprachen wie NumPy implementiert ist und eine hohe Verarbeitung wie Matrixmultiplikation außerhalb von Python ausführt. Bibliothek wird verwendet. Leider wird es immer noch viel Aufwand geben, auf die gesamte Python-Verarbeitung umzusteigen. Dieser Overhead ist besonders schlimm, wenn Sie auf einer GPU oder auf verteilte Weise berechnen möchten, deren Datenübertragung teuer wäre.
TensorFlow erledigt seine schwierige Aufgabe auch außerhalb von Python, unternimmt jedoch weitere Schritte, um diesen Overhead zu vermeiden. Anstatt einen teuren Prozess auszuführen, der von Python unabhängig ist, beschreibt TensorFlow ein Diagramm interagierender Prozesse, das vollständig außerhalb von Python ausgeführt wird. Dieser Ansatz ähnelt der Verwendung von Theano oder Torch.
Die Rolle des Python-Codes besteht daher darin, diesen externen Rechengraphen zu erstellen und festzulegen, welcher Teil des Rechengraphen ausgeführt werden soll. Weitere Informationen finden Sie unter Berechnungsdiagramm unter Grundlegende Verwendung. Siehe den Abschnitt /get_started/basic_usage.html#the-computation-graph).
In diesem Abschnitt erstellen wir ein Softmax-Regressionsmodell für eine einzelne lineare Ebene. Im nächsten Abschnitt erweitern wir dies im Fall der Softmax-Regression von mehrschichtigen Faltungsnetzwerken.
Placeholders Wir beginnen mit der Erstellung von Berechnungsgraphen, indem wir Knoten für Bildeingaben und Ausgabeklassen von Interesse erstellen.
x = tf.placeholder("float", shape=[None, 784])
y_ = tf.placeholder("float", shape=[None, 10])
Diese "x" und "y_" sind keine speziellen Werte. Sie sind vielmehr Platzhalter, die Werte, die wir eingeben, wenn wir TensorFlow auffordern, die Berechnungen auszuführen.
Das Eingabebild "x" besteht aus einem Gleitkomma-2D-Tensor. Hier weisen wir ihm die Form [Keine, 784] zu. 783 ist die Anzahl der Dimensionen des MNIST-Bildes parallel zu einer Zeile, was angibt, dass die erste Dimension, Keine, eine beliebige Größe haben kann, die der Stapelgröße entspricht. Die interessierende Ausgabeklasse "y_" besteht ebenfalls aus einem 2D-Tensor. Jede Spalte ist ein eindimensionaler 10-dimensionaler Vektor, der die Zahlen zeigt, die dem MNIST-Bild entsprechen.
Das Argument für die Platzhalterform ist optional, ermöglicht es Ihnen jedoch, Fehler, die aus Tensorformen resultieren, die nicht mit TensorFlow übereinstimmen, automatisch zu erkennen.
Variables Wir definieren nun die Gewichte "W" und "Bias" b "für unser Modell. Wir können uns vorstellen, wie zusätzliche Eingaben damit umzugehen, aber TensorFlow hat eine bessere Möglichkeit, mit ihnen umzugehen. Es ist variabel. Variable ist ein Wert, der im TensorFlow-Berechnungsdiagramm vorhanden ist. In Anwendungen für maschinelles Lernen sind die Parameter des Modells normalerweise variabel.
W = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))
Wir übergeben Anfangswerte für diese Parameter, indem wir "tf.Variable" aufrufen.
In diesem Fall initialisieren wir sowohl "W" als auch "b" als Tensol aller Nullen.
W ist eine 784x10-Matrix (weil wir 784 Eingabemerkmale und 10 Ausgänge haben) und b ist ein 10-dimensionaler Vektor (weil wir 10 Klassen haben).
Bevor Variablen in einer Sitzung verwendet werden, müssen sie mithilfe der Sitzung initialisiert werden. In diesem Schritt nehmen wir die bereits geklärten Anfangswerte (für alle Nulltensoren) und weisen ihnen ihre jeweiligen Variablen zu. Dies kann für alle Variablen auf einmal durchgeführt werden.
sess.run(tf.initialize_all_variables())
Wir können jetzt unser Regressionsmodell implementieren. Es ist nur eine Zeile! Wir multiplizieren das vektorisierte Eingabebild "x" mit der Gewichtsmatrix "W", addieren die Vorspannung "b" und berechnen die jeder Klasse zugewiesenen Softmax-Wahrscheinlichkeiten.
y = tf.nn.softmax(tf.matmul(x,W) + b)
Die während des Trainings minimierte Kostenfunktion wird kurz beschrieben. Unsere Kostenfunktion ist die Kreuzentropie zwischen dem Objekt und der Modellvorhersage.
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
Beachten Sie, dass tf.reduce_sum alle Klassen sowie alle Bilder in einem Mini-Batch summiert.
Wir berechnen die Kreuzentropie für die gesamte Mini-Charge.
Nachdem wir unsere Modell- und Schulungskostenfunktion definiert haben, ist die Schulung mit TensorFlow einfach. Weil TensorFlow alle Berechnungsgraphen kennt und die automatische Identifizierung verwendet, um den Kostengradienten für jede Variable zu ermitteln. TensorFlow verfügt über verschiedene installierte Optimierungsalgorithmen. Zum Beispiel machen wir Schritte mit einer Länge von 0,01 und verwenden den steilsten Abstieg, um die Kreuzentropie abzusteigen.
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
Was TensorFlow in dieser einen Zeile tatsächlich tat, war, dem Rechengraphen eine neue Verarbeitung hinzuzufügen. Der Prozess, einschließlich derjenigen, die diese Gradienten berechnen, berechnet die Parameteraktualisierungsschritte und wendet die aktualisierten Schritte auf die Parameter an.
Der zurückgegebene Prozess train_step wendet einen Gradientenabstieg an, der die Parameter aktualisiert, wenn er ausgeführt wird.
Das Modelltraining wird daher durch mehrmaliges Ausführen von "train_step" kompetent sein.
for i in range(1000):
batch = mnist.train.next_batch(50)
train_step.run(feed_dict={x: batch[0], y_: batch[1]})
In jeder Trainingsiteration lesen wir 50 Trainingsmuster. Wir verwenden dann "feed_dict", um das "x" und "_y" des "Platzhalter" -Tensors durch das Trainingsmuster zu ersetzen und den "train_step" -Prozess durchzuführen. Beachten Sie, dass Sie "feed_dict" verwenden können, um einen beliebigen Tensor in Atanas Berechnungsdiagramm auszutauschen. Nicht nur auf "Platzhalter" beschränkt.
Wie können wir unser Modell verbessern?
Zuerst berechnen wir, wo wir das richtige Etikett vorhergesagt haben.
tf.argmax ist eine sehr nützliche Funktion, die den höchsten Eingangsindex in einem Tensor entlang einer Achse liefert.
Zum Beispiel ist "tf.argmax (_y, 1)" die wahre Bezeichnung, während "tf.argmax (y, 1)" die ähnlichste Bezeichnung für jede Eingabe ist, die unser Modell berücksichtigt.
Wir können "tf.equal" verwenden, um zu sehen, ob unsere Vorhersagen mit der Wahrheit übereinstimmen.
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
Dies gibt eine Liste von Booleschen Werten. Um festzustellen, ob das Teil korrekt ist, setzen wir es auf Gleitkomma und nehmen dann den Durchschnitt. Zum Beispiel wird "[Richtig, Falsch, Richtig, Richtig]" zu "[1,0,1,1]" und zu "0,75".
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
Schließlich bewerten wir unsere Genauigkeit mit Testdaten. Dies sollte zu 91% korrekt sein.
print(accuracy.eval(feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
Es ist nicht gut, mit MNIST eine Genauigkeit von 91% zu erreichen. Es ist fast verwirrend schlecht. In diesem Abschnitt beheben wir das Problem und springen von einem sehr einfachen Modell zu einem einigermaßen hoch entwickelten, einem kleinen neuronalen Faltungsnetzwerk. Dies ergibt eine Genauigkeit von etwa 99,2%. Nicht auf dem neuesten Stand, aber unkompliziert.
Um dieses Modell zu erstellen, müssen wir viele Gewichte und Verzerrungen erstellen. Man initialisiert die Gewichte im Allgemeinen mit einem geringen Rauschen aufgrund von Symmetriebrechungen und verhindert, dass der Gradient Null wird. Da wir ReLU-Neuronen (Normalized Linear Function) verwendet haben, ist es eine gute Praxis, sie mit einer anfänglichen Verzerrung zu initialisieren, die leicht positiv ist, um tote Neuronen zu verhindern. Anstatt dies zu wiederholen, während wir das Modell erstellen, erstellen wir zwei benutzerfreundliche Funktionen, die dies für uns tun.
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
Convolution and pooling TensorFlow bietet uns auch viel Flexibilität bei der Faltung und Teilabtastung. Wie gehe ich gut mit Grenzen um? Wie groß ist unser Schritt? In diesem Beispiel wählen wir immer die mittelmäßige Version. Unsere Faltung verwendet einen Schritt und wird auf 0 aufgefüllt, sodass die Ausgabe dieselbe Größe wie die Eingabe hat. Unsere Teilabtastung ist ein alter maximaler Teilabtastungsplan (Schichtplan), der 2x2 Blöcke überschreitet. Um unseren Code sauber zu halten, lassen Sie uns diese abstrakten Prozesse funktionieren.
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 jetzt unsere erste Schicht implementieren. Es besteht aus Faltung und tritt nach Max-Pooling auf. Convolution berechnet 32 Features für einen 5x5-Patch. Sein Gewichtstensor hat die Form "[5, 5, 1, 32]". Die ersten beiden Dimensionen sind die Patchgröße, dann die Anzahl der Eingangskanäle und schließlich die Ausgangskanäle. Wir haben auch einen Bias-Vektor mit Elementen für jeden Ausgangskanal.
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
Um auf Ebenen anzuwenden, übersetzen wir zuerst "x" in einen 4D-Tensor mit einer zweiten und dritten Dimension, die der Breite und Höhe des Bildes entspricht, und einer endgültigen Dimension, die der Anzahl der Farbkanäle entspricht. Remake.
x_image = tf.reshape(x, [-1,28,28,1])
Wir machen dann eine Faltung des "x_image" und des Gewichtstensors, spannen es vor, wenden die ReLU-Funktion an und berechnen schließlich den maximalen Pool.
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
Anstatt ein tiefes Netzwerk aufzubauen, stapeln wir mehrere Schichten dieses Typs. Die zweite Ebene verfügt über 64 Funktionen für jeden 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)
Nachdem die Bildgröße auf 7x7 reduziert wurde, fügen wir eine vollständig verbundene Ebene mit 1024 Neuronen hinzu, die die Verarbeitung aller Bilder ermöglichen. Wir transformieren den Tensor von einer Teilabtastschicht in einen Stapel von Vektoren, multiplizieren ihn mit einer Gewichtsmatrix, fügen eine Vorspannung hinzu und wenden ReLU an.
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_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
Dropout Um eine Überanwendung zu reduzieren, wenden wir vor der Ausleseschicht ein Dropout an. Wir machen einen Platzhalter für die Wahrscheinlichkeit, dass die Ausgabe des Neurons während des Ausfalls erhalten bleibt. Dies ermöglicht es uns, während des Trainings abzubrechen und während des Testens das Laufen zu beenden. Die Operation "tf.nn.dropout" von TensorFlow skaliert die neuronale Ausgabe automatisch und maskiert sie zusätzlich. Der Dropout wird ohne zusätzliche Skalierung ausgeführt.
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
Schließlich fügen wir oben eine Softmax-Ebene sowie eine Ebene der Softmax-Regression 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)
Wie gut ist dieses Modell?
Für Training und Evaluierung verwenden wir fast den gleichen Code wie eine Schicht des oben beschriebenen einfachen Softmax-Netzwerks.
Die Unterschiede sind wie folgt.
Wir verwandeln das Programm zur Optimierung des steilsten Abstiegs in ein komplexeres ADAM-Optimierungsprogramm.
Wir fügen einen zusätzlichen Parameter keep_prob in deed_dict ein, um die Abbrecherquote zu steuern.
Und wir fügen alle 100 Iterationen im Trainingsprozess eine Protokollierung hinzu.
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}))
Die Genauigkeit des endgültigen Testsatzes nach dem Ausführen dieses Codes sollte etwa 99,2% betragen.
Wir haben gelernt, wie man mit TensorFlow schnell und einfach ein ziemlich ausgeklügeltes Modell des tiefen Lernens erstellt, trainiert und bewertet.
Das ist alles für die Übersetzung. Es ist komplizierter als das Tutorial für Anfänger, aber es ist insofern ähnlich, als jede Ebene gewichtet, voreingenommen und die Funktion angewendet wird. Als nächstes möchte ich den Code tatsächlich ausführen und dabei diesen Inhalt besser verstehen.
Recommended Posts