Tutorial zur linearen Regression mit TensorFlow [Beispiele]
Evelyn Clarke
Was ist lineare Regression?
Lineare Regression ist ein Ansatz in der Statistik zur Modellierung von Beziehungen zwischen zwei Variablen. Diese Modellierung erfolgt zwischen einer skalaren Antwort und einer oder mehreren erklรคrenden Variablen. Die Beziehung mit einer erklรคrenden Variablen wird als einfache lineare Regression bezeichnet, und fรผr mehr als eine erklรคrende Variable wird sie als multiple lineare Regression bezeichnet.
TensorFlow bietet Tools, mit denen Sie die vollstรคndige Kontrolle รผber die Berechnungen haben. Dies geschieht mit der Low-Level-API. Darรผber hinaus ist TensorFlow mit einer Vielzahl von APIs ausgestattet, um viele Aufgaben auszufรผhren Maschinelles Lernen Algorithmen. Dies ist die High-Level-API. TensorFlow nennt sie Schรคtzer
- Low-Level-API: Erstellen Sie die Architektur und optimieren Sie das Modell von Grund auf. Fรผr einen Anfรคnger ist das kompliziert
- High-Level-API: Definieren Sie den Algorithmus. Es ist benutzerfreundlich. TensorFlow bietet eine Toolbox namens Schรคtzer zu konstruieren, zu trainieren, auszuwerten und eine Vorhersage zu treffen.
In diesem Tutorial verwenden Sie die Nur Schรคtzer. Die Berechnungen sind schneller und einfacher umzusetzen. Im ersten Teil des Tutorials wird erlรคutert, wie Sie mit dem Gradientenabstiegsoptimierer eine lineare Regression in TensorFlow trainieren. In einem zweiten Teil verwenden Sie den Boston-Datensatz, um den Preis eines Hauses mithilfe des TensorFlow-Schรคtzers vorherzusagen.
Laden Sie Boston DataSet herunter
So trainieren Sie ein lineares Regressionsmodell
Bevor wir mit dem Training des Modells beginnen, schauen wir uns an, was eine lineare Regression ist.
Stellen Sie sich vor, Sie haben zwei Variablen, x und y, und Ihre Aufgabe besteht darin, den Wert vorherzusagen, den Sie kennen. Wenn Sie die Daten grafisch darstellen, kรถnnen Sie eine positive Beziehung zwischen Ihrer unabhรคngigen Variable x und Ihrer abhรคngigen Variable y erkennen.
Sie kรถnnen beobachten, dass bei x=1 y ungefรคhr gleich 6 ist und bei x=2 y bei etwa 8.5 liegt.
Dies ist keine sehr genaue Methode und fehleranfรคllig, insbesondere bei einem Datensatz mit Hunderttausenden Punkten.
Eine lineare Regression wird mit einer Gleichung ausgewertet. Die Variable y wird durch eine oder mehrere Kovariaten erklรคrt. In Ihrem Beispiel gibt es nur eine abhรคngige Variable. Wenn Sie diese Gleichung schreiben mรผssen, lautet sie:
Mit:
ist die Voreingenommenheit. dh wenn x=0, y=
ist das Gewicht, das x zugeordnet ist
ist das Residuum oder der Fehler des Modells. Es beinhaltet, was das Modell nicht aus den Daten lernen kann
Stellen Sie sich vor, Sie passen das Modell an und finden die folgende Lรถsung fรผr:
- = 3.8
- = 2.78
Sie kรถnnen diese Zahlen in die Gleichung einsetzen und sie lautet:
y= 3.8 + 2.78x
Sie haben jetzt eine bessere Mรถglichkeit, die Werte fรผr y zu ermitteln. Das heiรt, Sie kรถnnen x durch einen beliebigen Wert ersetzen, den Sie fรผr y vorhersagen mรถchten. Im Bild unten haben wir x in der Gleichung durch alle Werte im Datensatz ersetzt und das Ergebnis grafisch dargestellt.
Die rote Linie stellt den angepassten Wert dar, also die Werte von y fรผr jeden Wert von x. Sie mรผssen den Wert von x nicht sehen, um y vorherzusagen. Fรผr jedes x gibt es einen Wert, der zur roten Linie gehรถrt. Sie kรถnnen auch Werte fรผr x vorhersagen, die grรถรer als 2 sind!
Wenn Sie die lineare Regression auf weitere Kovariaten erweitern mรถchten, kรถnnen Sie dem Modell weitere Variablen hinzufรผgen. Der Unterschied zwischen der herkรถmmlichen Analyse und der linearen Regression besteht darin, dass bei der linearen Regression untersucht wird, wie y fรผr jede Variable x unabhรคngig betrachtet reagiert.
Sehen wir uns ein Beispiel an. Stellen Sie sich vor, Sie mรถchten den Umsatz einer Eisdiele vorhersagen. Der Datensatz enthรคlt verschiedene Informationen wie das Wetter (d. h. regnerisch, sonnig, bewรถlkt), Kundeninformationen (d. h. Gehalt, Geschlecht, Familienstand).
Bei der traditionellen Analyse wird versucht, den Verkauf vorherzusagen, indem man beispielsweise den Durchschnitt fรผr jede Variable berechnet und versucht, den Verkauf fรผr verschiedene Szenarien zu schรคtzen. Dies fรผhrt zu schlechten Vorhersagen und beschrรคnkt die Analyse auf das gewรคhlte Szenario.
Wenn Sie die lineare Regression verwenden, kรถnnen Sie diese Gleichung schreiben:
Der Algorithmus findet die beste Lรถsung fรผr die Gewichte; Dies bedeutet, dass versucht wird, die Kosten (die Differenz zwischen der angepassten Linie und den Datenpunkten) zu minimieren.
Wie der Algorithmus funktioniert
Der Algorithmus wรคhlt fรผr jeden eine Zufallszahl 
und 
und ersetzen Sie den Wert von x, um den vorhergesagten Wert von y zu erhalten. Wenn der Datensatz 100 Beobachtungen enthรคlt, berechnet der Algorithmus 100 vorhergesagte Werte.
Wir kรถnnen den Fehler berechnen, notiert 
des Modells, das ist die Differenz zwischen dem vorhergesagten Wert und dem tatsรคchlichen Wert. Ein positiver Fehler bedeutet, dass das Modell die Vorhersage von y unterschรคtzt, und ein negativer Fehler bedeutet, dass das Modell die Vorhersage von y รผberschรคtzt.
Ihr Ziel ist es, das Fehlerquadrat zu minimieren. Der Algorithmus berechnet den Mittelwert des quadratischen Fehlers. Dieser Schritt wird als Minimierung des Fehlers bezeichnet. Fรผr die lineare Regression gilt die Mittlerer quadratischer Fehler, auch MSE genannt. Mathematisch ist es:
Kennzahlen:
sind die Gewichte so 
bezieht sich auf den vorhergesagten Wert- y sind die tatsรคchlichen Werte
- m ist die Anzahl der Beobachtungen
bezieht sich auf den vorhergesagten WertBeachten Sie, dass 
bedeutet, dass die Transponierte der Matrizen verwendet wird. Der 
ist die mathematische Schreibweise des Mittelwerts.
Das Ziel ist es, das Beste zu finden 
die die MSE minimieren
Wenn der durchschnittliche Fehler groร ist, bedeutet dies, dass das Modell eine schlechte Leistung erbringt und die Gewichte nicht richtig gewรคhlt sind. Um die Gewichte zu korrigieren, mรผssen Sie einen Optimierer verwenden. Der traditionelle Optimierer heiรt Gradientenabstieg.
Der Gradientenabstieg nimmt die Ableitung und verringert oder erhรถht das Gewicht. Wenn die Ableitung positiv ist, wird das Gewicht verringert. Wenn die Ableitung negativ ist, erhรถht sich das Gewicht. Das Modell aktualisiert die Gewichte und berechnet den Fehler neu. Dieser Vorgang wird wiederholt, bis sich der Fehler nicht mehr รคndert. Jeder Prozess wird als ein bezeichnet Iteration. Auรerdem werden die Gradienten mit einer Lernrate multipliziert. Es gibt die Geschwindigkeit des Lernens an.
Wenn die Lernrate zu gering ist, dauert es sehr lange, bis der Algorithmus konvergiert (dh es sind viele Iterationen erforderlich). Wenn die Lernrate zu hoch ist, konvergiert der Algorithmus mรถglicherweise nie.
Auf dem Bild oben kรถnnen Sie sehen, dass das Modell den Vorgang etwa 20 Mal wiederholt, bevor es einen stabilen Wert fรผr die Gewichte findet und somit den niedrigsten Fehler erreicht.
Beachten Sie, dass, ist der Fehler nicht gleich Null, sondern stabilisiert sich bei etwa 5. Das bedeutet, dass das Modell einen typischen Fehler von 5 macht. Wenn Sie den Fehler reduzieren mรถchten, mรผssen Sie dem Modell weitere Informationen hinzufรผgen, z. B. mehr Variablen, oder andere Schรคtzer verwenden .
Sie erinnern sich an die erste Gleichung
Die Endgewichte betragen 3.8 und 2.78. Das Video unten zeigt Ihnen, wie der Gradientenabstieg die Verlustfunktion optimiert, um diese Gewichte zu finden
So trainieren Sie eine lineare Regression mit TensorFlow
Da Sie nun besser verstehen, was hinter der Haube passiert, kรถnnen Sie die von TensorFlow bereitgestellte Schรคtzer-API verwenden, um Ihre erste lineare Regression mit TensorFlow zu trainieren.
Sie verwenden den Boston-Datensatz, der die folgenden Variablen enthรคlt
| kriminell | Pro-Kopf-Kriminalitรคtsrate nach Stadt |
|---|---|
| zn | Anteil des Wohngrundstรผcks, das fรผr Grundstรผcke รผber 25,000 Quadratfuร ausgewiesen ist. |
| Indus | Anteil der Nicht-Einzelhandelsflรคchen pro Stadt. |
| Nox | Stickoxidkonzentration |
| rm | durchschnittliche Zimmeranzahl pro Wohnung |
| Alter | Anteil der vor 1940 gebauten Eigentumswohnungen |
| dis | gewichtete Entfernungen zu fรผnf Bostoner Arbeitsvermittlungszentren |
| Steuer | Vollwert-Grundsteuersatz pro 10,000 Dollar |
| ptratio | Schรผler-Lehrer-Verhรคltnis nach Stadt |
| mit V | Medianwert der Eigentumswohnungen in Tausend Dollar |
Sie erstellen drei verschiedene Datensรคtze:
| Datensatz | Ziel | gestalten |
|---|---|---|
| Training | Trainieren Sie das Modell und ermitteln Sie die Gewichte | 400, 10 |
| Evaluierung | Bewerten Sie die Leistung des Modells anhand unsichtbarer Daten | 100, 10 |
| Vorhersagen | Verwenden Sie das Modell, um den Hauswert anhand neuer Daten vorherzusagen | 6, 10 |
Das Ziel besteht darin, die Merkmale des Datensatzes zu nutzen, um den Wert des Hauses vorherzusagen.
Im zweiten Teil des Tutorials erfahren Sie, wie Sie TensorFlow auf drei verschiedene Arten zum Importieren der Daten verwenden:
- Mit Pandas
- Mit Numpy
- Nur TF
Beachten Sie, dass alle Optionen verfรผgbar sind die gleichen Ergebnisse liefern.
Sie erfahren, wie Sie mit der High-Level-API ein lineares TensorFlow-Regressionsmodell erstellen, trainieren und auswerten. Wenn Sie die Low-Level-API verwendeten, mussten Sie Folgendes manuell definieren:
- Verlustfunktion
- Optimieren: Gefรคlleabstieg
- Matrizenmultiplikation
- Graph und Tensor
Dies ist fรผr Anfรคnger mรผhsam und komplizierter.
Pandas
Sie mรผssen die erforderlichen Bibliotheken importieren, um das Modell zu trainieren.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Schritt 1) Importieren Sie die Daten mit Panda.
Sie definieren die Spaltennamen und speichern sie in COLUMNS. Sie kรถnnen pd.read_csv() verwenden, um die Daten zu importieren.
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]
training_set = pd.read_csv(โE:/boston_train.csvโ, skiinitialspace=True,skiprows=1, Names=COLUMNS)
test_set = pd.read_csv(โE:/boston_test.csvโ, skipinitialspace=True,skiprows=1, Names=COLUMNS)
Prediction_set = pd.read_csv(โE:/boston_predict.csvโ, skipinitialspace=True,skiprows=1, Names=COLUMNS)
Sie kรถnnen die Form der Daten drucken.
print(training_set.shape, test_set.shape, prediction_set.shape)
Ausgang
(400, 10) (100, 10) (6, 10)
Beachten Sie, dass die Bezeichnung, also Ihr y, im Datensatz enthalten ist. Sie mรผssen also zwei weitere Listen definieren. Eines enthรคlt nur die Funktionen und eines nur den Namen des Labels. Diese beiden Listen verraten Ihrem Schรคtzer, welche Features im Datensatz vorhanden sind und welcher Spaltenname die Bezeichnung ist
Dies geschieht mit dem folgenden Code.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Schritt 2) Konvertieren Sie die Daten
Sie mรผssen die numerischen Variablen in das richtige Format konvertieren. Tensorflow bietet eine Methode zum Konvertieren kontinuierlicher Variablen: tf.feature_column.numeric_column().
Im vorherigen Schritt definieren Sie eine Liste mit einem Feature, das Sie in das Modell aufnehmen mรถchten. Jetzt kรถnnen Sie diese Liste verwenden, um sie in numerische Daten umzuwandeln. Wenn Sie Features in Ihrem Modell ausschlieรen mรถchten, kรถnnen Sie eine oder mehrere Variablen in der Liste FEATURES lรถschen, bevor Sie die feature_cols erstellen
Beachten Sie, dass Sie verwenden Python Listenverstรคndnis mit der Liste FEATURES, um eine neue Liste mit dem Namen feature_cols zu erstellen. Damit kรถnnen Sie das neunmalige Schreiben von tf.feature_column.numeric_column() vermeiden. Ein Listenverstรคndnis ist eine schnellere und sauberere Mรถglichkeit, neue Listen zu erstellen
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Schritt 3) Definieren Sie den Schรคtzer
In diesem Schritt mรผssen Sie den Schรคtzer definieren. Tensorflow bietet derzeit 6 vorgefertigte Schรคtzer, darunter 3 fรผr Klassifizierungsaufgaben und 3 fรผr TensorFlow-Regressionsaufgaben:
- Regressor
- DNNRegressor
- LinearRegressor
- DNNLineaCombinedRegressor
- klassifizieren
- DNNClassifier
- LinearClassifier
- DNNLineaCombinedClassifier
In diesem Tutorial verwenden Sie den linearen Regressor. Um auf diese Funktion zuzugreifen, mรผssen Sie tf.estimator verwenden.
Die Funktion benรถtigt zwei Argumente:
- feature_columns: Enthรคlt die Variablen, die in das Modell aufgenommen werden sollen
- model_dir: Pfad zum Speichern des Diagramms, zum Speichern der Modellparameter usw
Tensorflow erstellt automatisch eine Datei mit dem Namen train in Ihrem Arbeitsverzeichnis. Sie mรผssen diesen Pfad verwenden, um auf das Tensorboard zuzugreifen, wie im folgenden TensorFlow-Regressionsbeispiel gezeigt.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_cols,
model_dir="train")
Ausgang
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Der knifflige Teil bei TensorFlow ist die Art und Weise, wie das Modell gefรผttert wird. Tensorflow ist fรผr die Arbeit mit parallelem Computing und sehr groรen Datensรคtzen konzipiert. Aufgrund der begrenzten Maschinenressourcen ist es nicht mรถglich, das Modell mit allen Daten auf einmal zu versorgen. Dazu mรผssen Sie jedes Mal einen Datenstapel eingeben. Beachten Sie, dass es sich um einen riesigen Datensatz mit Millionen oder mehr Datensรคtzen handelt. Wenn Sie keinen Stapel hinzufรผgen, tritt ein Speicherfehler auf.
Wenn Ihre Daten beispielsweise 100 Beobachtungen enthalten und Sie eine Stapelgrรถรe von 10 definieren, bedeutet dies, dass das Modell 10 Beobachtungen fรผr jede Iteration erkennt (10*10).
Wenn das Modell alle Daten gesehen hat, beendet es eins Epoche. Eine Epoche definiert, wie oft das Modell die Daten sehen soll. Es ist besser, diesen Schritt auf โKeineโ zu setzen und das Modell mehrere Iterationen durchfรผhren zu lassen.
Eine zweite Information, die hinzugefรผgt werden muss, ist, ob Sie die Daten vor jeder Iteration neu mischen mรถchten. Wรคhrend des Trainings ist es wichtig, die Daten neu zu mischen, damit das Modell kein spezifisches Muster des Datensatzes lernt. Wenn das Modell die Details des zugrunde liegenden Musters der Daten lernt, wird es Schwierigkeiten haben, die Vorhersage fรผr unbekannte Daten zu verallgemeinern. Dies nennt man รberanpassung. Das Modell schneidet bei den Trainingsdaten gut ab, kann jedoch bei unsichtbaren Daten keine korrekten Vorhersagen treffen.
TensorFlow macht diese beiden Schritte einfach. Wenn die Daten an die Pipeline gesendet werden, weiร sie, wie viele Beobachtungen sie benรถtigt (Batch) und ob sie die Daten mischen muss.
Um Tensorflow anzuweisen, wie das Modell gefรผttert werden soll, kรถnnen Sie pandas_input_fn verwenden. Dieses Objekt benรถtigt 5 Parameter:
- x: Feature-Daten
- y: Etikettendaten
- Batch_size: Batch. Standardmรครig 128
- num_epoch: Anzahl der Epochen, standardmรครig 1
- shuffle: Die Daten werden gemischt oder nicht. Standardmรครig: Keine
Sie mรผssen das Modell viele Male fรผttern, also definieren Sie eine Funktion, um diesen Vorgang zu wiederholen. all diese Funktion get_input_fn.
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Die รผbliche Methode zur Bewertung der Leistung eines Modells ist:
- Trainiere das Modell
- Bewerten Sie das Modell in einem anderen Datensatz
- Machen Sie eine Vorhersage
Der Tensorflow-Schรคtzer bietet drei verschiedene Funktionen, um diese drei Schritte einfach auszufรผhren.
Schritt 4): Trainieren Sie das Modell
Sie kรถnnen den Schรคtzerzug verwenden, um das Modell auszuwerten. Der Zugschรคtzer benรถtigt einen input_fn und eine Reihe von Schritten. Sie kรถnnen die oben erstellte Funktion verwenden, um das Modell zu fรผttern. Anschlieรend weisen Sie das Modell an, 1000 Mal zu iterieren. Beachten Sie, dass Sie nicht die Anzahl der Epochen angeben, sondern das Modell 1000 Mal iterieren lassen. Wenn Sie die Anzahl der Epochen auf 1 festlegen, wird das Modell viermal iterieren: Der Trainingssatz enthรคlt 4 Datensรคtze und die Stapelgrรถรe betrรคgt 400
- 128 Zahnreihen
- 128 Zahnreihen
- 128 Zahnreihen
- 16 Zahnreihen
Daher ist es einfacher, die Anzahl der Epochen auf โKeineโ zu setzen und die Anzahl der Iterationen zu definieren, wie im folgenden TensorFlow-Klassifizierungsbeispiel gezeigt.
estimator.train(input_fn=get_input_fn(training_set,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
Ausgang
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 238.616 INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec) INFO:tensorflow:global_step/sec: 314.293 INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec) INFO:tensorflow:global_step/sec: 303.863 INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec) INFO:tensorflow:global_step/sec: 308.782 INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec) INFO:tensorflow:global_step/sec: 244.969 INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec) INFO:tensorflow:global_step/sec: 155.966 INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec) INFO:tensorflow:global_step/sec: 263.256 INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec) INFO:tensorflow:global_step/sec: 254.112 INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec) INFO:tensorflow:global_step/sec: 292.405 INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec) INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873.
Sie kรถnnen das Tensorboard mit dem folgenden Befehl รผberprรผfen:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Schritt 5) Bewerten Sie Ihr Modell
Sie kรถnnen die Anpassung Ihres Modells an den Testsatz mit dem folgenden Code bewerten:
ev = estimator.evaluate(
input_fn=get_input_fn(test_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Ausgang
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
Sie kรถnnen den Verlust mit dem folgenden Code ausdrucken:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
Ausgang
Loss: 3215.895996
Das Modell hat einen Verlust von 3215. Sie kรถnnen die zusammenfassende Statistik รผberprรผfen, um eine Vorstellung davon zu bekommen, wie groร der Fehler ist.
training_set['medv'].describe()
Ausgang
count 400.000000 mean 22.625500 std 9.572593 min 5.000000 25% 16.600000 50% 21.400000 75% 25.025000 max 50.000000 Name: medv, dtype: float64
Aus der zusammenfassenden Statistik oben wissen Sie, dass der Durchschnittspreis fรผr ein Haus 22 betrรคgt, mit einem Mindestpreis von 9 und einem Hรถchstpreis von 50. Das Modell macht einen typischen Fehler von 3 Dollar.
Schritt 6) Machen Sie die Vorhersage
Schlieรlich kรถnnen Sie den Schรคtzer TensorFlow Predict verwenden, um den Wert von 6 Hรคusern in Boston zu schรคtzen.
y = estimator.predict(
input_fn=get_input_fn(prediction_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Um die geschรคtzten Werte von auszudrucken, kรถnnen Sie diesen Code verwenden:
predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))
Ausgang
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]
Das Modell prognostizierte folgende Werte:
| Einfamilienhaus | Prognose | |
|---|---|---|
| 1 | 32.29 | |
| 2 | 18.96 | |
| 3 | 27.27 | |
| 4 | 29.29 | |
| 5 | 16.43 | |
| 7 | 21.46 |
Beachten Sie, dass wir den wahren Wert von nicht kennen. Im Deep-Learning-Tutorial werden Sie versuchen, das lineare Modell zu schlagen
Numpy-Lรถsung
In diesem Abschnitt wird erlรคutert, wie Sie das Modell mithilfe eines Numpy-Schรคtzers trainieren, um die Daten einzuspeisen. Die Methode ist dieselbe, auรer dass Sie den Schรคtzer numpy_input_fn verwenden.
training_set_n = pd.read_csv(โE:/boston_train.csvโ).values
test_set_n = pd.read_csv(โE:/boston_test.csvโ).values
prediction_set_n = pd.read_csv(โE:/boston_predict.csvโ).values
Schritt 1) Importieren Sie die Daten
Zunรคchst mรผssen Sie die Feature-Variablen vom Label unterscheiden. Sie mรผssen dies fรผr die Trainingsdaten und die Auswertung tun. Es ist schneller, eine Funktion zum Aufteilen der Daten zu definieren.
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
Mit der Funktion kรถnnen Sie die Beschriftung von den Features des Trainings-/Auswertungsdatensatzes trennen
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Sie mรผssen die letzte Spalte des Vorhersagedatensatzes ausschlieรen, da sie nur NaN enthรคlt
x_predict = prediction_set_n[:, :-2]
Bestรคtigen Sie die Form des Arrays. Beachten Sie, dass die Beschriftung keine Dimension haben sollte, sie bedeutet (400,).
print(X_train.shape, y_train.shape, x_predict.shape)
Ausgang
(400, 9) (400,) (6, 9)
Sie kรถnnen die Feature-Spalten wie folgt erstellen:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Der Schรคtzer wird wie zuvor definiert, Sie legen die Feature-Spalten fest und legen fest, wo das Diagramm gespeichert werden soll.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
model_dir="train1")
Ausgang
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Sie kรถnnen den Numpy-Schรคtzwert verwenden, um die Daten in das Modell einzuspeisen und das Modell dann zu trainieren. Beachten Sie, dass wir zuvor die Funktion input_fn definieren, um die Lesbarkeit zu erleichtern.
# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_train},
y=y_train,
batch_size=128,
shuffle=False,
num_epochs=None)
estimator.train(input_fn = train_input,steps=5000)
Ausgang
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train1/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 490.057 INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec) INFO:tensorflow:global_step/sec: 788.986 INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec) INFO:tensorflow:global_step/sec: 736.339 INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec) INFO:tensorflow:global_step/sec: 383.305 INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec) INFO:tensorflow:global_step/sec: 859.832 INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec) INFO:tensorflow:global_step/sec: 804.394 INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec) INFO:tensorflow:global_step/sec: 753.059 INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec) INFO:tensorflow:global_step/sec: 402.165 INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec) INFO:tensorflow:global_step/sec: 344.022 INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec) INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt. INFO:tensorflow:Loss for final step: 5925.985. Out[23]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>
Sie wiederholen denselben Schritt mit einem anderen Schรคtzer, um Ihr Modell zu bewerten
eval_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_test},
y=y_test,
shuffle=False,
batch_size=128,
num_epochs=1)
estimator.evaluate(eval_input,steps=None)
Ausgang
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}
Abschlieรend kรถnnen Sie die Vorhersage berechnen. Es sollte รคhnlich wie Pandas sein.
test_input = tf.estimator.inputs.numpy_input_fn(
x={"x": x_predict},
batch_size=128,
num_epochs=1,
shuffle=False)
y = estimator.predict(test_input)
predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))
Ausgang
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]
Tensorflow-Lรถsung
Der letzte Abschnitt ist einer TensorFlow-Lรถsung gewidmet. Diese Methode ist etwas komplizierter als die andere.
Beachten Sie, dass, wenn Sie verwenden Jupyter Notizbuch, mรผssen Sie den Kernel neu starten und bereinigen, um diese Sitzung auszufรผhren.
TensorFlow hat ein groรartiges Tool entwickelt, um die Daten in die Pipeline zu รผbergeben. In diesem Abschnitt erstellen Sie die Funktion input_fn selbst.
Schritt 1) Definieren Sie den Pfad und das Format der Daten
Zunรคchst deklarieren Sie zwei Variablen mit dem Pfad der CSV-Datei. Beachten Sie, dass Sie รผber zwei Dateien verfรผgen, eine fรผr den Trainingssatz und eine fรผr den Testsatz.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Anschlieรend mรผssen Sie die Spalten, die Sie verwenden mรถchten, aus der CSV-Datei definieren. Wir werden alles nutzen. Danach mรผssen Sie den Typ der Variablen deklarieren.
Float-Variablen werden durch [0.] definiert.
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]
Schritt 2) Definieren Sie die Funktion input_fn
Die Funktion kann in drei Teile unterteilt werden:
- Importieren Sie die Daten
- Erstellen Sie den Iterator
- Verbrauchen Sie die Daten
Nachfolgend finden Sie den Gesamtcode zum Definieren der Funktion. Der Code wird spรคter erklรคrt
def input_fn(data_file, batch_size, num_epoch = None):
# Step 1
def parse_csv(value):
columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)
features = dict(zip(COLUMNS, columns))
#labels = features.pop('median_house_value')
labels = features.pop('medv')
return features, labels
# Extract lines from input files using the
Dataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file
.skip(1) # Skip header row
.map(parse_csv))
dataset = dataset.repeat(num_epoch)
dataset = dataset.batch(batch_size)
# Step 3
iterator = dataset.make_one_shot_iterator()
features, labels = iterator.get_next()
return features, labels
**Importieren Sie die Daten**
Bei einer CSV-Datei liest die Datensatzmethode jeweils eine Zeile. Um den Datensatz zu erstellen, mรผssen Sie das Objekt verwenden TextLineDatensatz. Ihr Datensatz hat einen Header, daher mรผssen Sie โskip(1)โ verwenden, um die erste Zeile zu รผberspringen. Zu diesem Zeitpunkt lesen Sie nur die Daten und schlieรen den Header in der Pipeline aus. Um das Modell zu fรผttern, mรผssen Sie die Features vom Etikett trennen. Die Methode zum Anwenden einer Transformation auf die Daten ist die Karte.
Diese Methode ruft eine Funktion auf, die Sie erstellen, um anzugeben, wie die Daten transformiert werden. Kurz gesagt, Sie mรผssen die Daten in รผbergeben TextLineDataset-Objekt, Header ausschlieรen und eine Transformation anwenden, die durch eine Funktion vorgegeben ist.Code Erklรคrung
- tf.data.TextLineDatensatz (Datendatei): Diese Zeile liest die CSV-Datei
- .skip(1) : รberspringe den Header
- .map(parse_csv)): Analysieren Sie die Datensรคtze in Tensoren. Sie mรผssen eine Funktion definieren, um das Kartenobjekt anzuweisen. Sie kรถnnen diese Funktion parse_csv aufrufen.
Diese Funktion analysiert die CSV-Datei mit der Methode `tf.decode_csv` und deklariert die Merkmale und die Bezeichnungen. Die Merkmale kรถnnen als Dictionary oder Tupel deklariert werden. Die Dictionary-Methode ist praktischer.Code Erklรคrung
- tf.decode_csv(value, record_defaults= RECORDS_ALL): Die Methode decode_csv verwendet die Ausgabe von TextLineDatensatz zum Lesen der CSV-Datei. record_defaults weist TensorFlow รผber den Spaltentyp an.
- dict(zip(_CSV_COLUMNS, columns)): Fรผllt das Wรถrterbuch mit allen Spalten.tracted wรคhrend dieser Datenverarbeitung
- Features.pop('median_house_value'): Schlieรen Sie die Zielvariable aus der Feature-Variable aus und erstellen Sie eine Label-Variable
Der Datensatz benรถtigt weitere Elemente, um die Tensoren iterativ zu fรผttern. Tatsรคchlich mรผssen Sie die Methode โrepeatโ hinzufรผgen, damit der Datensatz unbegrenzt weiterlaufen kann, um das Modell zu speisen. Wenn Sie die Methode nicht hinzufรผgen, iteriert das Modell nur einmal und gibt dann einen Fehler aus, da keine weiteren Daten in die Pipeline eingespeist werden.
Anschlieรend kรถnnen Sie die Chargengrรถรe mit der Batch-Methode steuern. Das bedeutet, dass Sie dem Datensatz mitteilen, wie viele Daten Sie fรผr jede Iteration in der Pipeline รผbergeben mรถchten. Wenn Sie eine groรe Batchgrรถรe festlegen, ist das Modell langsam.
Schritt 3) Erstellen Sie den Iterator
Jetzt sind Sie bereit fรผr den zweiten Schritt: Erstellen Sie einen Iterator, um die Elemente im Datensatz zurรผckzugeben.
Der einfachste Weg, einen Operator zu erstellen, ist die Methode make_one_shot_iterator.
Anschlieรend kรถnnen Sie die Features und Beschriftungen aus dem Iterator erstellen.
Schritt 4) Verbrauchen Sie die Daten
Sie kรถnnen mit der Funktion input_fn รผberprรผfen, was passiert. Sie mรผssen die Funktion in einer Sitzung aufrufen, um die Daten zu nutzen. Versuchen Sie es mit einer Stapelgrรถรe von 1.
Beachten Sie, dass die Features in einem Wรถrterbuch und die Beschriftung als Array gedruckt werden.
Es wird die erste Zeile der CSV-Datei angezeigt. Sie kรถnnen versuchen, diesen Code mehrmals mit unterschiedlicher Stapelgrรถรe auszufรผhren.
next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)
with tf.Session() as sess:
first_batch = sess.run(next_batch)
print(first_batch)
Ausgang
({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))
Schritt 4) Definieren Sie die Feature-Spalte
Sie mรผssen die numerischen Spalten wie folgt definieren:
X1= tf.feature_column.numeric_column('crim')
X2= tf.feature_column.numeric_column('zn')
X3= tf.feature_column.numeric_column('indus')
X4= tf.feature_column.numeric_column('nox')
X5= tf.feature_column.numeric_column('rm')
X6= tf.feature_column.numeric_column('age')
X7= tf.feature_column.numeric_column('dis')
X8= tf.feature_column.numeric_column('tax')
X9= tf.feature_column.numeric_column('ptratio')
Beachten Sie, dass Sie alle Variablen in einem Bucket kombinieren mรผssen
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Schritt 5) Erstellen Sie das Modell
Sie kรถnnen das Modell mit dem Schรคtzer LinearRegressor trainieren.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
Ausgang
INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Sie mรผssen eine Lambda-Funktion verwenden, um das Schreiben des Arguments in die Funktion inpu_fn zu ermรถglichen. Wenn Sie kein verwenden Lambda-Funktion, kรถnnen Sie das Modell nicht trainieren.
# Train the estimatormodel.train(steps =1000,
input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
Ausgang
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Create CheckpointSaverHook. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Saving checkpoints for 1 into train3/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 72.5646 INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec) INFO:tensorflow:global_step/sec: 101.355 INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec) INFO:tensorflow:global_step/sec: 109.293 INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec) INFO:tensorflow:global_step/sec: 102.235 INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec) INFO:tensorflow:global_step/sec: 104.656 INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec) INFO:tensorflow:global_step/sec: 106.697 INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec) INFO:tensorflow:global_step/sec: 118.454 INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec) INFO:tensorflow:global_step/sec: 114.947 INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec) INFO:tensorflow:global_step/sec: 111.484 INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec) INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873. Out[8]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>
Sie kรถnnen die Anpassung Ihres Modells an den Testsatz mit dem folgenden Code bewerten:
results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))
for key in results:
print(" {}, was: {}".format(key, results[key]))
Ausgang
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896 average_loss, was: 32.158958435058594 loss, was: 3215.89599609375 global_step, was: 1000
Der letzte Schritt besteht darin, den Wert von basierend auf dem Wert der Matrizen der Merkmale vorherzusagen. Sie kรถnnen ein Wรถrterbuch mit den Werten schreiben, die Sie vorhersagen mรถchten. Ihr Modell verfรผgt รผber 9 Funktionen, daher mรผssen Sie fรผr jede einen Wert angeben. Das Modell liefert fรผr jeden von ihnen eine Vorhersage.
Im folgenden Code haben Sie die Werte aller Features geschrieben, die in der CSV-Datei df_predict enthalten sind.
Sie mรผssen eine neue Funktion โinput_fnโ schreiben, da der Datensatz keine Beschriftung enthรคlt. Sie kรถnnen die API from_tensor aus dem Datensatz verwenden.
prediction_input = {
'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],
'zn': [75.0,0.0,25.0,33.0,0.0,0.0],
'indus': [2.95,18.10,5.13,2.18,18.10,9.90],
'nox': [0.428,0.713,0.453,0.472,0.700,0.544],
'rm': [7.024,6.297,6.762,7.236,5.390,5.782],
'age': [15.8,91.8,43.4,41.1,98.9,71.7],
'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],
'tax': [252,666,284,222,666,304],
'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]
}
def test_input_fn():
dataset = tf.data.Dataset.from_tensors(prediction_input)
return dataset
# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)
Abschlieรend drucken Sie die Vorhersagen aus.
for pred in enumerate(pred_results): print(pred)
Ausgang
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})
Zusammenfassung
Um ein Modell zu trainieren, mรผssen Sie Folgendes tun:
- Definieren Sie die Funktionen: Unabhรคngige Variablen: X
- Definieren Sie die Bezeichnung: Abhรคngige Variable: y
- Konstruieren Sie einen Zug-/Testsatz
- Definieren Sie das Anfangsgewicht
- Definieren Sie die Verlustfunktion: MSE
- Optimieren Sie das Modell: Gradientenabstieg
- Definieren:
- Lernrate
- Anzahl der Epochen
- Chargengrรถรe
In diesem Tutorial haben Sie gelernt, wie Sie die High-Level-API fรผr einen TensorFlow-Schรคtzer mit linearer Regression verwenden. Sie mรผssen Folgendes definieren:
- Feature-Spalten. Wenn kontinuierlich: tf.feature_column.numeric_column(). Sie kรถnnen eine Liste mit Python-Listenverstรคndnis fรผllen
- Der Schรคtzer: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Eine Funktion zum Importieren der Daten, der Batch-Grรถรe und der Epoche: input_fn()
Danach sind Sie bereit zum Trainieren, Auswerten und Vorhersagen mit train(), equal() und Predict().
