Die Earth Defense Force 4.1, die ich beiläufig gekauft habe, macht Spaß und Donner! Ich werde sagen. Es ist okay für Ameisen, stetig zu kommen, aber beißen Sie nicht einfach!
Ich frage mich, ob es heutzutage beliebt ist, ein solches Framework wie maschinelles Lernen herauszubringen, und Microsoft hat zu diesem Zweck ein ähnliches DMLT herausgebracht. Tensorflow hat die Führung übernommen, aber ich weiß nicht, wie viele Biere es hat, und ich habe das Gefühl, dass ich es nicht einmal herausholen kann, aber ich kann es nicht sagen, bis ich es anfasse. Es gibt viele Fälle, in denen Sie das maschinelle Lernsystem nicht verstehen, selbst wenn Sie es berühren.
Derzeit kann es normal installiert werden, es ist jedoch besser, die offizielle Seite für diesen Bereich zu sehen. Die offizielle Empfehlung lautet virtualenv. Später wurde ich getäuscht, weil ich kein Pythonista bin, aber Tensorflow ist derzeit nur für 2.7. Die Unterstützung für die 3.x-Serie wird ebenfalls als Problem erwähnt, und es scheint, dass die Unterstützung erfolgt, daher denke ich, dass sie bald herauskommen wird.
http://tensorflow.org/get_started/os_setup.md
Ich denke, Tensorflow wurde aufgrund seiner umfangreichen Tutorials zu einem heißen Thema. Wir bieten offiziell allgemeines maschinelles Lernen (Anfänger) und Lernmethoden über das Convolutional Network an.
Der Inhalt ist alles in Englisch, aber wenn Sie die Wörter im Zusammenhang mit Mathematik nachschlagen, werden Sie keine großen Probleme haben. Vorerst werde ich den Anfänger und die Tiefe, die ich gemacht habe, mit Kommentaren versehen.
Beginner
# coding: utf-8
import input_data
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
import tensorflow as tf
#Platzhalter. Eine Variable zum Speichern eines bestimmten Werts. Die erste Anzahl zweidimensionaler Vektoren ist Keine, da es sich um eine beliebige Anzahl handelt.
#Die zweite Dimension ist 784, die Anzahl der Pixel von MNIST
x = tf.placeholder("float", [None, 784])
#W ist Weight's W. Der Grund, warum die erste Dimension des zweidimensionalen Vektors die Anzahl der Pixel ist, besteht darin, dass die Reihenfolge der Anordnung von MNIST Index → Pixel und als Matrix ist
#Wenn dies beim Multiplizieren nicht der erste ist, ist das Ergebnis kein 10-Spalten-Vektor
W = tf.Variable(tf.zeros([784, 10]))
#Dies ist ein eindimensionaler Vektor. Es spielt keine Rolle, ob es sich um eine Zeile oder eine Spalte handelt, es handelt sich lediglich um ein Indexproblem.
b = tf.Variable(tf.zeros([10]))
#Sowohl W als auch b werden als variabel betrachtet, aber bei der nachfolgenden Gradientenabstiegsmethode wird die Fehlerrückausbreitungsmethode automatisch automatisch
#Es wird jedes Mal aktualisiert. Wenn Sie die Backpropagation-Methode nicht verwenden, werden Sie der Variablen nicht zugewiesen.
#Die Variable bleibt auf ihrem Standardwert.
#matmul ist eine Matrixmultiplikation. Die Reihenfolge ist aufgrund der Form der Matrix von x bis W.
#Da eindimensionale Vektoren so wie sie sind addiert werden können, werden das Ergebnis und b so wie sie sind addiert und Softmax wird auf das Ergebnis angewendet.
#Als Ergebnis.
#Das Ergebnis von Softmax ist ein Vektor, da es das Ergebnis der Durchführung von Softmax für jedes Element des resultierenden Vektors ist.
y = tf.nn.softmax(tf.matmul(x, W) + b + a)
#Das richtige Etikett für y. Jede Markierung ist ein Vektor von Element 10.
y_ = tf.placeholder("float", [None, 10])
#Das Ergebnis der Multiplikation des logarithmischen Vektors für jedes Element von y und jede Zeile der Bezeichnung = Skalar wird für alle Zeilen addiert und das Vorzeichen des Ergebnisses bestimmt.
cross_entropy = -tf.reduce_sum(y_*tf.log(y))
# #Graphoptimierung durch Backpropagation-Algorithmus unter Verwendung der Gradientenabstiegsmethode. Hübsche Blackbox
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
#Initialisieren Sie alle Variablen. Sitzung ist eine kontextähnliche Sache zum tatsächlichen Ausführen eines TensorFlow-Programms.
init = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init)
writer = tf.train.SummaryWriter("./log", sess.graph_def)
#Es wiederholt den Vorgang des zufälligen Erfassens von 100 Elementen aus dem MNIST-Datensatz und des Ausführens von Schulungen für diese.
#Wo x und y_Es scheint, dass der Grund, warum der Wert nur in eingegeben wird, darin besteht, dass hier die unbekannte Nummer = Keine eingegeben wird und er nur betrieben werden kann, wenn dies bestätigt wird.
#Platzhalter dafür.
#Also hier jeder[100, 784]Wann[100, 10]の行列が設定されるこWannになる。
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})
#Das Lernergebnis y und das Label y_Innerhalb jedes der Vektoren von wird der Index verglichen, der den Maximalwert annimmt.
#1 steht auf einem Etikett = diese Zahl und ist gleichzeitig immer der Maximalwert.
#Im Vergleich dazu ist der höchste Wert im Trainingsergebnis = welcher Wert im Bild beurteilt wird, sodass die Indizes gleich sind.
#Richtet
correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
# true/falsch zu 1.0/0.Wirke auf 0 und mittle die hinzugefügten Ergebnisse
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
sess.run(accuracy, feed_dict={x:mnist.test.images, y_: mnist.test.labels}))
Deep
# coding: utf-8
import input_data
mnist = input_data.read_data_sets('MNIST_data', one_hot=True)
import tensorflow as tf
sess = tf.InteractiveSession()
x = tf.placeholder("float", [None, 784])
y_ = tf.placeholder("float", [None, 10])
#Erstellen Sie eine Gewichtsvariable mit der angegebenen Form.
def weight_variable(shape):
#stddev ist die Standardabweichung. gekürzt_normal ist der angegebene Durchschnitt (Standard 0)
#Und von der übergebenen Standardabweichung (Standard 1) ein Wert, der mehr als doppelt so hoch ist wie die Standardabweichung
#Abschneiden, um wieder zu bekommen
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)
#Erstellen Sie einen Rechenknoten für die zweidimensionale Faltung.
#Da es sich um eine zweidimensionale Faltung handelt, wird der Eingabewert durch Falten des Werts in der Einheit zweidimensional = Breite und Höhe erzeugt.
# tf.nn.conv2d ist ein vierdimensionaler Tensor irgendeiner Form von Eingabe und Filter.
#Machen Sie den Inhalt der Eingabe zu einem Patch in der vom Filter angegebenen Einheit für Breite und Höhe.
#Filtern Sie jedes Patch, um die Abmessungen zu verringern.
#Für Schritte müssen das erste und das letzte Element immer 1 sein. 2. und 3 ..
#Das Element wird tatsächlich verwendet, und das Intervall, in dem das zu patchende Fenster verschoben wird, wird angegeben.
#Hier ist Stride für beide 1, sodass er sich in horizontaler und vertikaler Richtung um 1 bewegt.
#Ein- und Ausgang haben also die gleiche Größe.
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1,1,1,1], padding='SAME')
#Poolen Sie den Maximalwert im 2x2-Bereich der Eingabewerte. Vielleicht.
#Sowohl die Kernelgröße als auch die Streifengröße sind 2x2, also nur die größte im 2x2-Bereich
#Bild zu verlassen. Wenn Sie es hier einfügen, wird die Größe des Bildes genau halbiert.
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1,2,2,1],
strides=[1,2,2,1], padding='SAME')
#Erste Schicht.
# weight_der Variablen[5,5,1,32]Das liegt daran, dass die ersten beiden Dimensionen die Größe des Patches beim Falten haben.
#Die dritte Dimension ist die Anzahl der Eingangskanäle und die vierte Dimension ist die Anzahl der Ausgangskanäle.
W_conv1 = weight_variable([5,5,1,32])
#Die Anzahl der Ausgangskanäle beträgt 32.
b_conv1 = bias_variable([32])
#Umformen x. Die Umformung wird in diese Form gebracht, da eine vierdimensionale Form übergeben wird.
#Der erste Wert wird abgeflacht, sodass alle Werte in x eindimensional erweitert werden.
#Die 2. und 3. Dimension sind die Breite bzw. Höhe des Bildes, und die 4. Dimension ist die Anzahl der Farbkanäle.
#Was für ein Wert ist x? Die abgeflachte Version des 28x28-Bildes ist in einem eindimensionalen Array enthalten.
#Es ist ein zweidimensionales Array. Konvertieren Sie den 784-Teil in 28x28 und schließlich ein Element darin.
#Es ist in Form von.
x_image = tf.reshape(x, [-1,28,28,1])
# weight,x_image,Wenden Sie eine Verzerrung auf die ReLU-Funktion an, um die Ergebnisse zu bündeln.
#Wenn dieser Vorgang ausgeführt wird, wird die Größe aller gepatchten Daten halbiert.
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
#Die zweite Schicht. Die Patchgröße bleibt gleich, aber die Anzahl der Eingangs- und Ausgangskanäle beträgt 32x bzw. 2x.
W_conv2 = weight_variable([5,5,32,64])
b_conv2 = weight_variable([64])
#Beachten Sie, dass das erste Argument von conv2d der Pool der ersten Ebene ist. Auf diese Weise die erste Schicht
#Aus jedem Wert im Faltungspool ergeben sich die entsprechenden Eingangs- und Ausgangskanäle
#Sie können das gepatchte Ergebnis erneut verbinden und patchen.
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
# h_Die Daten in Pool2 haben 28 Breiten bzw. 28 Höhen./2/2 =Es ist 7.
#Da es in der zweiten Schicht 64 Ausgangskanäle gibt, ist derjenige, in dem dieser Betrag ausgerichtet ist, die erste Dimension.
#Die zweite Dimension ist die Anzahl der Neuronen, die sie berechnen.
W_fc1 = weight_variable([7 * 7 * 64, 1024])
#Dies wird auch die gleiche Anzahl von Neuronen wie Weight erhalten
b_fc1 = bias_variable([1024])
# h_In der Phase von Pool2[-1,7,7,1]Da es in der Reihenfolge von jeweils 64 Stück angeordnet ist
#In ein zweidimensionales Array konvertieren, das sich überlappt
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
#Multiplizieren Sie nun die zweidimensionalen Matrizen und als Ergebnis[-1, 1024]Ich habe eine zweidimensionale Anordnung von erhalten. Das ist praktisch
#Ist das Ergebnis von.
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#Erstellen Sie eine Dropout-Ebene, um Überanpassungen zu reduzieren.
keep_prob = tf.placeholder("float")
#Standardmäßig die Wahrscheinlichkeit, dass jedes Element beibehalten oder unabhängig bleibt
#Zufällig abgebrochen.
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Ab hier sind die verwendeten Werte unterschiedlich, aber grundsätzlich gleich.
#Da es sich um Auslesungen in Schichten handelt, werden die tatsächlich verwendeten Werte aus dem Faltungsnetzwerk extrahiert.
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)
#Ab hier ist es fast das gleiche wie beim Einschichtmodell. Optimierer ist jedoch ADAM. Was ist ADAM?
#Ich bin mir nicht sicher.
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())
#20000 Mal und so weiter, aber dies ist ungefähr die Hälfte auf dem Weg abgebrochen
#Weil ich davon ausgehe.
#Wenn ich es ausführe, bin ich mir nicht sicher warum, aber ich sollte 8 Threads verwenden können, aber ich verwende nur 4 Threads
#Es war in einem Zustand. Vielleicht die Anzahl der CPUs (Echo/proc/Weil es vier in cpuinfo gibt)?
# Core i7-4790 @ 3.Ungefähr 40 Minuten bei 60 GHz(!)Es dauert ungefähr.
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}))
writer = tf.train.SummaryWriter("./log", sess.graph_def)
Ich habe Kommentare hinzugefügt, aber ich habe auch aufgenommen, was in meinem Verständnis und meiner Dokumentation steht. Bitte verzeihen Sie mir etwaige Fehler.
Anfänger und Tief (Faltungsversion) Obwohl die Anzahl der Schleifen unterschiedlich ist, ist der Geschwindigkeitsunterschied im Anfänger überwältigend schneller. Ich habe nichts extra gemacht.
Als ich es tatsächlich auf meinem Computer ausprobierte (Core i7-4790 bei 3,60 GHz, Speicher 16 GB), war das Ergebnis wie folgt. Übrigens wird die Anzahl der Parallelen in der CPU in TensorFlow wahrscheinlich durch die Anzahl der CPU-Kerne selbst bestimmt, und es scheint, dass Hyperthread-ähnliche Dinge nicht berücksichtigt werden.
Beginner :Ca. 5 Sekunden
Deep(CPU Only) :40 Minuten(!?)
Es war ein schockierendes Ergebnis. Ich wollte es unbedingt mit aktivierter GPU versuchen, aber die Version des CUDA SDK, die in mein Gentoo integriert ist, ist nicht ausreichend oder zu fortgeschritten. Daher muss ich anscheinend zunächst CUDA selbst installieren, sodass ich es vorerst belassen werde. Vielleicht ist die Deep-Seite nur dann praktisch, wenn sie mit der GPU oder in der verteilten Umgebung ausgeführt wird, über die Tensorflow spricht.
Es hat das! Ich habe die Szenerie gezeigt, die ich im Video knusprig verwendet habe, aber natürlich kann sie verwendet werden. Ich bin nicht der einzige, der fälschlicherweise dachte, es sei eine Desktop-Anwendung.
Bei der Verwendung von Tensorboard sind zwei Dinge zu beachten. Wenn Sie das Diagramm nur zur Laufzeit anzeigen möchten, benötigen Sie nichts wie das offizielle.
writer = tf.train.SummaryWriter("./log", sess.graph_def)
Einfach ok. Dadurch wird in . / Log eine Datei mit dem Namen events.out.tfevents erstellt. <Unix Sekunden-ähnlich>.
Tensorboard selbst ist eine Art von Anwendung, die den Server über die Befehlszeile startet und Zugriff erhält. Bei der Angabe dieses Verzeichnisses musste es sich jedoch um einen ** vollständigen Pfad ** handeln. Ich dachte das wäre eine Falle ...
Wenn Sie sich diese Dinge heutzutage ansehen, warum machen Sie sie dann? Ich war besorgt und schaute nach hinten.
Die Bibliothek, die ich benutze, ist
Ich habe zum ersten Mal Dagre gehört, aber es scheint eine Bibliothek zum Erstellen gerichteter Graphen zu sein.
Und was mich persönlich am meisten überraschte, war, dass ich mich daran erinnere, es viele Male bei der Arbeit gesehen zu haben.
<link rel="import" href="external/polymer/polymer.html">
Als ich die Linie sah. ** Polymer! ** Ich bin versehentlich hineingestürzt. Das ist Google ...
Und der Körper von Tensorboard ist noch überraschender,
/// <reference path="../../../typings/tsd.d.ts" />
Gibt es nicht eine Zeile, die sagt ...! Es war eine Kombination aus TypeScript + Polymer. Natürlich hat Polymer das Gefühl, sich scharf zu bewegen, selbst wenn Sie etwas Ähnliches wie React herstellen. Daher ist es möglicherweise für solche Anwendungen geeignet, die wahrscheinlich schwer sind.
Ich habe die Originalquelle nicht gesehen, aber ich denke, sie wurde durch Vulkanisieren von \ * .ts und \ * .html in Bezug auf die Zusammensetzung erstellt. Angesichts der Tatsache, dass es in dieser Größenordnung verwendet wird, denke ich, dass es in Ordnung ist, Polymer zu verwenden. Tensorboard funktionierte jedoch nur mit Chrome. Seien Sie also vorsichtig.
Dies ist das erste Mal, dass ich ein solches Framework berührt habe, aber ich denke, es ist ziemlich intuitiv. Ich denke, es ist am besten, Matrizen und Vektoren berechnen zu können, aber ich denke, es ist sehr schön für Leute, die mathematische Formeln programmieren müssen, um Addition, Subtraktion, Multiplikation und Division ganz intuitiv anzuwenden.
Persönlich war ich mit der schleimigen Einstellung des Tensorboards zufrieden. Ich befürchte, dass die Nachfrage nach Bildschirmen wieder steigen wird, wenn so etwas in Open Source herauskommt.
Lassen Sie uns ein wenig mehr Tutorial berühren und sehen, wie viel schneller es sein wird, wenn Sie tatsächlich eine GPU verwenden. Wenn ich Zeit habe, werde ich DMLT versuchen.
Recommended Posts