Lineare Regression mit TensorFlow (Beispiele)

Inhaltsverzeichnis:

Anonim

Was ist lineare Regression?

Die lineare Regression ist ein statistischer Ansatz zur Modellierung von Beziehungen zwischen zwei Variablen. Diese Modellierung erfolgt zwischen einer skalaren Antwort und einer oder mehreren erklärenden Variablen. Die Beziehung zu 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 Berechnungen vollständig steuern können. Dies erfolgt mit der Low-Level-API. Darüber hinaus ist TensorFlow mit einer Vielzahl von APIs ausgestattet, mit denen viele Algorithmen für maschinelles Lernen ausgeführt werden können. 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 neu. Für Anfänger ist es kompliziert
  • Übergeordnete API: Definieren Sie den Algorithmus. Es ist einfacher freundlich. TensorFlow bietet einen Toolbox- Aufrufschätzer zum Erstellen, Trainieren, Bewerten und Erstellen einer Vorhersage.

In diesem Tutorial verwenden Sie nur die Schätzer . Die Berechnungen sind schneller und einfacher zu implementieren. 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 das Boston DataSet herunter

In diesem TensorFlow-Regressions-Tutorial lernen Sie:

  • Was ist lineare Regression?
  • So trainieren Sie ein lineares Regressionsmodell
  • So trainieren Sie eine lineare Regression mit TensorFlow
  • Pandas
  • Numpy Lösung
  • Tensorflow-Lösung

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 der Kenntnis des Werts von vorherzusagen. Wenn Sie die Daten zeichnen, sehen Sie eine positive Beziehung zwischen Ihrer unabhängigen Variablen x und Ihrer abhängigen Variablen y.

Sie können beobachten, wenn x = 1, y ungefähr gleich 6 ist und wenn x = 2, y ungefähr 8,5 ist.

Dies ist keine sehr genaue Methode und fehleranfällig, insbesondere bei einem Datensatz mit Hunderttausenden von 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, ist es:

Mit:

  • ist das mit x verbundene Gewicht
  • ist der Rest oder der Fehler des Modells. Es enthält, was das Modell nicht aus den Daten lernen kann

Stellen Sie sich vor, Sie passen zum Modell und finden die folgende Lösung für:

  • = 3,8
  • = 2,78

Sie können diese Zahlen in der Gleichung ersetzen und es wird:

y = 3,8 + 2,78x

Sie haben jetzt eine bessere Möglichkeit, die Werte für y zu finden. Das heißt, Sie können x durch einen beliebigen Wert ersetzen, den Sie y vorhersagen möchten. In der Abbildung 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, dh 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 eines, das zur roten Linie gehört. Sie können auch Werte von x über 2 vorhersagen!

Wenn Sie die lineare Regression auf mehr Kovariaten erweitern möchten, können Sie dem Modell weitere Variablen hinzufügen. Der Unterschied zwischen traditioneller Analyse und linearer Regression besteht darin, dass bei der linearen Regression untersucht wird, wie y für jede Variable x unabhängig voneinander reagiert.

Sehen wir uns ein Beispiel an. Stellen Sie sich vor, Sie möchten den Verkauf einer Eisdiele vorhersagen. Der Datensatz enthält verschiedene Informationen wie das Wetter (dh regnerisch, sonnig, bewölkt), Kundeninformationen (dh Gehalt, Geschlecht, Familienstand).

Bei der herkömmlichen Analyse wird versucht, den Verkauf vorherzusagen, indem beispielsweise der Durchschnitt für jede Variable berechnet und der Verkauf für verschiedene Szenarien geschätzt wird. Dies führt zu schlechten Vorhersagen und beschränkt die Analyse auf das ausgewählte Szenario.

Wenn Sie eine lineare Regression verwenden, können Sie folgende Gleichung schreiben:

