[PYTHON] [Übersetzen Sie das TensorFlow-Tutorial grob ins Japanische] 1. MNIST für ML-Anfänger

MNIST für Anfänger im maschinellen Lernen

Einführung

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/beginners/index.md Bitte beachten Sie, dass einige Übersetzungen seltsam erscheinen können, da sie echtes Japanisch sind.

Dieses Tutorial entspricht Kapitel 2 von Mr. Okayas Buch "Deep Learning". Sie können es also gemeinsam lesen.

Dann ist das diesmal erstellte Modell ein Modell namens Soft Max Regression.

MNIST-Daten

MNIST-Daten lesen.

import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)

Die Download-Daten sind in zwei Teile unterteilt. 60.000 Punkte Trainingsdaten (mnist.train) und 10.000 Punkte Testdaten (minist.test).

Alle MNIST-Daten bestehen aus zwei Elementen: einem handgeschriebenen digitalen Bild und den entsprechenden Etikettendaten. Hier heißt das handgeschriebene Bild xs und die Etikettendaten ys. (zB mnist.train.images und mnist.train.labels)

Jedes handgeschriebene Bild 28 Pixel x 28 Pixel = 784 Zahlen Mit anderen Worten, es ist eine Folge von Zahlen (Vektor).

Dies entspricht dem Wegwerfen der zweidimensionalen Information. Die schwierigste Methode enthält auch diese zweidimensionalen Informationen, aber dieses Mal werde ich sie bisher nicht berücksichtigen.

Infolgedessen wird mnist.train.images zu einem Tensor (≒ n-dimensionale Matrix), und seine Form ist [60000,784].

Die entsprechenden Markierungsdaten werden als "One-Hot-Vektor" ausgedrückt. ex, 0 -> [1,0,0,0,0,0,0,0,0,0,0] 3 -> [0,0,0,1,0,0,0,0,0,0,0] Mnist.train.labels ist also ein Array von [6000,10].

Softmax-Regression

Die Softmax-Regression ist ein natürliches und einfaches Modell. Softmax ist nützlich, wenn Sie einem Ziel Wahrscheinlichkeiten und anderen Zielen Wahrscheinlichkeiten geben möchten. (Beispiel: Dieses Bild ist zu 80% wahrscheinlich 9, 5% wahrscheinlich 8 ...)

Um zu berechnen, dass ein bestimmtes Bild zu einer bestimmten Klasse gehört, berechnen wir die gewichtete Summe der Pixelwerte. Dieses Gewicht macht Sinn. Der rote Teil steht für "negatives Gewicht" und der blaue Teil für "positives Gewicht". (* Blau sieht aus wie eine Zahl ..?)

Regression ausführen

Für effiziente Python-Berechnungen verlassen wir uns normalerweise auf Bibliotheken wie Numpy, mit denen umfangreiche Berechnungen außerhalb von Python durchgeführt werden können. Wenn ich jedoch zu Python zurückkehre, kostet es viel Berechnung. Wenn Sie GPUs oder andere parallele Berechnungen durchführen möchten, sind diese sehr ungünstig.

Mit TensorFlow können Sie alle Diagramme verwandter Anweisungen vollständig außerhalb von Python schreiben, anstatt eine schwere Anweisung unabhängig von Python ausführen zu lassen.

Overhead .. Kosten für die Verwaltung von Hardware und Programmen

Importieren Sie zunächst den Tensorflow.

import tensorflow as tf

Beschreiben Sie die miteinander verbundenen Anweisungen wie oben beschrieben, indem Sie symbolische Variablen bearbeiten.

x = tf.placeholder("float",[None,784])

x ist kein bestimmter Wert, sondern wird als Platzhalter bezeichnet. Dies ist der Wert, den Sie eingeben, wenn Sie TensorFlow auffordern, die Berechnung durchzuführen.

Der Eingabewert des MNIST-Bildes wurde in einen 784-dimensionalen Vektor umgewandelt. Diese werden als zweidimensionaler Tensor von [None, 784] ausgedrückt.

Das Modell benötigt auch Gewicht und Vorurteile. In solchen Fällen wird eine Variable verwendet. Variable ist ein veränderlicher Tensor, der im Diagramm der Interaktionsanweisungen von TensorFlow "lebt".

w = tf.Variable(tf.zeros([784,10]))
b = tf.Variable(tf.zeros([10]))

