Tutorial zur linearen Regression mit TensorFlow [Beispiele]

By:

Aktualisiert12. Juni 2024

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

Beachten 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 TextLineDatensatzobjekt, schließen Sie den Header aus und wenden Sie eine Transformation an, die durch eine function.Code-Erklärung angewiesen wird

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 Features und das Label. Die Features können als Wörterbuch oder Tupel deklariert werden. Sie verwenden die Wörterbuchmethode, weil sie bequemer ist.Codeerklä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üllen Sie das Wörterbuch mit allen während dieser Datenverarbeitung extrahierten Spalten
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().

Fassen Sie diesen Beitrag mit folgenden Worten zusammen:

Bleiben Sie über KI auf dem Laufenden Erhalten Sie Wöchentliche KI Fähigkeiten, Trends, umsetzbare Ratschläge.

Melden Sie sich für den Newsletter an

Ausgewählt von über 350,000