TensorFlow lineaire regressie met Facet & Interactietermijn

In deze tutorial leert u hoe u de gegevens controleert en voorbereidt om een ​​eenvoudige lineaire regressietaak te maken.

Deze tutorial is opgedeeld in twee delen:

• Zoek naar interactie
• Test het model

In de vorige tutorial heb je de Boston-dataset gebruikt om de gemiddelde prijs van een huis te schatten. De Boston-dataset heeft een kleine omvang, met slechts 506 waarnemingen. Deze dataset wordt beschouwd als een benchmark om nieuwe lineaire regressie-algoritmen uit te proberen.

De dataset is samengesteld uit:

Variabel	Omschrijving
zn	Het aandeel van woongrond bestemd voor kavels van meer dan 25.000 m2.
indus	Het aandeel niet-detailhandelsoppervlakte per stad.
nox	stikstofoxiden concentratie
rm	gemiddeld aantal kamers per woning
leeftijd	het aandeel koopwoningen gebouwd voor 1940
dis	gewogen afstanden tot vijf arbeidsbureaus in Boston
belasting	onroerende voorheffing over de volledige waarde per 10.000 dollar
ptratio	de leerling-leraar ratio per stad
medv	De mediaanwaarde van koopwoningen in duizend dollar
criminaliteit	criminaliteit per hoofd van de bevolking per stad
chas	Charles River dummy-variabele (1 als rivier begrenst; 0 anders)
B.	het aandeel zwarten in de stad

In deze tutorial zullen we de mediaanprijs schatten met behulp van een lineaire regressor, maar de focus ligt op een bepaald proces van machine learning: "gegevensvoorbereiding".

Een model generaliseert het patroon in de gegevens. Om een ​​dergelijk patroon vast te leggen, moet u het eerst vinden. Een goede gewoonte is om een ​​gegevensanalyse uit te voeren voordat u een algoritme voor machine learning uitvoert.

Het kiezen van de juiste functies maakt het verschil in het succes van uw model. Stel je voor dat je het loon van een volk probeert te schatten, als je het geslacht niet als covariaat meetelt, krijg je een slechte schatting.

Een andere manier om het model te verbeteren, is door te kijken naar de correlatie tussen de onafhankelijke variabele. Terug naar het voorbeeld, je kunt onderwijs zien als een uitstekende kandidaat om het loon maar ook de bezetting te voorspellen. Het is eerlijk om te zeggen dat het beroep afhankelijk is van het opleidingsniveau, namelijk hoger onderwijs leidt vaak tot een beter beroep. Als we dit idee generaliseren, kunnen we zeggen dat de correlatie tussen de afhankelijke variabele en een verklarende variabele kan worden vergroot tot nog een andere verklarende variabele.

Om het beperkte effect van opleiding op beroep vast te leggen, kunnen we een interactieterm gebruiken.

Als je naar de loonvergelijking kijkt, wordt het:

Als positief is, dan impliceert dit dat een extra opleiding een hogere stijging van de mediaanwaarde van een woning bij een hoge bezettingsgraad oplevert. Met andere woorden, er is een wisselwerking tussen opleiding en beroep.

In deze tutorial zullen we proberen te zien welke variabelen een goede kandidaat kunnen zijn voor interactietermen. We zullen testen of het toevoegen van dit soort informatie leidt tot een betere prijsvoorspelling.

In deze tutorial leer je

• Samenvattende statistieken
• Facetten overzicht
• Facetten diepe duik
• Installeer Facet
• Overzicht
• Grafiek
• Facetten diepe duik
• TensorFlow
• Voorbereidingsgegevens
• Basisregressie: benchmark
• Verbeter het model: Interactieterm

Samenvattende statistieken

Er zijn een paar stappen die u kunt volgen voordat u doorgaat naar het model. Zoals eerder vermeld, is het model een generalisatie van de gegevens. De beste methode is om de gegevens te begrijpen en een voorspelling te doen. Als u uw gegevens niet kent, heeft u kleine kansen om uw model te verbeteren.

Laad als eerste stap de gegevens als een pandas-dataframe en maak een trainingsset en testset.

Tips: voor deze tutorial moeten matplotlit en seaborn in Python zijn geïnstalleerd. U kunt het Python-pakket on-the-fly installeren met Jupyter. U dient dit niet te doen

!conda install -- yes matplotlib

maar

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

Merk op dat deze stap niet nodig is als u matplotlib en seaborn hebt geïnstalleerd.