Der Algorithmus findet die beste Lösung für die Gewichte; Dies bedeutet, dass versucht wird, die Kosten zu minimieren (die Differenz zwischen der angepassten Linie und den Datenpunkten).

Wie der Algorithmus funktioniert

Der Algorithmus wird eine Zufallszahl für jeden wählen und den Wert von x ersetzen , 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 vom Modell notierten Fehler berechnen , der die Differenz zwischen dem vorhergesagten Wert und dem realen Wert darstellt. 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 Quadrat des Fehlers zu minimieren. Der Algorithmus berechnet den Mittelwert des quadratischen Fehlers. Dieser Schritt wird als Minimierung des Fehlers bezeichnet. Für die lineare Regression gilt der mittlere quadratische Fehler , auch MSE genannt. Mathematisch ist es:

Wo:

  • bezieht sich also auf den vorhergesagten Wert
  • y sind die realen Werte
  • m ist die Anzahl der Beobachtungen

Beachten Sie, dass ist die mathematische Notation des Mittelwerts.

Das Ziel ist es, das Beste zu finden , das die MSE minimiert

Wenn der durchschnittliche Fehler groß ist, bedeutet dies, dass das Modell eine schlechte Leistung erbringt und die Gewichte nicht richtig ausgewählt werden. Um die Gewichte zu korrigieren, müssen Sie einen Optimierer verwenden. Der traditionelle Optimierer heißt Gradient Descent .

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 Iteration bezeichnet . Außerdem werden die Gradienten mit einer Lernrate multipliziert. Es zeigt die Geschwindigkeit des Lernens an.

Wenn die Lernrate zu klein 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.

Wie Sie dem obigen Bild entnehmen können, wiederholt das Modell den Vorgang ungefähr 20 Mal, bevor ein stabiler Wert für die Gewichte gefunden wird, wodurch der niedrigste Fehler erreicht wird.

Beachten Sie, dass der Fehler nicht gleich Null ist, sondern sich um 5 stabilisiert. Dies 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 Verwendung verschiedene Schätzer.

Sie erinnern sich an die erste Gleichung

Die Endgewichte betragen 3,8 und 2,78. Das folgende Video zeigt Ihnen, wie der Gradientenabstieg die Verlustfunktion optimiert, um diese Gewichte zu finden

So trainieren Sie eine lineare Regression mit TensorFlow

Nachdem Sie nun besser verstanden haben, was sich hinter der Haube abspielt, 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

crim Pro-Kopf-Kriminalitätsrate nach Städten
zn Anteil des Wohngrundstücks für Grundstücke über 25.000 m².
indus Anteil der Hektar außerhalb des Einzelhandels pro Stadt.
nox Stickoxidkonzentration
rm durchschnittliche Anzahl der Zimmer pro Wohnung
Alter Anteil der vor 1940 gebauten Eigentumswohnungen
dis gewichtete Entfernungen zu fünf Bostoner Beschäftigungszentren
MwSt Vollwertiger Grundsteuersatz pro 10.000 US-Dollar
ptratio Schüler-Lehrer-Verhältnis nach Stadt
medv Medianwert der Eigentumswohnungen in Tausend Dollar

Sie erstellen drei verschiedene Datensätze:

Datensatz Zielsetzung gestalten
Ausbildung Trainiere das Modell und erhalte die Gewichte 400, 10
Auswertung Bewerten Sie die Leistung des Modells anhand nicht sichtbarer Daten 100, 10
Vorhersagen Verwenden Sie das Modell, um den Hauswert für neue Daten vorherzusagen 6, 10

Ziel ist es, anhand der Merkmale des Datensatzes 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 die gleichen Ergebnisse liefern.

Sie lernen, wie Sie mithilfe der High-Level-API ein lineares TensorFlow-Regressionsmodell erstellen, trainieren und bewerten. Wenn Sie die Low-Level-API verwenden, müssen Sie Folgendes manuell definieren:

  • Verlustfunktion
  • Optimieren: Gefälle
  • 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 pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Schritt 1) Importieren Sie die Daten mit Panda.

