Hallo. In diesem Artikel werde ich den grundlegenden Schreibstil und die Grammatik von TensorFlow (TF) erläutern. Das Ziel ist für diejenigen, die TF noch nicht kennen und nicht viel Python geschrieben haben.
Als Hintergrund habe ich den Python-Code richtig geschrieben, als ich TF berührt habe. Da es sich um eine Notiz handelt, die zu diesem Zeitpunkt hinterlassen wurde, kann es ähnlichen Personen helfen, TF zu verstehen.
Für den Beispielcode habe ich "[Beurteilen Sie das Gehalt von professionellen Baseballspielern mit einem neuronalen Netzwerk]" (http://qiita.com/sergeant-wizard/items/9bb45c0850aebca2bc07) verwendet. .. Vielen Dank für Ihre Erlaubnis zur Veröffentlichung.
import tensorflow as tf
import numpy
Ich benutze auch numpy, also vergiss nicht, es zu importieren.
SCORE_SIZE = 33
HIDDEN_UNIT_SIZE = 32
TRAIN_DATA_SIZE = 90
SCORE_SIZE: Dimension der Eingabedaten HIDDEN_UNIT_SIZE: Anzahl der Knoten der verborgenen Schicht (Zwischenschicht) TRAIN_DATA_SIZE: Anzahl der Stichproben von Trainingsdaten Sie können den Variablennamen selbst festlegen!
raw_input = numpy.loadtxt(open(`input.csv`), delimiter=`,`)
[salary, score] = numpy.hsplit(raw_input, [1])
numpy.loadtxt: Datenladefunktion in der numpy-Bibliothek.
Trennzeichen ist eine Datenbegrenzerspezifikation. Der Autor hat die Daten in input.csv gespeichert. http://goo.gl/h5g8cJ raw_input speichert Array-Typdaten.
numpy.hsplit: Eine Funktion, die eine Trennlinie in vertikaler Richtung (Spaltenrichtung) setzt und das Array in horizontaler Richtung (Zeilenrichtung) teilt.
raw_input: Array, das geteilt werden soll [1]: Die Grenzlinie der Division. Wählen Sie die 0. Spalte aus, weisen Sie sie dem Gehalt zu und weisen Sie der Punktzahl die 1. Spalte zu. Daher ist das Gehalt ein Vektor der Anzahl der Komponenten = Anzahl der Personen (= 94), und die Punktzahl ist ein Array von 94 x 33. Beachten Sie, dass das Gehalt die Lehrerdaten und die Punktzahl die Eingabedaten sind. http://goo.gl/hoMyGH
[salary_train, salary_test] = numpy.vsplit(salary, [TRAIN_DATA_SIZE])
[score_train, score_test] = numpy.vsplit(score, [TRAIN_DATA_SIZE])
numpy.vsplit: Eine Funktion, die ein Skalpell horizontal einfügt und das Array vertikal teilt.
Gehaltszug: Vektor mit 89 Komponenten Gehaltsprüfung: Vektor mit 5 Komponenten score_train: 89 x 33 Array score_test: 5 x 33 Array
def inference(score_placeholder):
with tf.name_scope('hidden1') as scope:
hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name=`hidden1_weight`)
hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name=`hidden1_bias`)
hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias)
with tf.name_scope('output') as scope:
output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name=`output_weight`)
output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name=`output_bias`)
output = tf.matmul(hidden1_output, output_weight) + output_bias
return tf.nn.l2_normalize(output, 0)
Inferenz: Funktionsname (optional) score_placeholder: Daten, die im folgenden Code definiert sind.
Geben Sie für Platzhaltertypdaten die Daten / Aktualisierungsdaten (dh Eingabedaten und Lehrerdaten) an, die die Lernquelle sein sollen. Es ist ein Datentyp, der TF eigen ist. In TF werden beim Aktualisieren des Lernens die Originaldaten von einem Mechanismus namens Feed erfasst. Der Platzhaltertyp ist mit dem Feed verknüpft, und die Eingabedaten werden in den zugehörigen Berechnungen berücksichtigt. http://goo.gl/uhHk3o
with tf.name_scope('hidden1') as scope:
mit: Python-Syntax. Eine Anweisung, die die folgenden Anweisungen nicht auf Befehle außerhalb des Kontexts überträgt. tf.name_scope: TF-Namensverwaltungsfunktion. Für die verschachtelten Anweisungen unter dieser Funktion wird eine Kontextgruppe gebildet.
Der Vorteil der Verwaltung von Namen liegt im Zeichnen. TensorFlow kann das auf TensorBoard basierende Modell des Lernenden veranschaulichen. Das Verwalten der Namen erleichtert das Verständnis der Zeichnungsausgabe. Hier sind die folgenden Gewichtungs- und Bias-Zuweisungsaktionen unter der Funktion name_scope verschachtelt. Das heißt, es definiert, dass diese Anweisungen im Kontext von 'versteckt1' stehen, einer Berechnung der Parameter für versteckte Ebenen. http://goo.gl/AYodFB
hidden1_weight = tf.Variable(tf.truncated_normal([SCORE_SIZE, HIDDEN_UNIT_SIZE], stddev=0.1), name=`hidden1_weight`)
hidden1_bias = tf.Variable(tf.constant(0.1, shape=[HIDDEN_UNIT_SIZE]), name=`hidden1_bias`)
hidden1_output = tf.nn.relu(tf.matmul(score_placeholder, hidden1_weight) + hidden1_bias)
Es ist eine Berechnung von ** Eingabeebene → versteckte Ebene **.
tf.Variable: Die TF-Variablenklasse kann angewendet werden
Neben der Generierung als Variable hat es verschiedene Funktionen. Beispielsweise kann die Befehlszuweisung den Wert einer Variablen überschreiben. (Details sind unten verlinkt) http://goo.gl/nUJafs
tf.truncated_normal: Gibt eine normalverteilte Zufallszahl zurück
[SCORE_SIZE, HIDDEN_UNIT_SIZE]: Die Arraygröße der gewünschten Zufallszahlen. stddev: Gibt die Standardabweichung der Normalverteilung an. Geben Sie in der Standardnormalverteilung "mean = 0.0, stddev = 1.0" an. Der Anfangswert des NN-Gewichts $ {\ bf W} $ wird durch Zufallszahlen erzeugt. Zu diesem Zeitpunkt kann dieses Programm ohne Vorlernen als NN interpretiert werden. hidden1_weight kann als Matrix mit einer Gewichtung von $ {\ bf W} $ interpretiert werden. name benennt einfach die Ausführung dieser Funktion. http://goo.gl/oZkcvs
tf.constant: Funktion zum Generieren von Konstanten
0,1: Konstante 0,1 erzeugen. Form: Die Größe, die die Konstante macht. Erstellen Sie nur die Anzahl der ausgeblendeten Ebeneneinheiten (HIDDEN_UNIT_SIZE) und ersetzen Sie diese durch hidden1_bias. hidden1_bias ist der Bias-Term der verborgenen Schicht, und hier wird der Anfangswert auf 0,1 gesetzt.
tf.nn.relu: Eine Funktion, die ReLU berechnet, eine der Aktivierungsfunktionen. (Dieser Artikel dient der Erläuterung des Codes. Bitte lernen Sie die Bedeutung von ReLU separat kennen. M (_ _) m)
tf.matmul: Eine Funktion, die das Produkt von Matrizen (Vektoren) berechnet (oder das innere Produkt, wenn es sich um Vektoren handelt).
Hier wird das Produkt aus der Matrix score_placeholder und der Matrix hidden1_weight berechnet. Wie Sie der folgenden Definition entnehmen können, gilt diese Definition, da die Anzahl der Spalten in score_placeholder als SCORE_SIZE definiert ist. Als Ergebnis wird das Berechnungsergebnis für die Anzahl der Einheiten als Vektor als Ausgabe berechnet.
with tf.name_scope('output') as scope:
output_weight = tf.Variable(tf.truncated_normal([HIDDEN_UNIT_SIZE, 1], stddev=0.1), name=`output_weight`)
output_bias = tf.Variable(tf.constant(0.1, shape=[1]), name=`output_bias`)
output = tf.matmul(hidden1_output, output_weight) + output_bias
return tf.nn.l2_normalize(output, 0)
Es ist eine Berechnung von ** versteckter Schicht → Ausgabeschicht **. Die Ausgabe wird skalar berechnet. Mit anderen Worten, die Einheit der Ausgabeebene ist 1, was das Vergleichsziel mit dem Jahresgehalt des Spielers ist (Lehrerdaten). In diesem Fall wird die Aktivierungsfunktion zu einer einheitlichen Abbildung für die Ausgabeschicht. tf.nn.l2_normalize: Funktion, die die Normalisierung berechnet und zurückgibt
Wenn es sich um einen Vektor handelt, teilen Sie jede Komponente des Vektors durch die Norm. (Transformation, bei der die Größe des Vektors 1 wird) Gleiches gilt für Matrizen und Tensoren. Wenn es sich um einen Skalar handelt, wird 1 zurückgegeben. Da hier auch die Originaldaten normalisiert sind, ist es notwendig, die normalisierten Werte zu vergleichen. https://goo.gl/NEFajc
def loss(output, salary_placeholder, loss_label_placeholder):
with tf.name_scope('loss') as scope:
loss = tf.nn.l2_loss(output - tf.nn.l2_normalize(salary_placeholder, 0))
tf.scalar_summary(loss_label_placeholder, loss)
return loss
tf.nn.l2_loss: Eine Funktion, die den quadratischen Fehler berechnet.
Beachten Sie, dass der Datentyp Einschränkungen unterliegt. Die Hauptfehlerfunktionen sind ** Quadratfehlerfunktion ** und ** Kreuzentropiefehlerfunktion **. Die quadratische Fehlerfunktion wird für die numerische Vorhersageaufgabe verwendet, und die Kreuzentropiefehlerfunktion wird für die Klassifizierungsaufgabe verwendet. Die Methode zum Festlegen des Gehalts-Platzhalters besteht darin, bei jeder Aktualisierung Gehaltsdaten als Lehrerdaten in diese Variable einzugeben. http://goo.gl/V67M7c
tf.scalar_summary: Eine Funktion, die eine Zeichenfolge an den Zielskalar anfügt und die Bedeutung des Werts aufzeichnet.
loss_label_placeholder wird unten als String-Platzhalter definiert. http://goo.gl/z7JWNe
def training(loss):
with tf.name_scope('training') as scope:
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
return train_step
tf.train.GradientDescentOptimizer: Eine Klasse, die SGD-Algorithmen speichert.
0,01: Repräsentiert den Lernkoeffizienten ε minimieren (Verlust): Tricky, aber eine Funktion, die in einer Klasse namens tf.train.GradientDescentOptimizer gespeichert ist und die Zielvariable minimiert (Verlust in diesem Fall) Da es sich um ein Objekt handelt, das den Berechnungsprozess speichert, wird der aktualisierte Gewichtungsparameter nach der Differentialberechnung zurückgegeben. http://goo.gl/5XENkX
In TensorFlow wird eine Gruppe von Algorithmen zur Lernausführung in einer Klasse namens Graph gespeichert. Nicht nur die Berechnung (session.run), sondern auch die für das Zeichnen von Grafiken erforderlichen Informationen (session.graph) sind wie der Name schon sagt organisiert. (Es ist bequem (・ ω <))
with tf.Graph().as_default():
salary_placeholder = tf.placeholder(`float`, [None, 1], name=`salary_placeholder`)
score_placeholder = tf.placeholder(`float`, [None, SCORE_SIZE], name=`score_placeholder`)
loss_label_placeholder = tf.placeholder(`string`, name=`loss_label_placeholder`)
mit tf.Graph (). as_default () :: Anweisung, die die Graphklasse deklariert Salary_placeholder: Ein Objekt, in dem Lehrerdaten mit Jahreseinkommen gespeichert werden
[Keine, 1]: Bedeutet, dass die Anzahl der Spalten 1 und die Anzahl der Zeilen beliebig ist.
score_placeholder: Objekt zum Speichern von Eingabedaten loss_label_placeholder = Zeichenfolgenspeicherobjekt, das zum Zeitpunkt der Ausgabe in die Zusammenfassungsinformationen aufgenommen / wiedergegeben werden soll
feed_dict_train={
salary_placeholder: salary_train,
score_placeholder: score_train,
loss_label_placeholder: `loss_train`
}
feed_dict_train: Deklaration der Wörterbuchtypdaten, die für jedes Lernupdate verwendet werden sollen
In Wörterbuchdaten gespeichert (feed_dict_train). Damit der TF die Daten jedes Mal lesen kann, muss der Feed gebissen werden. http://goo.gl/00Ikjg ↑ Überprüfung der Wörterbuchtypdaten Geben Sie einen temporären Tensor für den Schlüssel und einen Anfangswert für den Wert ein. Eine Reihe von Wörterbüchern für Trainingsdaten. Sie können in session.run unten sehen, warum Sie diese Art von Wörterbuch benötigen.
feed_dict_test={
salary_placeholder: salary_test,
score_placeholder: score_test,
loss_label_placeholder: `loss_test`
}
feed_dict_test: Erstellen Sie Wörterbuchdaten für Testdaten Die Konfiguration ist die gleiche wie oben.
python
output = inference(score_placeholder)
loss = loss(output, salary_placeholder, loss_label_placeholder)
training_op = training(loss)
Fügen Sie die Inferenz der NN-Berechnungsfunktion für die Vorwärtsausbreitung in "Ausgabe" ein.
Fügen Sie den Verlust der Berechnungsfunktion der quadratischen Fehlerfunktion in "Verlust" ein.
Fügen Sie das Training der SGD-Algorithmus-Ausführungsfunktion in training_op ein.
python
summary_op = tf.merge_all_summaries()
tf.merge_all_summaries: Aggregiert die Informationen der Summary-Funktion.
http://goo.gl/wQo8Rz
init = tf.initialize_all_variables()
Weisen Sie die Funktion tf.initialize_all_variables zu, die alle Variablen auf init initialisiert. ** Der Zeitpunkt der Initialisierungsdeklaration ist wichtig. ** Wenn Sie nach dem Definieren aller erforderlichen Variablen nicht deklarieren, wird ein Fehler zurückgegeben.
http://goo.gl/S58XJ2
best_loss = float(`inf`)
Deklarieren Sie best_loss, eine Gleitkommazahl. Es gibt einen Ort, an dem der Fehler unten aktualisiert werden kann. Der beste Verlust wird für diesen Wert verwendet, aber der anfängliche beste Verlust ist höher als eine beliebige Zahl (inf; unendlich), da der anfängliche Wertverlust enthalten sein muss.
with tf.Session() as sess:
Die Sitzung ist eine Kernklasse in Graph und enthält Anweisungen zur Ausführung im Allgemeinen. Wenn die Sitzung nicht deklariert ist, wird nicht die gesamte objektbezogene Verarbeitung gestartet.
http://goo.gl/pDZeLI
summary_writer = tf.train.SummaryWriter('data', graph_def=sess.graph_def)
tf.train.SummaryWriter: Eine Funktion, die zusammenfassende Informationen in eine Ereignisdatei schreibt.
sess.run(init)
sess.run: Weitere Kernfunktion.
Führen Sie die im ersten Argument geschriebene Anweisung aus. In Windows ist es wie .exe!
for step in range(10000):
sess.run(training_op, feed_dict=feed_dict_train)
loss_test = sess.run(loss, feed_dict=feed_dict_test)
für Schritt in Reichweite (10000): 10000 Mal wiederholen. "Daten für 89 Personen lernen und Daten für 5 Personen testen." Dies ist ein Mal! feed_dict = feed_dict_train: Wichtige Option für session.run
Das hier wiederholt erläuterte Zuführsystem. Hier werden die erforderlichen Daten aufgenommen und die Berechnung der Lernaktualisierung durchgeführt.
if loss_test < best_loss:
best_loss = loss_test
best_match = sess.run(output, feed_dict=feed_dict_test)
Notieren Sie den Fehlerwert und die Ausgabeebene (geschätztes Jahresgehalt) nur, wenn der minimale Fehlerwert aktualisiert wurde.
if step % 100 == 0:
summary_str = sess.run(summary_op, feed_dict=feed_dict_test)
summary_str += sess.run(summary_op, feed_dict=feed_dict_train)
summary_writer.add_summary(summary_str, step)
Eine Anweisung, alle 100 Schritte zusammenfassende Informationen zu sammeln. Schreiben Sie außerdem die gesammelten Informationen in die Ereignisdatei.
print sess.run(tf.nn.l2_normalize(salary_placeholder, 0), feed_dict=feed_dict_test)
print best_match
Zeigen Sie für jeden Schritt Lehrerdaten und hochpräzise Daten der Ausgabeebene an.
Recommended Posts