Matplotlib is de bibliotheek om een ​​grafiek in Python te maken. Seaborn is een statistische visualisatiebibliotheek die bovenop matplotlib is gebouwd. Het levert aantrekkelijke en mooie kavels op.

De onderstaande code importeert de benodigde bibliotheken.

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

De bibliotheek sklearn bevat de Boston-gegevensset. U kunt de API aanroepen om de gegevens te importeren.

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

De naam van het element wordt opgeslagen in het object feature_names in een array.

boston.feature_names

Uitvoer

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
U kunt de kolommen hernoemen.


df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

U converteert de variabele CHAS naar een stringvariabele en labelt deze met ja als CHAS = 1 en nee als CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Met panda's is het eenvoudig om de dataset te splitsen. U verdeelt de dataset willekeurig met 80 procent trainingsset en 20 procent testset. Panda's hebben een ingebouwde kostenfunctie om een ​​dataframesample te splitsen.
De eerste parameter frac is een waarde van 0 tot 1. U stelt deze in op 0,8 om willekeurig 80 procent van het dataframe te selecteren.
Met Random_state kan voor iedereen hetzelfde dataframe worden geretourneerd.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
U kunt de vorm van de gegevens krijgen. Het zou moeten zijn:

Treinset: 506 * 0,8 = 405
Testset: 506 * 0,2 = 101

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

 
 
 
 
CRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
LEEFTIJD 
 
DIS 
 
RAD 
 
BELASTING 
 
PTRATIO 
 
B. 
 
LSTAT 
 
PRIJS 
 

 
 
0 
 
0,00632 
 
18,0 
 
2.31 
 
Nee 
 
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 
 
Nee 
 
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 
 
Nee 
 
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 
 
Nee 
 
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 
 
Nee 
 
0,524 
 
6.172 
 
96,1 
 
5.9505 
 
5.0 
 
311,0 
 
15.2 
 
396,90 
 
19.15 
 
27.1 
 

 

 

Gegevens zijn rommelig; het is vaak uit balans en besprenkeld met uitbijterwaarden die de analyse en machine learning-training in de weg staan.
De eerste stap om de dataset op te schonen, is begrijpen waar deze moet worden opgeschoond. Het opschonen van een dataset kan lastig zijn, vooral op een generaliseerbare manier
Het Google Research-team heeft voor deze taak een tool ontwikkeld met de naam Facets die helpt om de gegevens te visualiseren en op allerlei manieren te splitsen. Dit is een goed startpunt om te begrijpen hoe de dataset is ingedeeld.
Met facetten kunt u vinden waar de gegevens er niet helemaal uitzien zoals u denkt.
Met uitzondering van hun webapp, maakt Google het gemakkelijk om de toolkit in een Jupyter-notebook in te sluiten.
Facetten bestaat uit twee delen:

Facetten overzicht


Facetten diepe duik


Facetten overzicht
Facets Overview geeft een overzicht van de dataset. Facettenoverzicht splitst de kolommen van de gegevens op in rijen met opvallende informatie die wordt weergegeven

het percentage ontbrekende waarneming
min en max waarden
statistieken zoals het gemiddelde, de mediaan en de standaarddeviatie.
Het voegt ook een kolom toe die het percentage waarden toont dat nullen zijn, wat handig is als de meeste waarden nullen zijn.
Het is mogelijk om deze distributies in de testdataset te zien, evenals de trainingsset voor elke functie. Dit betekent dat u kunt controleren of de test een vergelijkbare verdeling heeft als de trainingsgegevens.

Dit is in ieder geval het minimum dat u moet doen vóór elke machine learning-taak. Met deze tool mis je deze cruciale stap niet en worden enkele afwijkingen aan het licht gebracht.

Facetten diepe duik
Facets Deep Dive is een coole tool. Het geeft enige duidelijkheid over uw dataset en zoom helemaal in om een ​​individueel stukje data te zien. Dit betekent dat u de gegevens per rij en kolom kunt facetten voor elk van de kenmerken van de gegevensset.
We zullen deze twee tools gebruiken met de Boston-dataset.
Opmerking : u kunt Facets Overview en Facets Deep Dive niet tegelijkertijd gebruiken. U moet eerst het notitieblok leegmaken om het gereedschap te wijzigen.