Sie definieren die Spaltennamen und speichern sie in SPALTEN. 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", skipinitialspace = 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)

Ausgabe

(400, 10) (100, 10) (6, 10)

Beachten Sie, dass die Bezeichnung, dh Ihr y, im Datensatz enthalten ist. Sie müssen also zwei weitere Listen definieren. Eine, die nur die Merkmale enthält, und eine, die nur den Namen des Etiketts enthält. Diese beiden Listen teilen Ihrem Schätzer mit, welche Funktionen im Dataset enthalten 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 einer kontinuierlichen Variablen: tf.feature_column.numeric_column ().

Im vorherigen Schritt definieren Sie eine Liste einer Funktion, die 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 die Liste FEATURES einfügen, bevor Sie die feature_cols erstellen

Beachten Sie, dass Sie das Python-Listenverständnis mit der Liste FEATURES verwenden, um eine neue Liste mit dem Namen feature_cols zu erstellen. Es hilft Ihnen zu vermeiden, neunmal tf.feature_column.numeric_column () zu schreiben. 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 die Klassifizierungsaufgabe und 3 für die TensorFlow-Regressionsaufgabe:

  • Regressor
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Klassifikator
    • DNNClassifier
    • LinearClassifier
    • DNNLineaCombinedClassifier

In diesem Tutorial verwenden Sie den linearen Regressor. Um auf diese Funktion zugreifen zu können, 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, 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")

Ausgabe

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': , '_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 schwierige Teil bei TensorFlow ist die Art und Weise, das Modell zu füttern. Tensorflow wurde für die Arbeit mit parallelem Computing und sehr großen Datenmengen entwickelt. Aufgrund der Begrenzung der Maschinenressourcen ist es unmö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, wird ein Speicherfehler angezeigt.

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 sieht (10 * 10).

Wenn das Modell alle Daten gesehen hat, endet eine Epoche . Eine Epoche definiert, wie oft das Modell die Daten sehen soll. Es ist besser, diesen Schritt auf "Keine" zu setzen und das Modell die Anzahl der Iterationen durchführen zu lassen.

Eine zweite hinzuzufügende Information ist, wenn Sie die Daten vor jeder Iteration mischen möchten. Während des Trainings ist es wichtig, die Daten zu mischen, damit das Modell kein bestimmtes Muster des Datensatzes lernt. Wenn das Modell die Details des zugrunde liegenden Musters der Daten lernt, wird es schwierig sein, die Vorhersage für unsichtbare Daten zu verallgemeinern. Dies wird als Überanpassung bezeichnet . Das Modell arbeitet gut mit den Trainingsdaten, kann jedoch nicht unsichtbare Daten korrekt vorhersagen.

TensorFlow macht diese beiden Schritte einfach. Wenn die Daten in die Pipeline gelangen, wissen sie, wie viele Beobachtungen sie benötigen (Stapel) und ob sie die Daten mischen müssen.

Um Tensorflow anzuweisen, wie das Modell zu füttern ist, 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: Mische die Daten oder nicht. Standardmäßig Keine

Sie müssen das Modell viele Male füttern, damit Sie eine Funktion definieren, 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
  • Vorhersage machen

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 zu bewerten. Der Zugschätzer benötigt eine 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 setzen, wird das Modell viermal wiederholt: Der Trainingssatz enthält 400 Datensätze, und die Stapelgröße beträgt 128

  1. 128 Zeilen
  2. 128 Zeilen
  3. 128 Zeilen
  4. 16 Zeilen

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)

Ausgabe

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 = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO: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 überprüfen, ob das Tensorboard den folgenden Befehl ausführt:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --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))

Ausgabe

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO: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))

Ausgabe

Loss: 3215.895996

Das Modell hat einen Verlust von 3215. Sie können die Zusammenfassungsstatistik überprüfen, um eine Vorstellung davon zu erhalten, wie groß der Fehler ist.

