Mein vorheriger Artikel TensorFlow zum ersten Mal - lineare Regression als Einführung wurde unmittelbar nach der Veröffentlichung von TensorFlow geschrieben. Unter ihnen ist es ein Artikel, den Sie mögen können. Es ist erst ungefähr anderthalb Jahre her, deshalb wollte ich den Artikel im Hinblick auf das Versions-Upgrade von TensorFlow überarbeiten. Die Inhalte folgen den obigen Angaben und sind lineare Regression und logistische Regression.
(Die Programmierumgebung ist wie folgt. Stand 29. Mai 2017.)
In der vorherigen Ausgabe von "First Time ..." haben wir das Tutorial von "Theano", Newmu / Theano-Tutorials - GitHub, vorgestellt und anschließend auf TensorFlow portiert. https://github.com/Newmu/Theano-Tutorials
Neulich habe ich ein Tutorial von TensorFlow mit fast dem gleichen Inhalt auf GitHub gefunden, daher möchte ich es vorstellen. https://github.com/nlintz/TensorFlow-Tutorials
TensorFlow-Tutorials
Introduction to deep learning based on Google's TensorFlow framework. These tutorials are direct ports of Newmu's Theano Tutorials.
Ein kurzer Tutorial-Code wird veröffentlicht, damit Sie Ihr Verständnis von "TensorFlow" Schritt für Schritt vertiefen können. Neben dem Python-Code wird auch ein Jupyter-Notizbuch veröffentlicht. Auch wenn Sie kein Anfänger mehr sind, können Sie es wie ein Kochbuch verwenden, indem Sie das Repository auf Ihren PC herunterladen (klonen) und beim Codieren darauf verweisen. Wir empfehlen daher, dass Sie darauf verweisen. Auf 00_multiply.py (einfache Multiplikation) folgen 01_linear_regression.py (lineare Regression) und 02_logistic_regression.py (logistische Regression), daher möchte ich diesen Artikel entsprechend erläutern. Der Inhalt wurde jedoch leicht angepasst, da es langweilig ist, den Code erneut zu drucken.
Erstens aus der linearen Regression. Bereiten Sie nach dem Import der zugehörigen Module die zu verwendenden Daten vor. (Das Original bestand aus Testdaten ohne Abschnitt b, aber hier ist es in b enthalten (Bias = 3.).)
import tensorflow as tf
import numpy as np
trX = np.linspace(-1, 1, 101)
#Der ursprüngliche Code hat keinen Bias-Term, aber hier ist er voreingenommen(=3)Ein Modell zu sein, das beinhaltet
target_w = 2.
target_b = 3.
noise_gain = 0.33
trY = target_w * trX + target_b + np.random.randn(*trX.shape) * noise_gain
model () ist eine Funktion, die als Regressionsmodell verwendet wird. (Lineare Funktion mit Steigung w und Abschnitt b als Parameter.)
def model(X, w, b):
#Lineares Prädiktormodell
#Im Originalcode tf.muliply()Wird aber der Operator verwendet"*"OK.
# return tf.multiply(X, w) + b
return X * w + b
Bereiten Sie als Nächstes die erforderlichen Variablen vor.
# TensorFlow placeholders
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# TensorFlow Variables
w = tf.Variable(0.0, name="weights") # zero initialize
b = tf.Variable(0.0, name="bias") # zero initialize
x und y werden durch die eindeutige Terminologie "Platzhalter" erstellt. Da es sich um einen Platzhalter handelt, gibt es zum Zeitpunkt der Deklaration keinen tatsächlichen Wert, und der tatsächliche Wert wird in der nachfolgenden Programmverarbeitung zugewiesen. Andererseits sind die Anfangswerte von w und b, die gewöhnliche Tensorvariablen sind, Null.
Dann beschreiben wir die wichtige Beziehung zwischen Variablen, die als Graph bezeichnet werden.
y_model = model(X, w, b)
cost = tf.reduce_mean(tf.square(Y - y_model))
Kosten ist eine Kostenfunktion, die der Differenz zwischen Ihrem Modell und den tatsächlichen Daten entspricht. "tf.reduce_mean ()" ist eine Funktion zur Berechnung des Durchschnitts. Daher berechnet der obige Code MSE (= mittlerer quadratischer Fehler).
Definieren Sie als Nächstes die Optimizer-Spezifikation und ihre Methode zur Berechnung der Parametersuche.
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
Hier wird der Optimierer der Gradientenabstiegsmethode angegeben und die Lernrate von 0,01 als Argument angegeben.
Jetzt bin ich neugierig auf Optimizer, aber TensorFlow unterstützt derzeit Folgendes (Teil der folgenden Tabelle). http://www.tensorflow.org/api_docs/python/train.html#optimizers
| Optimizer name | Description (Referenzlink) |
|---|---|
| GradientDescentOptimizer | Gradientenabstiegsmethode https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95 |
| AdagradOptimizer | AdaGrad-Methode https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#AdaGrad |
| MomentumOptimizer | Impulsmethode https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#.E3.83.A2.E3.83.A1.E3.83.B3.E3.82.BF.E3.83.A0.E6.B3.95 |
| AdamOptimizer | Adam-Methode https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#Adam |
| RMSPropOptimizer | RMSProp-Methode https://ja.wikipedia.org/wiki/%E7%A2%BA%E7%8E%87%E7%9A%84%E5%8B%BE%E9%85%8D%E9%99%8D%E4%B8%8B%E6%B3%95#RMSProp |
Die Parameter, die eingestellt werden müssen, unterscheiden sich je nach Optimierer. Dieses Mal verwenden wir jedoch den grundlegenden GradientDescentOptimizer. (Die erforderliche Parameterlernrate wurde wie oben beschrieben eingestellt.)
Jetzt, da wir fast fertig sind, starten wir eine Sitzung, die den Hauptberechnungsteil zeigt.
# Launch the graph in a session
with tf.Session() as sess:
# you need to initialize variables (in this case just variable W)
tf.global_variables_initializer().run()
for i in range(100):
for (x, y) in zip(trX, trY):
sess.run(train_op, feed_dict={X: x, Y: y})
final_w, final_b = sess.run([w, b])
Unmittelbar nach Beginn der Sitzung werden die Variablen (Variablen) initialisiert.
(Hinweis. In der vorherigen Version habe ich geschrieben, dass "Variablen vor dem Starten der Sitzung initialisiert werden müssen", dies ist jedoch falsch. Im vorherigen Code wurde die Initialisierungsverarbeitung (init op) vor der Sitzung ausgeführt. ) Wird definiert und nach dem Starten der Sitzung von sess.run (init) ausgeführt. Dieses Mal wird der Initialisierungsprozess definiert und run () wird unmittelbar nach der Sitzung ausgeführt.)
Wenn Sie vorerst "Initialisierung von Variablen" aktivieren,
Es scheint verschiedene Möglichkeiten zu geben, ein Programm zum Ausführen von Sessoin zu schreiben. Wie oben erwähnt, wird der Sitzungsbegrenzer durch Einfügen in die Anweisung "with" verdeutlicht und beim Beenden von "with" automatisch geöffnet. Die Sitzung ist geschlossen (), was praktisch ist.
Zum einen ist es schwierig, Zugdaten in TensorFlow anzugeben. Das Geben von Daten (Datenzufuhr) ist der Teil, in dem sich die Verarbeitung ändert, je nachdem, wie mit dem Lernen fortgefahren wird. Wie in der obigen Liste gezeigt, wird jedoch "feed_dict" verwendet. Denken Sie also daran.
Mit dem Obigen werden die Regressionsparameter berechnet. (Hinweis: In der aktuellen Version von tensorflow gibt cpu_feature_guard.cc je nach Umgebung eine Warnung aus, die Sie jedoch ignorieren können. Sie können die Warnung mithilfe der Umgebungsvariablen der Shell stoppen.)
$ python 01_linear_regression.py
predicted model: y = [ 2.045] * x + [ 3.001]
target model : y = [ 2.000] * x + [ 3.000]
Es ist ersichtlich, dass die Regressionsparameter des vorhergesagten Modells ungefähre Werte des Zielmodells sind.
Das Obige wird zusammengefasst und das Programm erneut veröffentlicht.
import tensorflow as tf
import numpy as np
trX = np.linspace(-1, 1, 101)
#Der ursprüngliche Code hat keinen Bias-Term, aber hier ist er voreingenommen(=3)Ein Modell zu sein, das beinhaltet
target_w = 2.
target_b = 3.
noise_gain = 0.33
trY = target_w * trX + target_b + np.random.randn(*trX.shape) * noise_gain
def model(X, w, b):
#Lineares Prädiktormodell
#Im Originalcode tf.muliply()Wird aber der Operator verwendet"*"OK.
# return tf.multiply(X, w) + b
return X * w + b
# TensorFlow placeholders
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)
# TensorFlow Variables
w = tf.Variable(0.0, name="weights") # zero initialize
b = tf.Variable(0.0, name="bias") # zero initialize
y_model = model(X, w, b)
#Definieren Sie den quadratischen Fehler, da es sich um eine Kostenfunktion und ein Regressionsmodell handelt
cost = tf.reduce_mean(tf.square(Y - y_model))
#Optimierungsoperator(Optimierer)einstellen.Lernrate= 0.01
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
# Launch the graph in a session
with tf.Session() as sess:
# you need to initialize variables (in this case just variable W)
tf.global_variables_initializer().run()
for i in range(100):
for (x, y) in zip(trX, trY):
sess.run(train_op, feed_dict={X: x, Y: y})
final_w, final_b = sess.run([w, b])
# (w, b) = (2, 3)Wird eine Annäherung an.
print('predicted model: y = [{:>8.3f}] * x + [{:>8.3f}]'.format(
final_w, final_b))
print('target model : y = [{:>8.3f}] * x + [{:>8.3f}]'.format(
target_w, target_b))
Der ursprüngliche logistische Regressionscode (https://github.com/nlintz/TensorFlow-Tutorials) befasst sich mit MNIST, hier jedoch mit dem leichten handgeschriebenen Zeichendatensatz "Ziffern", der mit scikit-learn geliefert wird.
Definieren Sie zunächst eine Unterstützungsfunktion für die Gewichtungsinitialisierung und ein Modell.
#Unterstützungsfunktion für die Initialisierung von Gewichten
def init_weights(shape):
return tf.Variable(tf.random_normal(shape, stddev=0.01))
#Im ursprünglichen Code ist die Abweichung nicht im Modell enthalten, aber dieser Code ist enthalten.
def model(X, w, b):
return tf.matmul(X, w) + b
Bereiten Sie "Ziffern" -Daten vor.
#Ziffern ist Scikit-Handgeschriebener Zeichendatensatz, erstellt von learn. Pixel: 8 x 8
def load_data():
digits = load_digits()
digits_images = digits.data / 16. # scaling to (0 .. 1)
digits_target_ = []
for i in range(len(digits.target)):
target_one = np.zeros([10], dtype=np.float32)
target_one[digits.target[i]] = 1.
digits_target_.append(target_one)
digits_target_onehot = np.asarray(digits_target_)
return digits_images, digits_target_onehot
X, Y = load_data()
# train /In Testsätze teilen
trX, teX, trY, teY = train_test_split(X, Y, test_size=0.2)
Folgen Sie danach der linearen Regression im vorherigen Abschnitt, um das Diagramm zu definieren.
# TensorFlow placeholders
X_ph = tf.placeholder(tf.float32, [None, 64])
Y_ph = tf.placeholder(tf.float32, [None, 10])
#Im ursprünglichen Code ist die Abweichung nicht im Modell enthalten, sie ist jedoch in diesem Code enthalten.
w = init_weights([64, 10])
b = tf.zeros([10])
py_x = model(X_ph, w, b)
#Kostenfunktion, Optimierer, Prognose
cost = tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y_ph)
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
predict_op = tf.argmax(py_x, 1)
Bei der linearen Regression wird die durch MSE (Mean Square Error) definierte Kostenfunktion in der logistischen Regression durch die Kreuzentropie (Softmax-Kreuzentropie) ersetzt. "Tf.nn.softmax_cross_entropy_with_logits ()" in der zweiten Hälfte der obigen Liste ist eine Funktion, die die Kreuzentorpie in der Klassifizierung mehrerer Klassen berechnet. (Diese Funktion erfordert Schlüsselwörter für "logits =" und "labels =")
Die Initialisierung der Variablen und die Vorgehensweise bei der Sitzung sind dieselben wie im vorherigen Code. Der Code wird wieder zusammen gebucht.
import tensorflow as tf
import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
#Unterstützungsfunktion für die Initialisierung von Gewichten
def init_weights(shape):
return tf.Variable(tf.random_normal(shape, stddev=0.01))
#Im ursprünglichen Code ist die Abweichung nicht im Modell enthalten, aber dieser Code ist enthalten.
def model(X, w, b):
return tf.matmul(X, w) + b
#Ziffern ist Scikit-Handgeschriebener Zeichendatensatz, erstellt von learn. Pixel: 8 x 8
def load_data():
digits = load_digits()
digits_images = digits.data / 16. # scaling to (0 .. 1)
digits_target_ = []
for i in range(len(digits.target)):
target_one = np.zeros([10], dtype=np.float32)
target_one[digits.target[i]] = 1.
digits_target_.append(target_one)
digits_target_onehot = np.asarray(digits_target_)
return digits_images, digits_target_onehot
X, Y = load_data()
# train /In Testsätze teilen
trX, teX, trY, teY = train_test_split(X, Y, test_size=0.2)
# TensorFlow placeholders
X_ph = tf.placeholder(tf.float32, [None, 64])
Y_ph = tf.placeholder(tf.float32, [None, 10])
#Im ursprünglichen Code ist die Abweichung nicht im Modell enthalten, sie ist jedoch in diesem Code enthalten.
w = init_weights([64, 10])
b = tf.zeros([10])
py_x = model(X_ph, w, b)
#Kostenfunktion, Optimierer, Prognose
cost = tf.nn.softmax_cross_entropy_with_logits(logits=py_x, labels=Y_ph)
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(cost)
predict_op = tf.argmax(py_x, 1)
# TensorFlow session
with tf.Session() as sess:
# you need to initialize all variables
tf.global_variables_initializer().run()
for i in range(100):
for start, end in zip(range(0, len(trX), 128), range(128, len(trX)+1, 128)):
train_fd = {X_ph: trX[start:end], Y_ph: trY[start:end]}
sess.run(train_op, feed_dict=train_fd)
#Richtige Antwortrate auf Numpy-Ebene(accuracy)Berechnen und ausgeben
if i % 10 == 0:
print('step {:>3d}: accuracy = {:>8.3f}'.format(
i, np.mean(np.argmax(teY, axis=1) ==
sess.run(predict_op, feed_dict={X_ph: teX}))))
TensorFlow kann auf verschiedene Arten geschrieben werden, von relativ primitiven APIs (sowie anderen Tools) bis zu APIs auf hoher Ebene, einschließlich der Keras-API. Es mag unangenehm sein, aber für Anfänger ist es besser, zuerst die primitive Verwendung wie oben beschrieben zu lernen und dann zur API auf hoher Ebene überzugehen, wenn der Inhalt bis zu einem gewissen Grad verstanden ist.
Vor kurzem habe ich angefangen, "PyTorch" mit einem Schwerpunkt auf Interesse zu studieren, aber selbst wenn ich Kenntnisse über TensorFlow habe, gibt es viele Probleme. Wir glauben, dass Tutorial-Code wie einfache "lineare Regression" und "logistische Regression" für einführende Studien in jeder Bibliothek nützlich sein sollte.
(Weitere Informationen zu TensorFlow finden Sie unter https://github.com/nlintz/TensorFlow-Tutorials!)
Recommended Posts