TensorFlow Lineare Regression mit Facette & Interaktionsterm

In diesem Lernprogramm erfahren Sie, wie Sie die Daten überprüfen und für die Erstellung einer einfachen linearen Regressionsaufgabe vorbereiten.

Dieses Tutorial besteht aus zwei Teilen:

• Suchen Sie nach Interaktion
• Testen Sie das Modell

Im vorherigen Tutorial haben Sie den Boston-Datensatz verwendet, um den Durchschnittspreis eines Hauses zu schätzen. Der Boston-Datensatz ist mit nur 506 Beobachtungen klein. Dieser Datensatz wird als Benchmark für die Erprobung neuer linearer Regressionsalgorithmen angesehen.

Der Datensatz besteht aus:

Variable	Beschreibung
zn	Der Anteil des Wohngrundstücks, der für Grundstücke über 25.000 m² vorgesehen ist.
indus	Der Anteil der Nicht-Einzelhandelsflächen pro Stadt.
nox	Stickoxidkonzentration
rm	durchschnittliche Anzahl der Zimmer pro Wohnung
Alter	der Anteil der vor 1940 gebauten Eigentumswohnungen
dis	gewichtete Entfernungen zu fünf Bostoner Beschäftigungszentren
MwSt	Vollwertiger Grundsteuersatz pro 10.000 US-Dollar
ptratio	das Schüler-Lehrer-Verhältnis einer Stadt
medv	Der Medianwert von Eigentumswohnungen in Tausend Dollar
crim	Pro-Kopf-Kriminalitätsrate nach Städten
chas	Charles River Dummy-Variable (1, wenn der Fluss begrenzt ist; 0, sonst)
B.	der Anteil der Schwarzen in der Stadt

In diesem Tutorial werden wir den Medianpreis mithilfe eines linearen Regressors schätzen. Der Schwerpunkt liegt jedoch auf einem bestimmten Prozess des maschinellen Lernens: "Datenaufbereitung".

Ein Modell verallgemeinert das Muster in den Daten. Um ein solches Muster zu erfassen, müssen Sie es zuerst finden. Es empfiehlt sich, eine Datenanalyse durchzuführen, bevor Sie einen Algorithmus für maschinelles Lernen ausführen.

Die Auswahl der richtigen Funktionen macht den Unterschied für den Erfolg Ihres Modells aus. Stellen Sie sich vor, Sie versuchen, den Lohn eines Volkes zu schätzen. Wenn Sie das Geschlecht nicht als Kovariate angeben, erhalten Sie eine schlechte Schätzung.

Eine andere Möglichkeit, das Modell zu verbessern, besteht darin, die Korrelation zwischen der unabhängigen Variablen zu untersuchen. Zurück zum Beispiel: Sie können sich Bildung als einen hervorragenden Kandidaten vorstellen, um den Lohn, aber auch den Beruf vorherzusagen. Man kann mit Recht sagen, dass der Beruf vom Bildungsniveau abhängt, dh Hochschulbildung führt oft zu einem besseren Beruf. Wenn wir diese Idee verallgemeinern, können wir sagen, dass die Korrelation zwischen der abhängigen Variablen und einer erklärenden Variablen von einer weiteren erklärenden Variablen vergrößert werden kann.

Um die begrenzten Auswirkungen der Bildung auf den Beruf zu erfassen, können wir einen Interaktionsbegriff verwenden.

Wenn Sie sich die Lohngleichung ansehen, wird sie:

Wenn dies positiv ist, bedeutet dies, dass ein zusätzliches Bildungsniveau zu einem höheren Anstieg des Medianwerts eines Hauses bei einem hohen Beschäftigungsniveau führt. Mit anderen Worten, es gibt einen Interaktionseffekt zwischen Bildung und Beruf.

In diesem Tutorial werden wir versuchen herauszufinden, welche Variablen ein guter Kandidat für Interaktionsterme sein können. Wir werden testen, ob das Hinzufügen dieser Art von Informationen zu einer besseren Preisvorhersage führt.

In diesem Tutorial lernen Sie

• Zusammengefasste Statistiken
• Facettenübersicht
• Facetten Deep Dive
• Installieren Sie Facet
• Überblick
• Graph
• Facetten Deep Dive
• TensorFlow
• Vorbereitungsdaten
• Grundlegende Regression: Benchmark
• Modell verbessern: Interaktionsbegriff