training_set['medv'].describe()

Ausgabe

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

Aus der obigen zusammenfassenden Statistik wissen Sie, dass der Durchschnittspreis für ein Haus 22.000 beträgt, mit einem Mindestpreis von 9.000 und einem Höchstpreis von 50.000. Das Modell macht einen typischen Fehler von 3.000 Dollar.

Schritt 6) Machen Sie die Vorhersage

Schließlich können Sie den Schätzer TensorFlow Predict verwenden, um den Wert von 6 Bostoner Häusern 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 zu drucken, können Sie diesen Code verwenden:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Ausgabe

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO: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 prognostiziert folgende Werte:

Haus

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 Tutorial zum tiefen Lernen werden Sie versuchen, das lineare Modell zu schlagen

Numpy Lösung

In diesem Abschnitt wird erläutert, wie Sie das Modell mit einem Numpy-Schätzer trainieren, um die Daten einzugeben. Die Methode ist dieselbe, mit der Sie den Schätzer numpy_input_fn verwenden.

training_set_n = pd.read_csv ("E: /boston_train.csv"). Werte

test_set_n = pd.read_csv ("E: /boston_test.csv"). Werte

Prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). Werte

Schritt 1) Importieren Sie die Daten

Zunächst müssen Sie die Feature-Variablen von der Bezeichnung unterscheiden. Sie müssen dies für die Trainingsdaten und die Auswertung tun. Es ist schneller, eine Funktion zum Teilen der Daten zu definieren.

def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train

Mit dieser Funktion können Sie die Beschriftung von den Merkmalen des Zug- / 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 das Etikett keine Abmessung haben sollte, dh (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Ausgabe

(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 ist wie zuvor definiert. Sie weisen die Feature-Spalten an und wo das Diagramm gespeichert werden soll.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")

Ausgabe

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': , '_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 Estimapor verwenden, um die Daten dem Modell zuzuführen und das Modell dann zu trainieren. Beachten Sie, dass wir zuvor die Funktion input_fn definiert haben, um die Lesbarkeit zu verbessern.

# 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)

Ausgabe

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 = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO: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]:

Sie replizieren 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)

Ausgabe

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[24]:{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

Schließlich können Sie die Vorhersage berechnen. Es sollte ähnlich sein wie Pandas.

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)))

Ausgabe

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO: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 Sie bei Verwendung des Jupyter-Notizbuchs den Kernel neu starten und bereinigen müssen, um diese Sitzung auszuführen.

TensorFlow hat ein großartiges Tool entwickelt, um die Daten in die Pipeline zu übertragen. 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 zwei Dateien haben, 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 alle verwenden. Danach müssen Sie den Variablentyp deklarieren.

Floats-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:

  1. Importieren Sie die Daten
  2. Erstellen Sie den Iterator
  3. Verbrauchen Sie die Daten

Unten finden Sie den Gesamtcode zum Definieren der Funktion. Der Code wird nachfolgend erläutert

def input_fn(data_file, batch_size, num_epoch = None):# Step 1def 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 theDataset 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 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Daten importieren **

Bei einer CSV-Datei liest die Dataset-Methode jeweils eine Zeile. Um das Dataset zu erstellen, müssen Sie das Objekt TextLineDataset verwenden. Ihr Datensatz hat eine Kopfzeile, daher müssen Sie überspringen (1), 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 map.