Installeer Facet
U kunt de Facet-webapp gebruiken voor het grootste deel van de analyse. In deze zelfstudie leert u hoe u deze kunt gebruiken in een Jupyter Notebook.
Allereerst moet u nbextensions installeren. Het is gedaan met deze code. U kopieert en plakt de volgende code in de terminal van uw machine.
pip install jupyter_contrib_nbextensions 
Direct daarna moet u de opslagplaatsen op uw computer klonen. U heeft twee keuzes:
Optie 1) Kopieer en plak deze code in de terminal (aanbevolen)
Als je Git niet op je computer hebt geïnstalleerd, ga dan naar deze URL https://git-scm.com/download/win en volg de instructies. Als je klaar bent, kun je het git-commando in de terminal gebruiken voor Mac-gebruikers of Anaconda-prompt voor Windows-gebruikers
git clone https://github.com/PAIR-code/facets 
Optie 2) Ga naar https://github.com/PAIR-code/facets en download de repositories.

Als je de eerste optie kiest, komt het bestand in je downloadbestand terecht. U kunt het bestand downloaden of naar een ander pad slepen.
U kunt met deze opdrachtregel controleren waar Facets zijn opgeslagen:
echo `pwd`/`ls facets` 
Nu u Facets heeft gelokaliseerd, moet u deze in Jupyter Notebook installeren. U moet de werkmap instellen op het pad waar de facetten zich bevinden.
Uw huidige werkmap en locatie van Facets zip zouden hetzelfde moeten zijn.

U moet de werkmap naar Facet verwijzen:
cd facets
Om Facets in Jupyter te installeren, heb je twee opties. Als je Jupyter met Conda voor alle gebruikers hebt geïnstalleerd, kopieer dan deze code:
kan jupyter nbextension gebruiken install facets-dist /
jupyter nbextension install facets-dist/
Gebruik anders:
jupyter nbextension install facets-dist/ --user
Oké, je bent helemaal klaar. Laten we Facet-overzicht openen.

Overzicht
Overzicht gebruikt een Python-script om de statistieken te berekenen. U moet het script met de naam generic_feature_statistics_generator in Jupyter importeren. Maak je geen zorgen; het script bevindt zich in de facetbestanden.
U moet het pad vinden. Het is gemakkelijk te doen. Je opent facetten, opent het bestand facets_overview en vervolgens python. Kopieer het pad

Ga daarna terug naar Jupyter en schrijf de volgende code. Verander het pad '/ Users / Thomas / facets / facets_overview / python' naar jouw pad.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
U kunt het script importeren met de onderstaande code.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
In Windows wordt dezelfde code
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Om de feature-statistieken te berekenen, moet je de functie GenericFeatureStatisticsGenerator () gebruiken, en je gebruikt het object ProtoFromDataFrames. U kunt het dataframe in een woordenboek doorgeven. Als we bijvoorbeeld een samenvattende statistiek voor de treinset willen maken, kunnen we de informatie in een woordenboek opslaan en deze gebruiken in het object `` ProtoFromDataFrames ''


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

Naam is de naam van de tabeldisplays en u gebruikt de naam van de tabel waarvan u de samenvatting wilt berekenen. In uw voorbeeld is de tabel met de gegevens 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")
Ten slotte kopieer en plak je de onderstaande code. De code komt rechtstreeks van GitHub. Je zou dit moeten kunnen zien:

# 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))
 
Grafiek
Nadat u de gegevens en hun distributie hebt gecontroleerd, kunt u een correlatiematrix uitzetten. De correlatiematrix berekent de Pearson-coëfficiënt. Deze coëfficiënt is gebonden tussen -1 en 1, waarbij een positieve waarde een positieve correlatie aangeeft en een negatieve waarde een negatieve correlatie.
U bent benieuwd welke variabelen een goede kandidaat kunnen zijn voor interactietermen.
## 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})
Uitvoer 

png

Uit de matrix kun je zien:

LSTAT
RM

Zijn sterk gecorreleerd met PRIJS. Een ander opwindend kenmerk is de sterke positieve correlatie tussen NOX en INDUS, wat betekent dat deze twee variabelen in dezelfde richting bewegen. Trouwens, er zijn ook gecorreleerd met de PRIJS. DIS is ook sterk gecorreleerd met IND en NOX.
U heeft een eerste aanwijzing dat IND en NOX goede kandidaten kunnen zijn voor de onderscheppingstermijn en DIS kan ook interessant zijn om op te focussen.
Je kunt een beetje dieper gaan door een paarraster uit te zetten. Het zal de correlatiekaart die u eerder hebt geplot, meer in detail illustreren.
Het paarraster dat we als volgt zijn samengesteld:

Bovendeel: spreidingsplot met gemonteerde lijn
Diagonaal: plot van kerneldichtheid
Onderste deel: Multivariate kerneldichtheidplot