Zusammengefasste Statistiken

Es gibt einige Schritte, die Sie ausführen können, bevor Sie mit dem Modell fortfahren. Wie bereits erwähnt, handelt es sich bei dem Modell um eine Verallgemeinerung der Daten. Die beste Vorgehensweise besteht darin, die Daten zu verstehen und eine Vorhersage zu treffen. Wenn Sie Ihre Daten nicht kennen, haben Sie nur geringe Chancen, Ihr Modell zu verbessern.

Laden Sie als ersten Schritt die Daten als Pandas-Datenrahmen und erstellen Sie einen Trainingssatz und einen Testsatz.

Tipps: Für dieses Tutorial müssen matplotlit und seaborn in Python installiert sein. Sie können das Python-Paket im laufenden Betrieb mit Jupyter installieren. Sie sollten dies nicht tun

!conda install -- yes matplotlib

aber

import sys!{sys.executable} -m pip install matplotlib # Already installed!{sys.executable} -m pip install seaborn

Beachten Sie, dass dieser Schritt nicht erforderlich ist, wenn Sie Matplotlib und Seaborn installiert haben.

Matplotlib ist die Bibliothek zum Erstellen eines Diagramms in Python. Seaborn ist eine statistische Visualisierungsbibliothek, die auf Matplotlib basiert. Es bietet attraktive und schöne Grundstücke.

Der folgende Code importiert die erforderlichen Bibliotheken.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tffrom sklearn.datasets import load_bostonimport numpy as np

Die Bibliothek sklearn enthält den Boston-Datensatz. Sie können die API aufrufen, um die Daten zu importieren.

boston = load_boston()df = pd.DataFrame(boston.data) 

Der Name des Features wird im Objekt feature_names in einem Array gespeichert.

boston.feature_names

Ausgabe

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Sie können die Spalten umbenennen.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Sie konvertieren die Variable CHAS als String-Variable und beschriften sie mit yes, wenn CHAS = 1, und no, wenn CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Mit Pandas ist es einfach, den Datensatz zu teilen. Sie teilen den Datensatz zufällig mit 80 Prozent Trainingssatz und 20 Prozent Testsatz auf. Pandas verfügen über eine integrierte Kostenfunktion zum Aufteilen eines Datenrahmenbeispiels.
Der erste Parameter frac ist ein Wert von 0 bis 1. Sie setzen ihn auf 0,8, um zufällig 80 Prozent des Datenrahmens auszuwählen.
Mit Random_state kann für alle derselbe Datenrahmen zurückgegeben werden.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Sie können die Form der Daten erhalten. Es sollte sein:

Zugsatz: 506 * 0,8 = 405
Testsatz: 506 * 0,2 = 101

print(df_train.shape, df_test.shape)
Ausgabe 
(405, 14) (101, 14) 
 
df_test.head(5)
Ausgabe
 

 
 
 
 
KRIMINALITÄT 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
ALTER 
 
DIS 
 
RAD 
 
MWST 
 
PTRATIO 
 
B. 
 
LSTAT 
 
PREIS 
 

 
 
0 
 
0,00632 
 
18.0 
 
2.31 
 
Nein 
 
0,538 
 
6,575 
 
65.2 
 
4,0900 
 
1.0 
 
296.0 
 
15.3 
 
396,90 
 
4.98 
 
24.0 
 

 
 
1 
 
0,02731 
 
0.0 
 
7.07 
 
Nein 
 
0,469 
 
6.421 
 
78.9 
 
4.9671 
 
2.0 
 
242.0 
 
17.8 
 
396,90 
 
9.14 
 
21.6 
 

 
 
3 
 
0,03237 
 
0.0 
 
2.18 
 
Nein 
 
0,458 
 
6.998 
 
45.8 
 
6.0622 
 
3.0 
 
222.0 
 
18.7 
 
394,63 
 
2.94 
 
33.4 
 

 
 
6 
 
0,08829 
 
12.5 
 
7.87 
 
Nein 
 
0,524 
 
6.012 
 
66.6 
 
5.5605 
 
5.0 
 
311.0 
 