Diese Methode ruft eine Funktion auf, die Sie erstellen, um anzuweisen, wie die Daten transformiert werden sollen. Kurz gesagt, Sie müssen die Daten im TextLineDataset-Objekt übergeben, den Header ausschließen und eine Transformation anwenden, die von einer function.Code-Erklärung angewiesen wird

  • tf.data.TextLineDataset (data_file): In dieser Zeile wurde die CSV-Datei gelesen
  • .skip (1): Überspringt die Kopfzeile
  • .map (parse_csv)): Analysiert die Datensätze in die 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 Features und die Bezeichnung. Die Funktionen können als Wörterbuch oder Tupel deklariert werden. Sie verwenden die Wörterbuchmethode, weil sie bequemer ist. Code-Erklärung

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): Die Methode decode_csv verwendet die Ausgabe des TextLineDataset zum Lesen der CSV-Datei. record_defaults weist TensorFlow über den Spaltentyp an.
  • dict (zip (_CSV_COLUMNS, Spalten)): Füllen Sie das Wörterbuch mit allen Spalten, die während dieser Datenverarbeitung extrahiert wurden
  • features.pop ('median_house_value'): Schließen Sie die Zielvariable von der Feature-Variablen aus und erstellen Sie eine Beschriftungsvariable

Der Datensatz benötigt weitere Elemente, um die Tensoren iterativ zu versorgen. In der Tat müssen Sie die Methodenwiederholung hinzufügen, damit das Dataset unbegrenzt fortgesetzt werden kann, um das Modell zu füttern. 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.

Danach können Sie die Stapelgröße mit der Stapelmethode steuern. Dies 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 Stapelgröß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 Dataset zurückzugeben.

Die einfachste Möglichkeit, einen Operator zu erstellen, ist die Methode make_one_shot_iterator.

Danach können Sie die Features und Beschriftungen im Iterator erstellen.

Schritt 4) Verbrauchen Sie die Daten

Sie können überprüfen, was mit der Funktion input_fn passiert. Sie müssen die Funktion in einer Sitzung aufrufen, um die Daten zu verbrauchen. Sie versuchen es mit einer Chargengröße von 1.

Beachten Sie, dass die Funktionen 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)

Ausgabe

({'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')

Ausgabe

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': , '_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 Argument in die Funktion inpu_fn schreiben zu können. Wenn Sie keine Lambda-Funktion verwenden, 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))

Ausgabe

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 = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO: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]:

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]))

Ausgabe

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

Der letzte Schritt ist die Vorhersage des Werts von basierend auf dem Wert der Matrizen der Merkmale. Sie können ein Wörterbuch mit den Werten schreiben, die Sie vorhersagen möchten. Ihr Modell verfügt über 9 Funktionen, sodass Sie für jede Funktion einen Wert angeben müssen. Das Modell liefert eine Vorhersage für jeden von ihnen.

Im folgenden Code haben Sie die Werte der einzelnen Features geschrieben, die in der CSV-Datei df_predict enthalten sind.

Sie müssen eine neue input_fn-Funktion schreiben, da das Dataset keine Bezeichnung enthält. Sie können die API from_tensor aus dem Dataset 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)

Schließlich drucken Sie die Vorhersagen.

for pred in enumerate(pred_results):print(pred)

Ausgabe

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO: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:

  • Definieren Sie die Features: Unabhängige Variablen: X.
  • Definieren Sie die Bezeichnung: Abhängige Variable: y
  • Konstruieren Sie ein Zug- / Test-Set
  • Definieren Sie das Anfangsgewicht
  • Definieren Sie die Verlustfunktion: MSE
  • Modell optimieren: Gradientenabstieg
  • Definieren:
    • Lernrate
    • Anzahl der Epochen
    • Chargengröße

In diesem Lernprogramm haben Sie gelernt, wie Sie die API auf hoher Ebene für einen linearen Regressions-TensorFlow-Schätzer verwenden. Sie müssen definieren:

  1. Feature-Spalten. Wenn kontinuierlich: tf.feature_column.numeric_column (). Sie können eine Liste mit Python-Listenverständnis füllen
  2. Der Schätzer: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Eine Funktion zum Importieren der Daten, der Stapelgröße und der Epoche: input_fn ()

Danach können Sie mit train () trainieren, bewerten und Vorhersagen treffen, bewerten () und vorhersagen ()