U kiest de focus op vier onafhankelijke variabelen. De keuze komt overeen met de variabelen met een sterke correlatie met PRIJS

INDUS
NOX
RM
LSTAT

bovendien de PRIJS.
Merk op dat de standaardfout standaard wordt toegevoegd aan de spreidingsplot.
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)
Uitvoer 

Laten we beginnen met het bovenste gedeelte:

De prijs is negatief gecorreleerd met INDUS, NOX en LSTAT; positief gecorreleerd met RM.
Er is een enigszins non-lineariteit met LSTAT en PRICE
Er is een soort rechte lijn wanneer de prijs gelijk is aan 50. Uit de beschrijving van de dataset is PRICE afgekapt op de waarde van 50

Diagonaal

NOX lijkt twee clusters te hebben, een rond 0,5 en een rond 0,85.

Om er meer over te weten, kun je naar het onderste gedeelte kijken. De Multivariate Kernel Density is interessant in zekere zin dat het kleurt waar de meeste punten zijn. Het verschil met de scatterplot tekent een waarschijnlijkheidsdichtheid, ook al is er geen punt in de dataset voor een gegeven coördinaat. Als de kleur sterker is, duidt dit op een hoge puntconcentratie rond dit gebied.
Als je de multivariate dichtheid voor INDUS en NOX controleert, zie je de positieve correlatie en de twee clusters. Wanneer het aandeel van de industrie hoger is dan 18, is de stikstofoxidenconcentratie hoger dan 0,6.
U kunt nadenken over het toevoegen van een interactie tussen INDUS en NOX in de lineaire relatie.
Ten slotte kunt u de tweede tools gebruiken die door Google zijn gemaakt, Facets Deep Dive. De interface is onderverdeeld in vier hoofdsecties. Het centrale gebied in het midden is een inzoombare weergave van de gegevens. Bovenaan het paneel bevindt zich het vervolgkeuzemenu waar u de rangschikking van de gegevens kunt wijzigen om facetten, positionering en kleur te regelen. Aan de rechterkant is er een gedetailleerde weergave van een specifieke rij met gegevens. Dit betekent dat u op elk punt met gegevens in de middenvisualisatie kunt klikken om de details van dat specifieke gegevenspunt te zien.
Tijdens de datavisualisatiestap ben je geïnteresseerd in het zoeken naar de paarsgewijze correlatie tussen de onafhankelijke variabele op de prijs van het huis. Het omvat echter ten minste drie variabelen en 3D-plots zijn ingewikkeld om mee te werken.
Een manier om dit probleem aan te pakken, is door een categorische variabele te maken. Dat wil zeggen, we kunnen een 2D-plot maken door de stip in te kleuren. U kunt de variabele PRICE opsplitsen in vier categorieën, waarbij elke categorie een kwartiel is (dwz 0,25, 0,5, 0,75). U noemt deze nieuwe variabele 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 diepe duik
Om Deep Dive te openen, moet u de gegevens omzetten in een json-indeling. Panda's als object daarvoor. U kunt to_json gebruiken na de Pandas-gegevensset.
De eerste regel code behandelt de grootte van de dataset.
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')
De onderstaande code is afkomstig van Google GitHub. Nadat u de code hebt uitgevoerd, zou u dit moeten kunnen zien:

# 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))
U bent benieuwd of er een verband is tussen het bedrijfstarief, de oxideconcentratie, de afstand tot het arbeidsbureau en de prijs van de woning.
Daarvoor splitst u eerst de gegevens op branchebereik en kleur met het prijskwartiel:

Selecteer facetten X en kies INDUS.
Selecteer Weergave en kies DIS. Het kleurt de stippen met het kwartiel van de huizenprijs

hier betekenen donkere kleuren dat de afstand tot het eerste arbeidsbureau ver is.
Tot dusverre laat het opnieuw zien wat u weet, lager branchetarief, hogere prijs. Nu kunt u de uitsplitsing per INDUX, per NOX bekijken.

Selecteer facetten Y en kies NOX.

Nu zie je dat het huis ver van het eerste arbeidsbureau het laagste industrie-aandeel heeft en dus de laagste oxideconcentratie. Als u ervoor kiest om het type weer te geven met Q_PRICE en in de linkerbenedenhoek te zoomen, kunt u zien welk type prijs het is.
Je hebt nog een hint dat de interactie tussen IND, NOX en DIS goede kandidaten kan zijn om het model te verbeteren.

TensorFlow
In deze sectie zult u de lineaire classificator schatten met de TensorFlow-schatters-API. U gaat als volgt te werk:

Bereid de gegevens voor
Schat een benchmarkmodel: geen interactie
Schat een model met interactie

Onthoud dat het doel van machine learning is om de fout te minimaliseren. In dit geval wint het model met de laagste gemiddelde kwadratische fout. De TensorFlow-schatter berekent deze metriek automatisch.
Voorbereidingsgegevens
In de meeste gevallen moet u uw gegevens transformeren. Daarom is Facets Overview fascinerend. Uit de samenvattende statistiek zag je dat er uitschieters zijn. Deze waarden zijn van invloed op de schattingen omdat ze niet lijken op de populatie die u analyseert. Uitschieters vertekenden de resultaten meestal. Een positieve uitbijter heeft bijvoorbeeld de neiging de coëfficiënt te overschatten.
Een goede oplossing om dit probleem aan te pakken, is om de variabele te standaardiseren. Standaardisatie betekent een standaarddeviatie van één en het gemiddelde van nul. Het standaardisatieproces omvat twee stappen. Allereerst trekt het de gemiddelde waarde van de variabele af. Ten tweede wordt het gedeeld door de variantie, zodat de verdeling een eenheidsvariantie heeft
De bibliotheek sklearn is handig om variabelen te standaardiseren. U kunt hiervoor de module voorbewerking met de objectweegschaal gebruiken.
U kunt de onderstaande functie gebruiken om een ​​dataset te schalen. Merk op dat u de labelkolom en categorische variabelen niet schaalt.
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
U kunt de functie gebruiken om de geschaalde trein / testset te construeren.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Basisregressie: benchmark
Allereerst train en test je een model zonder interactie. Het doel is om de prestatiestatistiek van het model te zien.
De manier om het model te trainen is precies zoals de tutorial over High-level API . U gebruikt de TensorFlow-schatter LinearRegressor.
Ter herinnering: u moet kiezen:

de kenmerken die in het model moeten worden gestopt
transformeer de functies
construeer de lineaire regressor
construeer de input_fn functie
train het model
test het model

U gebruikt alle variabelen in de dataset om het model te trainen. In totaal zijn er continue variabelen op elniveau en één categorische variabele
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
U converteert de objecten naar een numerieke kolom of categorische kolom
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'])]
U maakt het model met de linearRegressor. Je slaat het model op in de map train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Uitvoer 
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}
Elke kolom in de trein- of testgegevens wordt omgezet in een Tensor met de functie get_input_fn
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)
U schat het model op de treindata.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Uitvoer 
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.
Ten slotte schat u de prestaties van het model op de testset in
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Uitvoer 
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}
Het verlies van het model is 1650. Dit is de metriek die in de volgende sectie moet worden verslagen

Verbeter het model: Interactieterm
Tijdens het eerste deel van de tutorial zag je een interessante relatie tussen de variabelen. De verschillende visualisatietechnieken lieten zien dat INDUS en NOS met elkaar verbonden zijn en draaien om het effect op de prijs te vergroten. Niet alleen de interactie tussen INDUS en NOS heeft invloed op de prijs, maar ook dit effect is sterker wanneer het interageert met DIS.
Het is tijd om dit idee te generaliseren en te kijken of u het door het model voorspelde model kunt verbeteren.
U moet twee nieuwe kolommen toevoegen aan elke dataset: train + test. Daarvoor creëer je een functie om de interactieterm te berekenen en een andere om de drievoudige interactieterm te berekenen. Elke functie produceert een enkele kolom. Nadat de nieuwe variabelen zijn gemaakt, kunt u ze samenvoegen met de trainingsgegevensset en de testgegevensset.
Allereerst moet u een nieuwe variabele maken voor de interactie tussen INDUS en NOX.
De onderstaande functie retourneert twee dataframes, train en test, met de interactie tussen var_1 en var_2, in jouw geval INDUS en 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
U slaat de twee nieuwe kolommen op
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
Ten tweede creëer je een tweede functie om de drievoudige interactieterm te berekenen.
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')
Nu u alle benodigde kolommen heeft, kunt u ze toevoegen om de dataset te trainen en te testen. U noemt deze twee nieuwe dataframes:

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

Dat is het; u kunt het nieuwe model schatten met de interactietermen en zien hoe de prestatiestatistiek is.
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)
Uitvoer 
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)
Uitvoer 
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)
Uitvoer 
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}
Het nieuwe verlies is 1515. Alleen al door twee nieuwe variabelen toe te voegen, kon je het verlies verkleinen. Het betekent dat u een betere voorspelling kunt doen dan met het benchmarkmodel.