15.2 
 
395,60 
 
12.43 
 
22.9 
 

 
 
7 
 
0,14455 
 
12.5 
 
7.87 
 
Nein 
 
0,524 
 
6.172 
 
96.1 
 
5.9505 
 
5.0 
 
311.0 
 
15.2 
 
396,90 
 
19.15 
 
27.1 
 

 

 

Daten sind unordentlich; Es ist oft unausgeglichen und mit Ausreißerwerten übersät, die die Analyse und das Training für maschinelles Lernen beeinträchtigen.
Der erste Schritt, um das Dataset zu bereinigen, besteht darin, zu verstehen, wo es bereinigt werden muss. Das Bereinigen eines Datensatzes kann schwierig sein, insbesondere auf verallgemeinerbare Weise
Das Google Research-Team hat für diesen Job ein Tool namens Facets entwickelt , mit dessen Hilfe die Daten visualisiert und auf alle möglichen Arten in Scheiben geschnitten werden können. Dies ist ein guter Ausgangspunkt, um zu verstehen, wie der Datensatz aufgebaut ist.
Mithilfe von Facetten können Sie feststellen, wo die Daten nicht ganz so aussehen, wie Sie denken.
Mit Ausnahme der Web-App macht es Google einfach, das Toolkit in ein Jupyter-Notizbuch einzubetten.
Facetten bestehen aus zwei Teilen:

Facettenübersicht


Facetten Deep Dive


Facettenübersicht
Facettenübersicht gibt einen Überblick über den Datensatz. Facettenübersicht teilt die Datenspalten in Zeilen mit wichtigen Informationen auf

der Prozentsatz der fehlenden Beobachtung
Min- und Max-Werte
Statistiken wie Mittelwert, Median und Standardabweichung.
Außerdem wird eine Spalte hinzugefügt, in der der Prozentsatz der Werte angezeigt wird, bei denen es sich um Nullen handelt. Dies ist hilfreich, wenn die meisten Werte Nullen sind.
Es ist möglich, diese Verteilungen im Testdatensatz sowie im Trainingssatz für jede Funktion anzuzeigen. Dies bedeutet, dass Sie überprüfen können, ob der Test eine ähnliche Verteilung wie die Trainingsdaten aufweist.

Dies ist mindestens das Minimum, das vor einer maschinellen Lernaufgabe zu tun ist. Mit diesem Tool verpassen Sie diesen entscheidenden Schritt nicht und es werden einige Anomalien hervorgehoben.

Facetten Deep Dive
Facets Deep Dive ist ein cooles Tool. Dies ermöglicht eine gewisse Klarheit Ihres Datensatzes und das Vergrößern, um ein einzelnes Datenelement anzuzeigen. Dies bedeutet, dass Sie die Daten zeilen- und spaltenweise über alle Funktionen des Datasets hinweg facettieren können.
Wir werden diese beiden Tools mit dem Boston-Datensatz verwenden.
Hinweis : Sie können Facets Overview und Facets Deep Dive nicht gleichzeitig verwenden. Sie müssen zuerst das Notizbuch löschen, um das Werkzeug zu wechseln.

Installieren Sie Facet
Sie können die Facet-Web-App für den größten Teil der Analyse verwenden. In diesem Tutorial erfahren Sie, wie Sie es in einem Jupyter-Notizbuch verwenden.
Zunächst müssen Sie nbextensions installieren. Es wird mit diesem Code gemacht. Sie kopieren den folgenden Code und fügen ihn in das Terminal Ihres Geräts ein.
pip install jupyter_contrib_nbextensions 
Gleich danach müssen Sie die Repositorys auf Ihrem Computer klonen. Sie haben zwei Möglichkeiten:
Option 1) Kopieren Sie diesen Code und fügen Sie ihn in das Terminal ein (empfohlen).
Wenn Sie Git nicht auf Ihrem Computer installiert haben, rufen Sie diese URL https://git-scm.com/download/win auf und befolgen Sie die Anweisungen. Sobald Sie fertig sind, können Sie den Befehl git im Terminal für Mac-Benutzer oder die Anaconda-Eingabeaufforderung für Windows-Benutzer verwenden
git clone https://github.com/PAIR-code/facets 
Option 2) Gehen Sie zu https://github.com/PAIR-code/facets und laden Sie die Repositorys herunter.

