Es ist einen Monat her, seit TensorFlow herauskam, und ich fühle mich bereits spät, aber ich habe es zuerst übersetzt, um das Anfänger-Tutorial "MNIST For ML Beginners" auszuprobieren. Seien Sie jedoch vorsichtig, wenn Sie darauf verweisen, da die Wahrscheinlichkeit groß ist, dass die Übersetzung falsch ist. Ich wäre Ihnen dankbar, wenn Sie auf Fehler hinweisen könnten.
Übersetzt von: MNIST für ML-Anfänger
Dieses Tutorial richtet sich an Leser, die sowohl mit maschinellem Lernen als auch mit TensorFlow noch nicht vertraut sind. Wenn Sie bereits wissen, was MNIST ist und was Softmax-Regression (Multi-Term Logistic) ist, sollten Sie ein weiteres Tutorial durchführen.
Wenn Sie lernen, wie man programmiert, drucken Sie normalerweise zuerst "Hello World". Maschinelles Lernen hat MNIST, genauso wie Programmieren Hello World hat.
MNIST ist ein einfacher Computer Vision-Datensatz. Der Datensatz besteht aus den folgenden handgeschriebenen numerischen Bildern.
(Zahl)
Außerdem enthält jedes Bild eine Beschriftung der Nummer. Beispielsweise lautet die Bezeichnung des obigen Bildes 5, 0, 4, 1.
In diesem Tutorial trainieren wir ein Modell, das Bilder untersucht und vorhersagt, um welche Zahlen es sich handelt. Unser Ziel ist es nicht wirklich, komplexe Modelle zu trainieren, um eine Spitzenleistung zu erzielen (aber wir werden Ihnen diesen Code später zur Verfügung stellen!), Sondern TensorFlow auszuprobieren. Daher beginnen wir mit einem sehr einfachen Modell namens Softmax-Regression.
Der eigentliche Code in diesem Tutorial ist sehr kurz und alle interessanten Dinge geschehen in nur drei Zeilen. Es ist jedoch sehr wichtig, die Idee dahinter zu verstehen. Es ist sowohl die Funktionsweise von TensorFlow als auch der Kern des Konzepts des maschinellen Lernens. Aus diesem Grund sind wir im gesamten Code sehr vorsichtig und hilfreich.
MNIST-Daten finden Sie auf der Website von Yann LeCun. Zur Vereinfachung haben wir Python-Code hinzugefügt, der die Daten automatisch herunterlädt und installiert. Sie können diesen Code herunterladen und wie folgt oder einfach importieren Sie können kopieren und einfügen in. (Hinweis: Kopieren und Einfügen bedeutet, dass Sie dieselbe Datei einfügen und verwenden können, ohne die oben verlinkte Datei input_data.py herunterladen und als separate Datei importieren zu müssen.)
import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
Diese heruntergeladenen Daten sind in zwei Teile unterteilt: 60.000 Trainingsdaten (mnist.train) und 10.000 Testdaten (mnist.test). Diese Aufteilung ist sehr wichtig. Geteilte Daten, die wir nicht lernen, sind für maschinelles Lernen unerlässlich, damit wir sehen können, was wir tatsächlich bei der Verallgemeinerung gelernt haben! (Hinweis: Die Übersetzung ist hier verdächtig. Vielleicht möchte ich sagen, dass zusätzlich zu den für das Training verwendeten Trainingsdaten Testdaten, die nicht für das Training verwendet werden, unverzichtbar sind ...)
Wie eingangs erwähnt, besteht jeder MNIST-Datenpunkt aus zwei Teilen, einem handschriftlichen Zahlenbild und einem zugehörigen Etikett. Wir werden das Bild "xs" und die Bezeichnung "ys" nennen. Sowohl Trainingssätze als auch Testsätze (Hinweis: wahrscheinlich mnist.train und mnist.test) enthalten xs und ys. Beispielsweise sind die Bilder der Trainingsdaten mnist.train.images und die Beschriftungen der Trainingsdaten sind mnist.train.labels.
Jedes Bild ist 28x28 Pixel groß. Wir können dies als eine Reihe großer Zahlen interpretieren.
(Zahl)
Wir können diese Sequenz auf einen Vektor mit den Zahlen 28x28 = 784 erweitern. Es spielt keine Rolle, wie wir die Sequenz dehnen, wenn wir zwischen den Bildern konsistent sind. Unter diesem Gesichtspunkt ist das MNIST-Bild nur eine sehr umfangreiche Struktur (Warnung: Intensive Computational Visualization ) Ist eine große Anzahl von Punkten im 784-dimensionalen Vektorraum.
Durch das Strecken der Daten werden Informationen über die zweidimensionale Struktur des Bildes weggeworfen. Ist das etwas schlechtes? Es ist die beste Computer-Vision-Methode, um diese Struktur in nachfolgenden Tutorials zu nutzen. (Hinweis: Die Übersetzung ist verdächtig.) Aber die einfache Methode, die wir hier verwenden, ist die Softmax-Regression, nicht wahr?
Das Ergebnis von mnist.train.images ist ein (n-dimensionales Array) Tensor mit der Form [60000, 784]. Die erste Dimension (60000) repräsentiert das Bild und die zweite Dimension (784) repräsentiert die Pixel in jedem Bild. Jedes Element im Tensor hat eine Pixelintensität zwischen 0 und 1 und ist ein bestimmtes Pixel in einem bestimmten Bild.
(Zahl)
Die entsprechende Bezeichnung in MNIST wird als Nummer für das Bild beschrieben, bei der es sich um eine Nummer von 0 bis 9 handelt. Für die Zwecke dieses Tutorials möchten wir unser Label als "ein heißer Vektor". Ein heißer Vektor ist ein Vektor von 0s in mehreren Dimensionen und 1s in einer Dimension. (Hinweis: Der später beschriebene Vektor enthält nur eine 1.) In diesem Fall wird die n-te Zahl als Vektor von n-dimensionalen dargestellt. Zum Beispiel ist 3 [0, 0, 0, 1, 0, 0, 0, 0, 0, 0]. Daher ist mnist.train.labels eine Sequenz vom Typ float [60000, 10]. (Hinweis: Es gibt 60000 28x28 = 784 trainierte Bilder, die in mnist.train.images durch [60000, 784] dargestellt werden. Diese Bilder sind die Nummern 0-9, also mnist.train.labels Es wird durch [60000, 10] dargestellt.)
(Zahl)
Wir sind jetzt bereit, unser Modell tatsächlich zu machen!
Wir wissen, dass alle Bilder in MNIST Zahlen sind, 0 oder 9. Wir wollen das Bild finden und eine Wahrscheinlichkeit für die Anzahl angeben. Zum Beispiel sucht unser Modell nach einem Bild von 9, und wir sind sicher, dass es 9 in 80% ist, aber es gibt uns eine 5% ige Chance, 8 zu sein (wegen der oberen Schleife), und zwar Weil es nicht so ist, gibt es eine kleine Chance, ein anderer zu werden.
Dies ist der klassische Fall, in dem die Softmax-Regression ein natürliches und einfaches Modell ist. Wenn Sie Wahrscheinlichkeiten als eines von mehreren verschiedenen Dingen zuweisen möchten, ist Softmax genau das Richtige für Sie. Später, wenn wir anspruchsvollere Modelle trainieren, wird der letzte Schritt die Softmax-Schicht sein.
Die Softmax-Regression besteht aus zwei Schritten. Erstens erhöhen wir die Evidenz unserer Eingabe, die eine solide Klasse darstellt, und wandeln die Evidenz in Wahrscheinlichkeiten um.
Die Summe der im Bild angegebenen Beweise gehört zu einer bestimmten Klasse (Hinweis: die Zahlen 0-9), und wir gewichten die Summe der Pixelintensitäten. Das Gewicht ist negativ, wenn das Bild in der Klasse ein Pixel mit hoher Intensität aufweist, das dem Beweis entgegengesetzt ist, und positiv, wenn es ein Beweis für die Unterstützung ist.
Die folgende Abbildung zeigt das Gewicht eines Modells, das für jede Klasse trainiert wurde. Rot steht für ein negatives Gewicht und Blau für ein positives Gewicht.
(Zahl)
Wir fügen auch einige zusätzliche Beweise hinzu, die als Voreingenommenheit bezeichnet werden. Grundsätzlich wollen wir sagen können, dass etwas nichts mit Input zu tun hat. Der Beweis für die Klasse $ i $ ist das Ergebnis, das bei Eingabe $ x $ angegeben wird.
evidence_i = \sum_{j} W_{i,j} x_j + b_i
$ W_i $ ist das Gewicht, $ b_i $ ist die Abweichung für die Klasse $ i $ und $ j $ ist der Index der Gesamtpixel im Eingabebild $ x $. Wir verwenden dann die Softmax-Funktion, um unsere vorhergesagte Wahrscheinlichkeit $ y $ aus der Summe der Beweise umzuwandeln.
y = softmax(evidence)
Dieser Softmax dient als "Aktivierungsfunktion" oder "Verknüpfungsfunktion" und formt die Ausgabe unserer linearen Funktion in die gewünschte Form. In diesem Fall handelt es sich um eine Wahrscheinlichkeitsverteilung über 10 Fälle. Sie können sich dies so vorstellen, dass die Summe der Beweise in die Wahrscheinlichkeit unserer Eingabe für jede Klasse umgewandelt wird. Es ist wie folgt definiert.
softmax(x) = normalize(exp(x))
Wenn Sie diese Formel erweitern, erhalten Sie:
softmax(x)_i = \frac {exp(x_i)} {\sum_{j} exp(x_j)}
Dies hilft jedoch oft, an die erste Methode zu denken, Softmax. Es geht darum, die Eingabe zu multiplizieren und dann zu normalisieren. Powering bedeutet eine weitere Beweiseinheit, die das Gewicht einer Hypothese verstärkt und erhöht. Andererseits bedeutet die Reduzierung einer Beweiseinheit, dass die Hypothese schnell an Gewicht gewinnt. Keine der Hypothesen hat null oder negative Gewichte. Softmax normalisiert diese Gewichte dann, addiert sie zu einer und wandelt sie in eine gültige Wahrscheinlichkeitsverteilung um. (Weitere Informationen zu Softmax-Funktionen finden Sie im Abschnitt von Michael Nieslens Buch mit bidirektionaler Visualisierung. TU es einfach.
Sie können sich die Softmax-Regression trotz der großen Menge von $ x $ so etwas vorstellen. Für jede Ausgabe berechnen wir eine gewichtete Summe von $ x $, verzerren sie und wenden dann Softmax an.
(Zahl)
Wenn wir es als Formel schreiben, erhalten wir:
\begin{bmatrix}
y_1 \\
y_2 \\
y_3 \\
\end{bmatrix} = softmax
\begin{pmatrix}
W_{1,1} x_1 + W_{1,2} x_2 + W_{1,3} x_3 + b_1 \\
W_{2,1} x_1 + W_{2,2} x_2 + W_{2,3} x_3 + b_2\\
W_{3,1} x_1 + W_{3,2} x_2 + W_{3,3} x_3 + b_3
\end{pmatrix}
Wir können "diese Prozedur als Vektor zeigen" und sie in Matrixmultiplikation und Vektoraddition umwandeln. Dies ist nützlich für die Recheneffizienz. (Es ist auch eine nützliche Art zu denken)
\begin{bmatrix}
y_1 \\
y_2 \\
y_3 \\
\end{bmatrix} = softmax
\begin{pmatrix}
\begin{bmatrix}
W_{1,1} & W_{1,2} & W_{1,3} \\
W_{2,1} & W_{2,2} & W_{2,3} \\
W_{3,1} & W_{3,2} & W_{3,3}
\end{bmatrix}
\cdot
\begin{bmatrix}
x_1 \\
x_2 \\
x_3
\end{bmatrix}
+
\begin{bmatrix}
b_1 \\
b_2\\
b_3
\end{bmatrix}
\end{pmatrix}
Um es kompakter zu machen, können wir einfach schreiben:
y = softmax(W_x + b)
Um effektive numerische Berechnungen mit Python durchzuführen, verwenden wir normalerweise hochwirksamen Code, der in anderen Sprachen implementiert ist, z. B. NumPy, das teure Operationen als Matrixmultiplikation außerhalb von Python ausführt. Verwenden Sie die Bibliothek. Leider scheint es immer noch viel Aufwand zu geben, für jede Operation zu Python zu wechseln. Dieser Overhead ist besonders schlimm, wenn Sie Berechnungen auf GPUs oder auf verteilte Weise ausführen möchten, bei denen die Datenübertragung hohe Kosten verursacht.
TensorFlow macht auch außerhalb von Python einen schweren Lift, unternimmt jedoch einen weiteren Schritt, um diesen Overhead zu vermeiden. Anstatt einen teuren Prozess unabhängig von Python auszuführen, können wir mit TensorFlow ein Diagramm von Interaktionsprozessen zeichnen, die vollständig außerhalb von Python ausgeführt werden. (Ein solcher Ansatz ist in einigen Bibliotheken für maschinelles Lernen zu finden.)
Um TensorFlow verwenden zu können, müssen wir es implementieren.
import tensorflow as tf
Wir beschreiben diese Interaktionsprozesse durch symbolische Variablen, die sie manipulieren. Lass uns eins machen.
x = tf.placeholder(tf.float32, [None, 784])
$ x $ ist kein besonderer Wert. Dies ist ein Platzhalter, der Wert, den wir eingeben, wenn wir TensorFlow bitten, die Berechnung auszuführen. Wir möchten in der Lage sein, jede Zahl im MNIST-Bild parallel zu 784 Dimensionen einzugeben. Wir drücken dies als 2-D-Tensor mit einer Reihe paralleler Punkte zusammen mit der Form [Keine, 784] aus. (Diese Keine bedeutet eine Dimension, die beliebig lang sein kann.)
Wir brauchen auch Gewichte und Vorurteile für unser Modell. Wir können uns vorstellen, diese wie zusätzliche Eingaben zu behandeln, aber TensorFlow hat eine bessere Möglichkeit, sie zu behandeln. Es ist variabel. Variavle ist ein veränderlicher Tensor, der im TensorFlow-Diagramm der Interaktionsverarbeitung lebt. Es kann durch Berechnung verwendet und geändert werden. Für Anwendungen des maschinellen Lernens sind die Parameter des Modells im Allgemeinen variabel.
W = tf.Variable(tf.zeros([784, 10))
b = tf.Variable(tf.zeros([10]))
Wir erstellen diese Variablen, indem wir ihnen tf.Variable als Anfangswert der Variablen geben. In diesem Fall initialisieren wir sowohl $ W $ als auch $ b $ als Tensol aller Nullen. Sie sind sehr problematisch, bis wir $ W $ und $ b $ trainieren.
Beachten Sie, dass $ W $ die Form [784, 10] hat, da wir den Vektor eines 784-dimensionalen Bildes damit multiplizieren möchten, um einen Vektor mit 10-dimensionalen Beweisen für verschiedene Klassen zu erzeugen. $ b $ hat die Form [10] und wir können sie der Ausgabe hinzufügen.
Wir können jetzt unser Modell implementieren. Es ist nur eine Zeile!
y = tf.nn.softmax(tf.matmul(x, W) + b)
Zuerst multiplizieren wir $ x $ und $ W $ mit der Darstellung von tf.matmul ($ x $, $ W $). Dies wird umgedreht, wenn sie in unserer Formel mit $ W_x $ als kleiner Trick multipliziert werden, um mit x umzugehen, einem 2D-Tensor mit vielen Eingaben. Wir fügen dann $ b $ hinzu und wenden schließlich tf.nn.softmax an.
Das ist es. Nach zwei kurzen Einrichtungszeilen ist nur eine Zeile erforderlich, um unser Modell zu definieren. Dies liegt nicht daran, dass TensorFlow die Softmax-Regression besonders einfach macht. Es ist nur eine sehr flexible Möglichkeit, viele Arten von numerischen Berechnungen aus maschinellen Lernmodellen für die physikalische Simulation darzustellen. Sobald dies klar ist, kann unser Modell auf verschiedenen Geräten ausgeführt werden. Die CPU, GPU oder sogar Ihr Mobiltelefon Ihres Computers!
Um unser Modell zu trainieren, müssen wir definieren, was es bedeutet, gut für das Modell zu sein. In der Praxis des maschinellen Lernens definieren wir im Allgemeinen, was für das Modell schlecht sein soll, was als Kosten oder Verlust bezeichnet wird, und wie das Schlechte kleiner gemacht werden kann. Versuchen. Aber die beiden sind gleichwertig.
Eine sehr gewöhnliche und sehr gute Kostenfunktion ist die "Kreuzentropie". Überraschenderweise entsteht Cross-Entropie aus dem Nachdenken über Informationskomprimierungscodes in der Informationstheorie, aber sie ist in vielen Bereichen eine wichtige Idee und ergibt sich aus dem maschinellen Lernen von Glücksspielen. Es ist definiert als:
H_{y^{'}}(y) = -\sum_i y^{'}_i \log(y_i)
$ y $ ist die Wahrscheinlichkeitsverteilung, die wir vorhergesagt haben, und $ y_ {'} $ ist die wahre Wahrscheinlichkeitsverteilung (ein heißer Vektor, den wir eingeben). In gewisser Weise bewertet Cross-Entropy, wie ineffizient unsere Vorhersagen für die Wahrheit sind. Weitere Details zur Kreuzentropie werden in diesem Lernprogramm nicht behandelt, aber Verständnis lohnt sich.
Um die Kreuzentropie zu implementieren, müssen wir zuerst dem Platzhalter die richtige Antworteingabe hinzufügen.
y_ = tf.placeholder(tf.float32, [None, 10])
Dann können wir die Kreuzentropie $ - \ sum_i y ^ {'} _i \ log (y_i) $ implementieren.
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
Zuerst berechnet "tf.log" den Logarithmus jedes Elements "y".
Dann multiplizieren wir jedes Element "y_" mit dem entsprechenden Element "tf.log (y)".
Schließlich fügt tf.reduce_sum die Tensoren aller Elemente hinzu.
(Hinweis: Dies ist nicht nur die wahre Kreuzentropie in einer Vorhersage, sondern auch die Summe der Kreuzentropien aller 100 Bilder, nach denen wir gesucht haben. Wie gut sind die 100 Daten? Nur besser wird dargestellt, wie unser Modell besser ist als ein einzelnes Datenelement.)
Jetzt, da wir wissen, was unser Modell tun soll, ist TensorFlow sehr einfach zu handhaben. Da TensorFlow das gesamte Diagramm Ihrer Berechnung kennt, kann automatisch [Fehler umkehren] effizient ermittelt werden, wie sich Ihre Variablen auf die Kosten auswirken, die Sie minimieren möchten. Ausbreitungsalgorithmus](http://colah.github.io/posts/2015-08-Backprop/) kann verwendet werden. Sie können dann die Variablen ändern und den Optimierungsalgorithmus Ihrer Wahl anwenden, um die Kosten zu senken.
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
In diesem Fall soll TensorFlow "cross_entropy" mithilfe der Gradientenabstiegsmethode mit einem Lernkoeffizienten von 0,01 minimieren. Der Gradientenabstieg ist ein einfaches Verfahren, und TensorFlow ändert jede Variable einfach in Richtung Kosteneinsparungen in ein kleines Bit. TensorFlow bietet jedoch auch viele andere Optimierungsalgorithmen. Verwenden Sie etwas so Einfaches wie das Anpassen einer Zeile.
Was TensorFlow hier wirklich hinter den Kulissen ist, ist das Hinzufügen einer neuen Verarbeitung zu Ihrem Diagramm, die Fehlerausbreitung und Gradientenabstieg implementiert. Wenn es ausgeführt wird, wird es einen Schritt zurück gegeben, indem es das Pisten-Training herunterfährt und die Variablen anpasst, um die Kosten leicht zu senken.
Jetzt haben wir ein Modell für das Training aufgestellt. Das Letzte, was wir tun, ist, dass wir der Initialisierung der von uns erstellten Variablen eine gewisse Verarbeitung hinzufügen müssen.
init = tf.initialize_all_variables()
Wir können jetzt das Modell in "Sitzung" ausführen und den Prozess der Initialisierung der Variablen ausführen.
sess = tf.Session()
sess.run(init)
Lass uns trainieren. Wir führen 1000 Trainingsschritte durch!
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})
Bei jedem Schritt der Schleife erhalten wir einen "Stapel" von 100 zufälligen Datenpunkten aus dem Trainingssatz. Wir führen einen "train_step" durch, der Batch-Daten abruft, um Platzhalter und andere auszutauschen.
Die Verwendung einer kleinen Menge zufälliger Daten wird als stochastisches Training bezeichnet, in diesem Fall als stochastischer Gradientenabstieg. Idealerweise möchten wir alle Daten in jedem Schritt des Trainings verwenden, aber es ist teuer, weil es uns ein gutes Gefühl dafür gibt, was wir tun sollten. Stattdessen verwenden wir jedes Mal eine andere Teilmenge. Dies zu tun ist billig und hat die gleichen Vorteile.
Wie gut ist unser Modell?
Lassen Sie uns zunächst das richtige Etikett wissen, das wir vorhergesagt haben.
tf.argmax ist eine sehr nützliche Funktion, die den Index der höchsten Eingabe in einem Tensor entlang einer Achse angibt.
Zum Beispiel ist "tf.argmax (y, 1)" die Bezeichnung unseres Modells, die am wahrscheinlichsten für jede Eingabe ist, während "tf.argmax (y_, 1)" die richtige Bezeichnung ist.
Wir können "tf.equal" verwenden, um zu sehen, ob unsere Vorhersagen wahr sind.
correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
Dies gibt uns eine Liste von Booleschen. Um festzustellen, ob die Funktion korrekt ist, wandeln wir sie in Gleitkomma um und nehmen dann den Durchschnittswert. Zum Beispiel wird [Richtig, Falsch, Richtig, Richtig] zu [1,0,1,1] und (Hinweis: Durchschnittswert) zu 0,75.
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
Schließlich fordern wir Genauigkeit in den Testdaten.
print(sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels}))
Dies sollte ungefähr 91% sein.
Ist es gut? Nicht wirklich. In der Tat ist es ein wenig schlecht. Das liegt daran, dass ich ein sehr einfaches Modell verwendet habe. Mit einer kleinen Änderung können wir 97% erhalten. Das beste Modell kann eine Genauigkeit von über 99,7% erreichen! (Weitere Informationen finden Sie in dieser Ergebnisliste.)
Das Problem ist, dass wir aus diesem Modell gelernt haben. Wenn Ihnen diese Ergebnisse nicht gefallen, können Sie leicht lernen, wie Sie mit TensorFlow [Nächstes Tutorial](https: //www.tensorflow) ein komplexeres Modell erstellen. Überprüfen Sie org / version / master / tutorials / mnist / pros / index.html)!
Das Obige ist die Übersetzung von MNIST For ML Beginners.
Es gibt einige verdächtige und subtile Übersetzungen an einigen Stellen, aber jetzt weiß ich, was ich tun möchte. Es gibt einige Formeln, aber ich multipliziere und addiere nur Matrizen, und das mache ich nicht so schwierig. TensorFlow eignet sich für schwierige Softmax-Regression und Gradientenabstieg. Nun, ich denke es ist nur so, dass du das verstehst.
Ich denke, das Folgende ist eine kurze Zusammenfassung.
Als nächstes möchte ich tatsächlich einen Code komponieren und ausführen, ob er Zeichen erkennen kann.
Recommended Posts