Dieses Mal habe ich W und b als Variable gemacht, die nur 0 hat. Wir werden von nun an W und b lernen, daher spielt es keine Rolle, wie hoch der Anfangswert war.

Jetzt können Sie das Modell ausführen!

y = tf.nn.softmax(tf.matmul(x,W)+b)

Es scheint, dass tf.matmul (x, W) verwendet wird, um x zu multiplizieren, und W, b wird hinzugefügt, und das Ergebnis wird der Softmax-Funktion von tf.nn.softmax zugewiesen. Der Grund, warum x ein zweidimensionaler Tensor ist, ist, dass er mit W multipliziert werden kann. (Wahrscheinlich matmul = Matrixmultiplikator)

Lernen

Eine Fehlerfunktion wird verwendet, um quantitativ zu bewerten, was eine gute Modellierung als maschinelles Lernen ist. Dieses Mal verwenden wir eine Fehlerfunktion namens Kreuzentropie. Hier ist y die Wahrscheinlichkeitsverteilung des diesmal vorhergesagten Ergebnisses und y die wahre Verteilung.

Um Cross-Entropy auszuführen, müssen Sie zuerst einen neuen Platzhalter hinzufügen, um die richtige Antwort einzugeben.

y_ = tf.placeholder("float",[None,10])

Und Sie können Cross-Entropie ausführen.

cross_entropy = -tf.reduce_sum(y_*tf.log(y))

tf.log (y) berechnet den Logarithmus jedes Elements von y, berechnet die Multiplikation mit jedem Wert von y_ und schließlich addiert tf.reduce_sum alle Elemente des Tensors.

Mit TensorFlow ist das Lernen einfach. TensorFlow kennt das gesamte Diagramm seiner Berechnung, sodass es automatisch den Backpropagation-Algorithmus verwenden kann. Der Backpropagation-Algorithmus zeigt effizient, wie sich Variablen auf die zu minimierende Fehlerfunktion auswirken.

train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

Dieses Mal wird TensorFlow angewiesen, cross_entropy mit einer Lernrate von 0,01 unter Verwendung des Gradientenabstiegsalgorithmus zu minimieren. Der Gradientenabstieg ist ein einfaches Verfahren, und TensorFlow ändert einfach jede Variable geringfügig in Richtung eines kleineren Fehlers. TensorFlow verfügt jedoch über viele Optimierungsalgorithmen, deren Verwendung sehr einfach ist.

Es muss nur eine Anweisung hinzugefügt werden, um die festgelegten Variablen zu initialisieren, bevor das Modell trainiert wird. (* Noch nicht ausgeführt!)

init = t.initialize_all_bariables()

Schließlich können Sie die Sitzung starten. Lassen Sie uns die Anweisung ausführen, um die Variable zu initialisieren.

sess = tf.Session()
sess.run(init)

Und wiederhole das Training 1000 mal!

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 von uns erstellten Trainingsdatensatz. Führen Sie dann train_step aus, geben Sie die einzelnen Stapeldaten an und ändern Sie den Platzhalter.

Die Technik der Verwendung "kleiner Chargen" von Zufallsdaten wird als stochastisches Training bezeichnet, in diesem Fall als stochastischer Gradientenabstieg.

Auswertung des erstellten Modells

Stellen Sie zunächst fest, was Sie richtig vorhergesagt haben. tf.argmax ist eine sehr nützliche Funktion, die den Wert zurückgibt, dessen Wert der Tensor entlang mehrerer Achsen das größte Element hat. Beispielsweise gibt tf.argmax (y, 1) die wahrscheinlichste Bezeichnung für jede Eingabe zurück, und tf.argmax (y_, 1) gibt die richtige Bezeichnung zurück. Und tf.equal kann verwendet werden, um festzustellen, ob unsere Vorhersage korrekt war.

correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))

Als Ergebnis wird eine Liste von Booleschen Werten zurückgegeben. Konvertieren Sie es zur Vereinfachung in einen Float-Wert und nehmen Sie den Durchschnitt. Zum Beispiel wird [Richtig, Falsch, Richtig, Richtig] zu [1,0,1,1] und der Durchschnitt beträgt 0,75.

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

Schließlich fragen wir die prädiktive Korrektheitsrate für die Testdaten

print sess.run(accuracy, feed_dict={x: mnist.test.images, y_: mnist.test.labels})

Dieses Ergebnis wird bei 91% liegen.