Wenn Sie die erste Option auswählen, wird die Datei in Ihrer Download-Datei gespeichert. Sie können die Datei entweder herunterladen lassen oder auf einen anderen Pfad ziehen.
Mit dieser Befehlszeile können Sie überprüfen, wo Facetten gespeichert sind:
echo `pwd`/`ls facets` 
Nachdem Sie Facetten gefunden haben, müssen Sie es in Jupyter Notebook installieren. Sie müssen das Arbeitsverzeichnis auf den Pfad einstellen, in dem sich die Facetten befinden.
Ihr aktuelles Arbeitsverzeichnis und der Speicherort von Facets zip sollten identisch sein.

Sie müssen das Arbeitsverzeichnis auf Facet verweisen:
cd facets
Um Facetten in Jupyter zu installieren, haben Sie zwei Möglichkeiten. Wenn Sie Jupyter mit Conda für alle Benutzer installiert haben, kopieren Sie diesen Code:
kann jupyter nbextension verwenden install facets-dist /
jupyter nbextension install facets-dist/
Andernfalls verwenden Sie:
jupyter nbextension install facets-dist/ --user
Alles klar, Sie sind fertig. Öffnen wir die Facettenübersicht.

Überblick
Übersicht verwendet ein Python-Skript, um die Statistiken zu berechnen. Sie müssen das Skript generic_feature_statistics_generator in Jupyter importieren. Mach dir keine Sorgen; Das Skript befindet sich in den Facettendateien.
Sie müssen seinen Pfad finden. Es ist leicht zu machen. Sie öffnen Facetten, öffnen die Datei facets_overview und dann Python. Kopieren Sie den Pfad

Kehren Sie danach zu Jupyter zurück und schreiben Sie den folgenden Code. Ändern Sie den Pfad '/ Users / Thomas / facets / facets_overview / python' in Ihren Pfad.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Sie können das Skript mit dem folgenden Code importieren.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
In Windows wird der gleiche Code
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Um die Feature-Statistik zu berechnen, müssen Sie die Funktion GenericFeatureStatisticsGenerator () und das Objekt ProtoFromDataFrames verwenden. Sie können den Datenrahmen in einem Wörterbuch übergeben. Wenn wir beispielsweise eine zusammenfassende Statistik für den Zugsatz erstellen möchten, können wir die Informationen in einem Wörterbuch speichern und im Objekt "ProtoFromDataFrames" verwenden


'name': 'train', 'table': df_train 

Name ist der Name der Tabellenanzeige, und Sie verwenden den Namen der Tabelle, für die Sie die Zusammenfassung berechnen möchten. In Ihrem Beispiel lautet die Tabelle mit den Daten df_train
# Calculate the feature statistics proto from the datasets and stringify it for use in facets overviewimport base64gfsg = GenericFeatureStatisticsGenerator()proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train},{'name': 'test', 'table': df_test}])#proto = gfsg.ProtoFromDataFrames([{'name': 'train', 'table': df_train}])protostr = base64.b64encode(proto.SerializeToString()).decode("utf-8")
Zuletzt kopieren Sie einfach den folgenden Code und fügen ihn ein. Der Code kommt direkt von GitHub. Sie sollten dies sehen können:

# Display the facets overview visualization for this data# Displfrom IPython.core.display import display, HTMLHTML_TEMPLATE = """
"""html = HTML_TEMPLATE.format(protostr=protostr)display(HTML(html))
 
Graph
Nachdem Sie die Daten und ihre Verteilung überprüft haben, können Sie eine Korrelationsmatrix zeichnen. Die Korrelationsmatrix berechnet den Pearson-Koeffizienten. Dieser Koeffizient ist zwischen -1 und 1 gebunden, wobei ein positiver Wert eine positive Korrelation und ein negativer Wert eine negative Korrelation anzeigt.
Sie sind interessiert zu sehen, welche Variablen ein guter Kandidat für Interaktionsterme sein können.
## Choose important feature and further check with Dive%matplotlib inlineimport matplotlib.pyplot as pltimport seaborn as snssns.set(style="ticks")# Compute the correlation matrixcorr = df.corr('pearson')# Generate a mask for the upper trianglemask = np.zeros_like(corr, dtype=np.bool)mask[np.triu_indices_from(mask)] = True# Set up the matplotlib figuref, ax = plt.subplots(figsize=(11, 9))# Generate a custom diverging colormapcmap = sns.diverging_palette(220, 10, as_cmap=True)# Draw the heatmap with the mask and correct aspect ratiosns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,square=True, linewidths=.5, cbar_kws={"shrink": .5})
Ausgabe 

png

Aus der Matrix können Sie sehen:

LSTAT
RM

Sind stark mit dem Preis korreliert. Ein weiteres aufregendes Merkmal ist die starke positive Korrelation zwischen NOX und INDUS, was bedeutet, dass sich diese beiden Variablen in die gleiche Richtung bewegen. Daneben gibt es auch korrelierte mit dem PREIS. DIS ist auch stark mit IND und NOX korreliert.
Sie haben einen ersten Hinweis darauf, dass IND und NOX gute Kandidaten für den Intercept-Begriff sein können und dass es auch interessant sein könnte, sich auf DIS zu konzentrieren.
Sie können etwas tiefer gehen, indem Sie ein Paargitter zeichnen. Die zuvor gezeichnete Korrelationskarte wird detaillierter dargestellt.
Das Paarraster besteht wie folgt:

Oberer Teil: Streudiagramm mit angepasster Linie
Diagonale: Kerndichtediagramm
Unterer Teil: Multivariates Kernel-Dichtediagramm

Sie wählen den Fokus auf vier unabhängige Variablen. Die Auswahl entspricht den Variablen mit starker Korrelation mit PRICE

INDUS
NOX
RM
LSTAT

außerdem der PREIS.
Beachten Sie, dass der Standardfehler standardmäßig zum Streudiagramm hinzugefügt wird.
attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"]g = sns.PairGrid(df[attributes])g = g.map_upper(sns.regplot, color="g")g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False)g = g.map_diag(sns.kdeplot)
Ausgabe 

Beginnen wir mit dem oberen Teil:

Der Preis korreliert negativ mit INDUS, NOX und LSTAT. positiv korreliert mit RM.
Es gibt eine leichte Nichtlinearität mit LSTAT und PRICE
Es ist wie eine gerade Linie, wenn der Preis gleich 50 ist. Aus der Beschreibung des Datensatzes geht hervor, dass PRICE auf den Wert 50 gekürzt wurde

Diagonale

NOX scheint zwei Cluster zu haben, einen um 0,5 und einen um 0,85.

Um mehr darüber zu erfahren, können Sie sich den unteren Teil ansehen. Die multivariate Kerneldichte ist in gewissem Sinne interessant, da sie dort färbt, wo sich die meisten Punkte befinden. Der Unterschied zum Streudiagramm zeichnet eine Wahrscheinlichkeitsdichte, obwohl der Datensatz für eine bestimmte Koordinate keinen Punkt enthält. Wenn die Farbe stärker ist, zeigt dies eine hohe Punktkonzentration um diesen Bereich an.
Wenn Sie die multivariate Dichte für INDUS und NOX überprüfen, sehen Sie die positive Korrelation und die beiden Cluster. Wenn der Anteil der Industrie über 18 liegt, liegt die Stickoxidkonzentration über 0,6.
Sie können darüber nachdenken, eine Interaktion zwischen INDUS und NOX in die lineare Beziehung einzufügen.
Schließlich können Sie das zweite von Google erstellte Tool, Facets Deep Dive, verwenden. Die Schnittstelle ist in vier Hauptabschnitte unterteilt. Der zentrale Bereich in der Mitte ist eine zoombare Anzeige der Daten. Oben im Bedienfeld befindet sich das Dropdown-Menü, in dem Sie die Anordnung der Daten ändern können, um Facettierung, Positionierung und Farbe zu steuern. Rechts sehen Sie eine Detailansicht einer bestimmten Datenzeile. Dies bedeutet, dass Sie auf einen beliebigen Datenpunkt in der mittleren Visualisierung klicken können, um die Details zu diesem bestimmten Datenpunkt anzuzeigen.
Während des Datenvisualisierungsschritts möchten Sie nach der paarweisen Korrelation zwischen der unabhängigen Variablen und dem Preis des Hauses suchen. Es handelt sich jedoch um mindestens drei Variablen, und die Arbeit mit 3D-Plots ist kompliziert.
Eine Möglichkeit, dieses Problem anzugehen, besteht darin, eine kategoriale Variable zu erstellen. Das heißt, wir können ein 2D-Diagramm mit einer Farbe für den Punkt erstellen. Sie können die Variable PRICE in vier Kategorien aufteilen, wobei jede Kategorie ein Quartil ist (dh 0,25, 0,5, 0,75). Sie nennen diese neue Variable Q_PRICE.
## Check non linearity with important featuresdf['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])## Show non linearity between RM and LSTATax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")


Facetten Deep Dive
Um Deep Dive zu öffnen, müssen Sie die Daten in ein JSON-Format umwandeln. Pandas als Objekt dafür. Sie können to_json nach dem Pandas-Dataset verwenden.
Die erste Codezeile behandelt die Größe des Datasets.
df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"])sprite_size = 32 if len(df.index)>50000 else 64jsonstr = df.to_json(orient='records')
Der folgende Code stammt von Google GitHub. Nachdem Sie den Code ausgeführt haben, sollte Folgendes angezeigt werden:

# Display thde Dive visualization for this datafrom IPython.core.display import display, HTML# Create Facets templateHTML_TEMPLATE = """
"""# Load the json dataset and the sprite_size into the templatehtml = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)# Display the templatedisplay(HTML(html))
Sie sind interessiert zu sehen, ob es einen Zusammenhang zwischen der Branchenrate, der Oxidkonzentration, der Entfernung zum Jobcenter und dem Preis des Hauses gibt.
Dazu teilen Sie zunächst die Daten nach Branchenbereich und Farbe mit dem Preisquartil auf:

Wählen Sie Facettieren X und wählen Sie INDUS.
Wählen Sie Anzeige und dann DIS. Es färbt die Punkte mit dem Quartil des Hauspreises

Hier bedeuten dunklere Farben, dass die Entfernung zum ersten Jobcenter weit ist.
Bisher zeigt es wieder, was Sie wissen, niedrigere Branchenrate, höherer Preis. Jetzt können Sie sich die Aufschlüsselung nach INDUX und NOX ansehen.

Wählen Sie Facettierung Y und NOX.

Jetzt können Sie sehen, dass das Haus weit entfernt vom ersten Jobcenter den niedrigsten Branchenanteil und damit die niedrigste Oxidkonzentration aufweist. Wenn Sie den Typ mit Q_PRICE anzeigen und die untere linke Ecke zoomen, können Sie sehen, um welche Art von Preis es sich handelt.
Sie haben einen weiteren Hinweis darauf, dass die Interaktion zwischen IND, NOX und DIS gute Kandidaten für die Verbesserung des Modells sein kann.

TensorFlow
In diesem Abschnitt schätzen Sie den linearen Klassifikator mit der TensorFlow-Schätzer-API. Sie werden wie folgt vorgehen:

Bereiten Sie die Daten vor
Schätzen Sie ein Benchmark-Modell: Keine Interaktion
Schätzen Sie ein Modell mit Interaktion

Denken Sie daran, dass das Ziel des maschinellen Lernens darin besteht, den Fehler zu minimieren. In diesem Fall gewinnt das Modell mit dem niedrigsten mittleren quadratischen Fehler. Der TensorFlow-Schätzer berechnet diese Metrik automatisch.
Vorbereitungsdaten
In den meisten Fällen müssen Sie Ihre Daten transformieren. Deshalb ist Facettenübersicht faszinierend. In der zusammenfassenden Statistik haben Sie gesehen, dass es Ausreißer gibt. Diese Werte wirken sich auf die Schätzungen aus, da sie nicht der von Ihnen analysierten Population entsprechen. Ausreißer haben die Ergebnisse normalerweise verzerrt. Beispielsweise neigt ein positiver Ausreißer dazu, den Koeffizienten zu überschätzen.
Eine gute Lösung, um dieses Problem anzugehen, besteht darin, die Variable zu standardisieren. Standardisierung bedeutet eine Standardabweichung von Eins und Mittel von Null. Der Standardisierungsprozess umfasst zwei Schritte. Zunächst wird der Mittelwert der Variablen subtrahiert. Zweitens wird es durch die Varianz dividiert, so dass die Verteilung eine Einheitsvarianz aufweist
Die Bibliothek sklearn ist hilfreich, um Variablen zu standardisieren. Zu diesem Zweck können Sie die Modulvorverarbeitung mit der Objektskala verwenden.
Mit der folgenden Funktion können Sie einen Datensatz skalieren. Beachten Sie, dass Sie die Beschriftungsspalte und die kategorialen Variablen nicht skalieren.
from sklearn import preprocessingdef standardize_data(df):X_scaled = preprocessing.scale(df[['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']])X_scaled_df = pd.DataFrame(X_scaled, columns = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'])df_scale = pd.concat([X_scaled_df,df['CHAS'],df['PRICE']],axis=1, join='inner')return df_scale
Mit dieser Funktion können Sie das skalierte Zug- / Test-Set erstellen.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Grundlegende Regression: Benchmark
Zunächst trainieren und testen Sie ein Modell ohne Interaktion. Der Zweck besteht darin, die Leistungsmetrik des Modells anzuzeigen.
Die Art und Weise, das Modell zu trainieren, entspricht genau dem Tutorial zur High-Level-API . Sie verwenden den TensorFlow-Schätzer LinearRegressor.
Zur Erinnerung müssen Sie Folgendes auswählen:

die Funktionen, die in das Modell eingefügt werden sollen
transformieren Sie die Funktionen
konstruiere den linearen Regressor
Konstruieren Sie die Funktion input_fn
trainiere das Modell
Testen Sie das Modell

Sie verwenden alle Variablen im Datensatz, um das Modell zu trainieren. Insgesamt gibt es elf kontinuierliche Variablen und eine kategoriale Variable
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Sie konvertieren die Features in eine numerische Spalte oder eine kategoriale Spalte
continuous_features = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES]#categorical_features = tf.feature_column.categorical_column_with_hash_bucket(CATE_FEATURES, hash_bucket_size=1000)categorical_features = [tf.feature_column.categorical_column_with_vocabulary_list('CHAS', ['yes','no'])]
Sie erstellen das Modell mit dem linearRegressor. Sie speichern das Modell im Ordner train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Ausgabe 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston', '_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}
Jede Spalte in den Zug- oder Testdaten wird mit der Funktion get_input_fn in einen Tensor konvertiert
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']LABEL= 'PRICE'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)
Sie schätzen das Modell anhand der Zugdaten.
model.train(input_fn=get_input_fn(df_train_scale,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_Boston/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 144.457INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec)INFO:tensorflow:global_step/sec: 258.392INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec)INFO:tensorflow:global_step/sec: 227.998INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec)INFO:tensorflow:global_step/sec: 210.739INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec)INFO:tensorflow:global_step/sec: 234.237INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec)INFO:tensorflow:global_step/sec: 238.1INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec)INFO:tensorflow:global_step/sec: 237.934INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec)INFO:tensorflow:global_step/sec: 220.687INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec)INFO:tensorflow:global_step/sec: 232.702INFO:tensorflow:loss = 24049.678, step = 901 (0.432 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston/model.ckpt.INFO:tensorflow:Loss for final step: 23228.568.
Zuletzt schätzen Sie die Leistung des Modells auf dem Testsatz
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Ausgabe 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:40:43INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43INFO:tensorflow:Saving dict for global step 1000: average_loss = 86.89361, global_step = 1000, loss = 1650.9785{'average_loss': 86.89361, 'global_step': 1000, 'loss': 1650.9785}
Der Verlust des Modells beträgt 1650. Dies ist die Metrik, die im nächsten Abschnitt zu schlagen ist

Modell verbessern: Interaktionsbegriff
Im ersten Teil des Tutorials haben Sie eine interessante Beziehung zwischen den Variablen gesehen. Die verschiedenen Visualisierungstechniken haben gezeigt, dass INDUS und NOS miteinander verbunden sind und sich drehen, um die Auswirkungen auf den Preis zu verstärken. Nicht nur die Interaktion zwischen INDUS und NOS beeinflusst den Preis, sondern auch dieser Effekt ist stärker, wenn er mit DIS interagiert.
Es ist Zeit, diese Idee zu verallgemeinern und zu prüfen, ob Sie das vorhergesagte Modellmodell verbessern können.
Sie müssen jedem Datensatz zwei neue Spalten hinzufügen: train + test. Dazu erstellen Sie eine Funktion zur Berechnung des Interaktionsterms und eine andere zur Berechnung des Dreifachinteraktionsterms. Jede Funktion erzeugt eine einzelne Spalte. Nachdem die neuen Variablen erstellt wurden, können Sie sie mit dem Trainingsdatensatz und dem Testdatensatz verknüpfen.
Zunächst müssen Sie eine neue Variable für die Interaktion zwischen INDUS und NOX erstellen.
Die folgende Funktion gibt zwei Datenrahmen zurück, train und test, mit der Interaktion zwischen var_1 und var_2, in Ihrem Fall INDUS und NOX.
def interaction_term(var_1, var_2, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]test = t_test.rename(name)return train, test
Sie speichern die beiden neuen Spalten
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
Zweitens erstellen Sie eine zweite Funktion, um den Term der dreifachen Interaktion zu berechnen.
def triple_interaction_term(var_1, var_2,var_3, name):t_train = df_train_scale[var_1]*df_train_scale[var_2]*df_train_scale[var_3]train = t_train.rename(name)t_test = df_test_scale[var_1]*df_test_scale[var_2]*df_test_scale[var_3]test = t_test.rename(name)return train, testinteration_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
Nachdem Sie alle benötigten Spalten haben, können Sie sie zum Trainieren und Testen des Datensatzes hinzufügen. Sie nennen diese beiden neuen Datenrahmen:

df_train_new
df_test_new

df_train_new = pd.concat([df_train_scale,interation_ind_ns_train,interation_ind_ns_dis_train],axis=1, join='inner')df_test_new = pd.concat([df_test_scale,interation_ind_ns_test,interation_ind_ns_dis_test],axis=1, join='inner')df_train_new.head(5)
Ausgabe 

Das ist es; Sie können das neue Modell mit den Interaktionstermen schätzen und sehen, wie die Leistungsmetrik ist.
CONTI_FEATURES_NEW = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS']### Define categorical listcontinuous_features_new = [tf.feature_column.numeric_column(k) for k in CONTI_FEATURES_NEW]model = tf.estimator.LinearRegressor(model_dir="train_Boston_1",feature_columns= categorical_features + continuous_features_new)
Ausgabe 
INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train_Boston_1', '_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}
CODE
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']LABEL= 'PRICE'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)
 
model.train(input_fn=get_input_fn(df_train_new,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_Boston_1/model.ckpt.INFO:tensorflow:loss = 56417.703, step = 1INFO:tensorflow:global_step/sec: 124.844INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec)INFO:tensorflow:global_step/sec: 182.704INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec)INFO:tensorflow:global_step/sec: 208.189INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec)INFO:tensorflow:global_step/sec: 213.855INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec)INFO:tensorflow:global_step/sec: 209.758INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec)INFO:tensorflow:global_step/sec: 196.618INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec)INFO:tensorflow:global_step/sec: 196.472INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec)INFO:tensorflow:global_step/sec: 172.82INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec)INFO:tensorflow:global_step/sec: 168.916INFO:tensorflow:loss = 19878.56, step = 901 (0.592 sec)INFO:tensorflow:Saving checkpoints for 1000 into train_Boston_1/model.ckpt.INFO:tensorflow:Loss for final step: 19598.387.
 
model.evaluate(input_fn=get_input_fn(df_test_new,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Ausgabe 
INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-29-02:41:14INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14INFO:tensorflow:Saving dict for global step 1000: average_loss = 79.78876, global_step = 1000, loss = 1515.9863{'average_loss': 79.78876, 'global_step': 1000, 'loss': 1515.9863}
Der neue Verlust beträgt 1515. Durch Hinzufügen von zwei neuen Variablen konnten Sie den Verlust verringern. Dies bedeutet, dass Sie eine bessere Vorhersage treffen können als mit dem Benchmark-Modell.