Auf einen Blick: TensorFlow ist eine Open-Source-Machine-Learning-Bibliothek von Google, die sich auf logistische Regression und prädiktive Modellierung konzentriert. Dieser Leitfaden erklärt seine Kernkonzepte, Installation und Implementierung anhand praktischer Beispiele.
- TensorFlow verwendet Tensoren, das sind mehrdimensionale Arrays.
- Ein Beispiel zeigt, wie man die Bestehensquoten der Schüler anhand von Lernstunden vorhersagt.
Hier stellen wir TensorFlow vor, eine Open-Source-Machine-Learning-Bibliothek, die von Google entwickelt wurde. Wir erklären, was sie bewirkt, und zeigen, wie man sie für logistische Regressionen nutzen kann.
TensorFlow hat viele Anwendungen im maschinellen Lernen, darunter neuronale Netze. Eine Anwendung neuronaler Netze ist die Handschriftanalyse. Eine weitere ist die Gesichtserkennung. TensorFLow ist so konzipiert, dass solche Probleme unbegrenzt skaliert werden können, da die Knoten im Graphen über ein verteiltes Netzwerk ausgeführt werden können. Google verwendet TensorFlow in einigen seiner Produktionsanwendungen.
Ein interessanter Aspekt von TensorFlow ist, dass nicht nur die Logik die CPU eines Rechners nutzt, sondern auch die GPU oder die grafische Prozessor-Einheit. Das sorgt für mehr Leistung pro Maschine, da GPUs typischerweise viel Leistung haben, da das Versorgen des Computerbildschirms Geschwindigkeit erfordert.
[Helix-Video]
Installation und Grundkonzepte
Um diesem Tutorial zu folgen, installiere zuerst TF mit den hier angegebenen Anweisungen.
Die Basiseinheit in TensorFlow ist der Tensor. Ein Tensor ist ein Array beliebig zahlreicher Dimensionen. Zum Beispiel:
[1] ist ein eindimensionales Array
[[1,1]] ist ein zweidimensionales Array
Um zu starten, starte zuerst Python und importiere TensorFlow:
import tensorflow as tf
Du kannst Werte direkt zuweisen oder einen Platzhalter erstellen, bei dem du den Wert später zuweist. Zum Beispiel kann ein einzelner Wert geschrieben werden:
x = tf.constant(3.0, dtype=tf.float32)
Wobei x eine unveränderliche Konstante ist (das heißt, du kannst sie nicht ändern).
Aber der Tensor hat keinen Wert, bis du eine Sitzung startest und sie ausführst :
Oder Sie können schreiben:
import tensorflow as tf
sess = tf.Session()
x = tf.constant(3.0, dtype=tf.float32)
print(sess.run([x]))
Outputs:
[3.0]
Oder Sie können schreiben:
import tensorflow as tf
sess = tf.Session()
y = tf.Variable([3.0], dtype=tf.float32)
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run([y]))
Outputs:
[array([ 3.], dtype=float32)]
Im obigen Beispiel haben die Variable(n) keinen Wert, bis man tf.global_variables_initializer() ausführt.
Du kannst Tensoren addieren und andere Mathematik machen, wie zum Beispiel:
x = tf.constant([3,3], dtype=tf.float32)
y = tf.constant([4,4], dtype=tf.float32)
print (x + y)
print(sess.run([x+y]))
outputs:
Tensor("add_4:0", shape=(2,), dtype=float32)
[array([ 11., 11.], dtype=float32)]
Wie du siehst, haben die Werte von x und y keinen Wert, bis du Ausführen aufrufst.
Hier ist ein weiteres Beispiel. Dies ist der Graph einer Geraden f(x)=mx + b, wobei m die Steigung und b der y-Intercept ist.
m = tf.Variable([2], dtype=tf.float32)
b = tf.Variable([3], dtype=tf.float32)
x = tf.placeholder(tf.float32)
y = m * x + b
Man kann ein Array von n Werten daran übergeben und diese Funktion n Mal ausführen. Hier verwenden wir [1, 2, 3, 4]:
init = tf.global_variables_initializer()
sess.run(init)
print(sess.run(y, {x: [1, 2, 3, 4]}))
Outputs:
[ 5. 7. 9. 11.]
Hintergrund
Lineare Regression mit tf.estimator
Für Hintergrundinformationen zur logistischen Regression und zur Interpretation der Ergebnisse können Sie dieses Dokument von WikiPedia lesen. Wir beziehen unsere Testdaten auch aus diesem Dokument. Das Ziel ist es, die Wahrscheinlichkeit vorherzusagen, dass ein Schüler einen Test besteht, basierend auf der Anzahl der Lernstunden.
Kopiere und füge den untenstehenden Code in den Python-Interpreter ein, während wir es erklären.
Nachdem ich TensorFlow installiert habe, starte jetzt Python.
Zuerst importieren wir Pandas, da dies der einfachste Weg ist, mit Spaltendaten zu arbeiten. Die Stunden sind gleitende Zahlen, wie x.xx. Wir multiplizieren sie mit 100 und wandeln sie in eine ganze Zahl um, da die TensorFlow-Funktionen, die wir für die logistische Regression verwendet haben, entweder Strings oder ganze Zahlen benötigen.
import pandas
hours = [0.50,0.75,1.00,1.25,1.50,1.75,1.75,2.00,2.25,2.50,2.75,3.00,3.25,3.50,4.00,4.25,4.50,4.75,5.00,5.50]
passx = [0,0,0,0,0,0,1,0,1,0,1,0,1,0,1,1,1,1,1,1]
df = pandas.DataFrame(passx)
df['hours'] = hours
df.columns = ['pass', 'hours']
h = df['hours'].apply(lambda x: x * 100).astype(int)
df['hours']=h
print(df)
outputs:
print(df)
hours pass
0 0.50 0
1 0.75 0
2 1.00 0
3 1.25 0
...
Wir erstellen eine Funktion input_fn die wir in das untenstehende LinearClassifier-Modell übergeben können. Diese Funktion gibt einen Datenrahmen mit der tf.estimator.inputs.pandas_input_fn-Methode zurück.
def input_fn(df):
labels = df["pass"]
return tf.estimator.inputs.pandas_input_fn(
x=df,
y=labels,
batch_size=100,
num_epochs=10,
shuffle=False,
num_threads=5)
TensorFlow schreibt seine Arbeitsdaten auf die Festplatte, also geben wir ihm einen Ort dafür. Und wir müssen ein NumericColumn-Objekt erstellen, da unsere unabhängige Variable stetig und nicht kategorisch ist. Dann erstellen wir das LinearClassifier-Modell .
import tensorflow as tf
import tempfile
model_dir = tempfile.mkdtemp()
hours = tf.feature_column.numeric_column("hours")
base_columns = [hours]
m = tf.estimator.LinearClassifier(model_dir=model_dir, feature_columns=base_columns)
Jetzt betreiben wir die Zugmethode .
m.train(input_fn(df),steps=None)
Outputs:
INFO:tensorflow:Create CheckpointSaverHook.
INFO:tensorflow:Saving checkpoints for 1 into /tmp/tmpS8OD2H/model.ckpt.
INFO:tensorflow:loss = 69.3147, step = 1
INFO:tensorflow:Saving checkpoints for 10 into /tmp/tmpS8OD2H/model.ckpt.
INFO:tensorflow:Loss for final step: 54.1885.
Verwenden Sie dieselben Daten für den Testdatensatz wie für den Trainingssatz. Im echten Leben würden Sie sie in zwei Teile aufteilen. Aber wir haben hier sehr wenige Daten.
results = m.evaluate(input_fn(df),steps=None)
Outputs:
INFO:tensorflow:Starting evaluation at 2017-11-02-14:20:16
INFO:tensorflow:Restoring parameters from /tmp/tmpS8OD2H/model.ckpt-10
INFO:tensorflow:Finished evaluation at 2017-11-02-14:20:16
INFO:tensorflow:Saving dict for global step 10: accuracy = 0.75, accuracy_baseline = 0.5, auc = 0.895, auc_precision_recall = 0.907308, average_loss = 0.535767, global_step = 10, label/mean = 0.5, loss = 53.5767, prediction/mean = 0.585759
Hier drucken wir die gleichen Ergebnisse wie oben aus, aber in einer leichter lesbaren Form.
print("model directory = %s" % model_dir)
for key in sorted(results):
print("%s: %s" % (key, results[key]))
Outputs:
accuracy: 0.75
accuracy_baseline: 0.5
auc: 0.895
auc_precision_recall: 0.907308
average_loss: 0.535767
global_step: 10
label/mean: 0.5
loss: 53.5767
prediction/mean: 0.585759
Die Genauigkeit könnte verbessert werden. Man könnte einen größeren Datensatz erstellen und die Eingabedaten in einen Trainings- und Testdatensatz aufteilen. Man könnte auch num_epochs und andere Werte anpassen.
ML mit TensorFlow & Keras Guide
- TensorFlow vs. PyTorch: Die Wahl Ihres ML-Frameworks
- Einführung in TensorFlow und logistische Regression
- Verwendung von TensorFlow zur Erstellung eines neuronalen Netzwerks (mit Beispielen)
- Verwendung des TensorFlow-Neuralnetzwerks für maschinelle Lernvorhersagen mit TripAdvisor-Daten
- Wie die Keras-Maschinensprachen-API TensorFlow erleichtert
- Wie man Keras verwendet, um Klassifikationsprobleme mit einem neuronalen Netzwerk zu lösen
- Deep Learning Schritt-für-Schritt-Neuralnetz-Tutorial mit Keras
- Google Cloud TPUs für ML-Beschleunigung
Diese Beiträge sind meine eigenen und spiegeln nicht unbedingt die Position, Strategien oder Meinung von BMC wider.