TensorFlow linjär regression med fasett & Interaktionsperiod

I denna handledning lär du dig hur du kontrollerar data och förbereder dem för att skapa en enkel linjär regressionsuppgift.

Denna handledning är uppdelad i två delar:

• Leta efter interaktion
• Testa modellen

I föregående handledning använde du Boston-datauppsättningen för att uppskatta huspriset. Boston dataset har en liten storlek, med endast 506 observationer. Denna dataset betraktas som ett riktmärke för att prova nya linjära regressionsalgoritmer.

Datauppsättningen består av:

Variabel	Beskrivning
zn	Andelen bostadsmark avsatt för mycket över 25 000 kvm.
indus	Andelen icke-detaljhandeln tunnland per stad.
nox	kväveoxidkoncentration
rm	genomsnittligt antal rum per bostad
ålder	andelen ägarbostäder byggda före 1940
dis	viktade avstånd till fem Boston-arbetsplatser
beskatta	fullvärdes fastighetsskattesats per dollar 10.000
ptratio	förhållandet mellan elev och lärare i en stad
medv	Medianvärdet av ägarbostäder i tusen dollar
crim	per capita brottslighet per stad
chas	Charles River dummyvariabel (1 om gränsen till floden; 0 annars)
B	andelen svarta av staden

I denna handledning kommer vi att uppskatta medianpriset med en linjär regressor, men fokus ligger på en viss process för maskininlärning: "dataförberedelse."

En modell generaliserar mönstret i data. För att fånga ett sådant mönster måste du hitta det först. En god praxis är att utföra en dataanalys innan du kör någon maskininlärningsalgoritm.

Att välja rätt funktioner gör hela skillnaden i framgången för din modell. Tänk dig att du försöker uppskatta ett folks lön. Om du inte tar med kön som en kovariat får du en dålig uppskattning.

Ett annat sätt att förbättra modellen är att titta på korrelationen mellan den oberoende variabeln. Tillbaka till exemplet kan du tänka på utbildning som en utmärkt kandidat för att förutsäga lönen men också yrket. Det är rättvist att säga att yrket beror på utbildningsnivån, nämligen högre utbildning leder ofta till ett bättre yrke. Om vi ​​generaliserar denna idé kan vi säga att korrelationen mellan den beroende variabeln och en förklarande variabel kan förstoras av ännu en förklarande variabel.

För att fånga den begränsade effekten av utbildning på yrke kan vi använda en interaktionsterm.

Om man tittar på löneekvationen blir den:

Om det är positivt, innebär det att en ytterligare utbildningsnivå ger en högre ökning av medianvärdet för ett hus för en hög yrkesnivå. Med andra ord finns det en interaktionseffekt mellan utbildning och yrke.

I denna handledning kommer vi att försöka se vilka variabler som kan vara en bra kandidat för interaktionsvillkor. Vi kommer att testa om att lägga till denna typ av information leder till bättre prisförutsägelse.

I den här handledningen lär du dig

• Sammanfattande statistik
• Facetsöversikt
• Facets Deep Dive
• Installera Facet
• Översikt
• Graf
• Facets Deep Dive
• TensorFlow
• Beredningsdata
• Grundläggande regression: riktmärke
• Förbättra modellen: Interaktionsperiod

Sammanfattande statistik

Det finns några steg du kan följa innan du går vidare till modellen. Som tidigare nämnts är modellen en generalisering av data. Det bästa sättet är att förstå data och göra en förutsägelse. Om du inte känner till dina uppgifter har du små möjligheter att förbättra din modell.

Som ett första steg, ladda in data som en pandas dataframe och skapa en träningsuppsättning och testuppsättning.

Tips: För denna handledning måste du ha matplotlit och seaborn installerat i Python. Du kan installera Python-paketet i farten med Jupyter. Du borde inte göra det här

!conda install -- yes matplotlib

men

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

Observera att detta steg inte är nödvändigt om du har matplotlib och seaborn installerat.

Matplotlib är biblioteket för att skapa en graf i Python. Seaborn är ett statistiskt visualiseringsbibliotek byggt ovanpå matplotlib. Det ger attraktiva och vackra tomter.

Koden nedan importerar nödvändiga bibliotek.

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

Biblioteket sklearn inkluderar Boston dataset. Du kan ringa dess API för att importera data.

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

Funktionens namn lagras i objektet funktionsnamn i en matris.

boston.feature_names

Produktion

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Du kan byta namn på kolumnerna.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Du konverterar variabeln CHAS som en strängvariabel och märker den med ja om CHAS = 1 och nej om CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Med pandor är det enkelt att dela upp datasetet. Du delar slumpmässigt datamängden med 80 procent träningsuppsättning och 20 procent testuppsättning. Pandor har en inbyggd kostnadsfunktion för att dela ett dataramprov.


Den första parametern frac är ett värde från 0 till 1. Du ställer in det på 0,8 för att välja slumpmässigt 80 procent av dataramen.
Random_state tillåter att samma dataram returneras för alla.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Du kan få formen på data. Det borde vara:

Tågsats: 506 * 0,8 = 405
Testuppsättning: 506 * 0,2 = 101

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

 
 
 
 
CRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
ÅLDER 
 
DIS 
 
RAD 
 
BESKATTA 
 
PTRATIO 
 
B 
 
LSTAT 
 
PRIS 
 

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

 

 

Data är rörigt; det är ofta felbalanserat och ströms med avvikande värden som kastar bort analysen och maskininlärningsträningen.
Det första steget för att rengöra datauppsättningen är att förstå var den behöver rengöras. Att rensa upp en dataset kan vara svårt att göra, särskilt på något generaliserat sätt
Googles forskningsteam har utvecklat ett verktyg för det här jobbet som heter Facets som hjälper till att visualisera data och skiva den på alla möjliga sätt. Detta är en bra utgångspunkt för att förstå hur datauppsättningen är uppbyggd.
Med facetter kan du hitta var data inte riktigt ser ut som du tänker.
Med undantag för deras webbapp gör Google det enkelt att bädda in verktygslådan i en Jupyter-anteckningsbok.
Facetterna har två delar:

Facetsöversikt


Facets Deep Dive


Facetsöversikt
Facetsöversikt ger en översikt över datasetet. Facetsöversikt delar upp datakolumnerna i rader med framträdande information som visas

andelen saknad observation
min- och maxvärden
statistik som medelvärde, median och standardavvikelse.
Det lägger också till en kolumn som visar procentandelen värden som är nollor, vilket är användbart när de flesta värdena är nollor.
Det är möjligt att se dessa distributioner på testdatasetet samt träningsuppsättningen för varje funktion. Det betyder att du kan dubbelkontrollera att testet har en liknande fördelning som träningsdata.

Detta är åtminstone det lägsta att göra innan någon maskininlärningsuppgift. Med det här verktyget missar du inte detta viktiga steg, och det belyser vissa avvikelser.

Facets Deep Dive
Facets Deep Dive är ett coolt verktyg. Det gör det möjligt att ha en viss klarhet i din dataset och zooma hela vägen in för att se en enskild datadel. Det betyder att du kan facettera data efter rad och kolumn över alla funktionerna i datasetet.
Vi kommer att använda dessa två verktyg med Boston dataset.
Obs! Du kan inte använda Facets Overview och Facets Deep Dive samtidigt. Du måste rensa anteckningsboken först för att byta verktyg.

Installera Facet
Du kan använda Facet-webbappen för större delen av analysen. I den här handledningen kommer du att se hur du använder den i en Jupyter Notebook.
Först och främst måste du installera nbextensions. Det görs med den här koden. Du kopierar och klistrar in följande kod i terminalen på din maskin.
pip install jupyter_contrib_nbextensions 
Direkt efter det måste du klona förvaren i din dator. Du har två val:
Alternativ 1) Kopiera och klistra in den här koden i terminalen (rekommenderas)
Om du inte har Git installerat på din maskin, gå till denna URL https://git-scm.com/download/win och följ instruktionerna. När du är klar kan du använda git-kommandot i terminalen för Mac-användare eller Anaconda-prompten för Windows-användare
git clone https://github.com/PAIR-code/facets 
Alternativ 2) Gå till https://github.com/PAIR-code/facets och ladda ner arkiven.

Om du väljer det första alternativet hamnar filen i din nedladdningsfil. Du kan antingen låta filen hämtas eller dra den till en annan sökväg.
Du kan kontrollera var Facets är lagrade med den här kommandoraden:
echo `pwd`/`ls facets` 
Nu när du har hittat Facets måste du installera den i Jupyter Notebook. Du måste ställa in arbetskatalogen till den väg där fasetter finns.
Din nuvarande arbetskatalog och plats för Facets zip bör vara densamma.

Du måste rikta arbetskatalogen till Facet:
cd facets
För att installera Facets i Jupyter har du två alternativ. Om du installerade Jupyter med Conda för alla användare, kopiera den här koden:
kan använda jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
Använd annars:
jupyter nbextension install facets-dist/ --user
Okej, du är redo. Låt oss öppna Facet Översikt.

Översikt
Översikt använder ett Python-skript för att beräkna statistiken. Du måste importera skriptet som heter generic_feature_statistics_generator till Jupyter. Oroa dig inte; skriptet finns i fasetterna.
Du måste hitta dess väg. Det görs enkelt. Du öppnar facetter, öppnar filen facets_overview och sedan python. Kopiera sökvägen

Efter det, gå tillbaka till Jupyter och skriv följande kod. Ändra sökvägen '/ Users / Thomas / facets / facets_overview / python' till din sökväg.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Du kan importera skriptet med koden nedan.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
I Windows blir samma kod
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
För att beräkna funktionsstatistiken måste du använda funktionen GenericFeatureStatisticsGenerator () och du använder objektet ProtoFromDataFrames. Du kan skicka dataramen i en ordlista. Om vi ​​till exempel vill skapa en sammanfattningsstatistik för tåguppsättningen kan vi lagra informationen i en ordlista och använda den i objektet 'ProtoFromDataFrames'


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

Namn är namnet på tabellen som visas och du använder namnet på den tabell som du vill beräkna sammanfattningen. I ditt exempel är tabellen som innehåller data 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")
Slutligen kopierar du bara och klistrar in koden nedan. Koden kommer direkt från GitHub. Du borde kunna se detta:

# 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))
 
Graf
När du har kontrollerat data och deras distribution kan du plotta en korrelationsmatris. Korrelationsmatrisen beräknar Pearson-koefficienten. Denna koefficient är bunden mellan -1 och 1, med ett positivt värde indikerar en positiv korrelation och negativt värde en negativ korrelation.
Du är intresserad av att se vilka variabler som kan vara en bra kandidat för interaktionsvillkor.
## 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})
Produktion 

png

Från matrisen kan du se:

LSTAT
RM

Är starkt korrelerade med PRICE. En annan spännande funktion är den starka positiva korrelationen mellan NOX och INDUS, vilket innebär att de två variablerna rör sig i samma riktning. Dessutom är det korrelerade med PRIS. DIS är också starkt korrelerat med IND och NOX.
Du har en första antydan om att IND och NOX kan vara bra kandidater för avlyssningsperioden och DIS kan också vara intressant att fokusera på.
Du kan gå lite djupare genom att plotta ett par rutnät. Det kommer att illustrera mer detaljerat den korrelationskarta du planerade tidigare.
Paret rutnät vi är sammansatta enligt följande:

Övre del: Spridningsdiagram med monterad linje
Diagonal: Kärndensitetsdiagram
Nedre del: Multivariat kärndensitetsdiagram

Du väljer fokus på fyra oberoende variabler. Valet motsvarar variablerna med stark korrelation med PRICE

INDUS
NOX
RM
LSTAT

dessutom PRISET.
Observera att standardfelet läggs till som standard i spridningsdiagrammet.
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)
Produktion 

Låt oss börja med den övre delen:

Priset är negativt korrelerat med INDUS, NOX och LSTAT; positivt korrelerad med RM.
Det finns en något olinjäritet med LSTAT och PRICE
Det är som en rak linje när priset är lika med 50. Från beskrivningen av datasetet har PRICE trunkerats till värdet 50

Diagonal

NOX verkar ha två kluster, en runt 0,5 och en runt 0,85.

För att kontrollera mer om det kan du titta på den nedre delen. Multivariate Kernel Density är intressant på så sätt att den färgar där de flesta poängen är. Skillnaden med spridningsdiagrammet drar en sannolikhetstäthet, även om det inte finns någon punkt i datasetet för en given koordinat. När färgen är starkare indikerar den en hög koncentration av punkten runt detta område.
Om du kontrollerar den multivariata densiteten för INDUS och NOX kan du se den positiva korrelationen och de två klustren. När industrins andel är över 18 är kväveoxidkoncentrationen över 0,6.
Du kan tänka på att lägga till en interaktion mellan INDUS och NOX i det linjära förhållandet.
Slutligen kan du använda de andra verktygen som skapats av Google, Facets Deep Dive. Gränssnittet är uppdelat i fyra huvudsektioner. Det centrala området i mitten är en zoombar visning av data. Överst på panelen finns rullgardinsmenyn där du kan ändra arrangemanget av data för att kontrollera facettering, positionering och färg. Till höger finns en detaljerad vy av en specifik rad med data. Det betyder att du kan klicka på valfri datapunkt i mittvisualiseringen för att se detaljerna om den specifika datapunkten.
Under datavisualiseringssteget är du intresserad av att leta efter det parvisa sambandet mellan den oberoende variabeln på huspriset. Det handlar dock om minst tre variabler, och 3D-plottar är komplicerade att arbeta med.
Ett sätt att hantera detta problem är att skapa en kategorisk variabel. Det vill säga, vi kan skapa ett 2D-diagram och färgpunkten. Du kan dela upp variabeln PRICE i fyra kategorier, varvid varje kategori är en kvartil (dvs. 0,25, 0,5, 0,75). Du kallar den här nya variabeln 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")


Facets Deep Dive
För att öppna Deep Dive måste du förvandla data till ett json-format. Pandor som ett objekt för det. Du kan använda to_json efter Pandas-datasetet.
Den första raden kod hanterar storleken på datasetet.
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')
Koden nedan kommer från Google GitHub. När du har kört koden bör du kunna se detta:

# 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))
Du är intresserad av att se om det finns ett samband mellan branschhastighet, oxidkoncentration, avstånd till jobbet och huspriset.
För det delade du först data efter branschintervall och färg med priskvartilen:

Välj faceting X och välj INDUS.
Välj Display och välj DIS. Det kommer att färga prickarna med kvartil av huspriset

här betyder mörkare färger att avståndet till det första jobbet är långt.
Hittills visar det igen vad du vet, lägre industriränta, högre pris. Nu kan du titta på fördelningen av INDUX, av NOX.

Välj facettering Y och välj NOX.

Nu kan du se att huset långt ifrån det första jobbcentret har lägst branschandel och därmed den lägsta oxidkoncentrationen. Om du väljer att visa typen med Q_PRICE och zooma i det nedre vänstra hörnet kan du se vilken typ av pris det är.
Du har en annan ledtråd att interaktionen mellan IND, NOX och DIS kan vara bra kandidater för att förbättra modellen.

TensorFlow
I det här avsnittet kommer du att uppskatta den linjära klassificeraren med TensorFlow estimators API. Du fortsätter enligt följande:

Förbered data
Uppskatta en standardmodell: Ingen interaktion
Uppskatta en modell med interaktion

Kom ihåg att målet med maskininlärning är att minimera felet. I det här fallet vinner modellen med det lägsta medelkvadratfelet. TensorFlow-beräknaren beräknar automatiskt detta mått.
Beredningsdata
I de flesta fall måste du omvandla dina data. Det är därför Facetsöversikt är fascinerande. Från sammanfattningsstatistiken såg du att det finns avvikelser. Dessa värden påverkar uppskattningarna eftersom de inte ser ut som den population du analyserar. Outliers vanligtvis partiska resultaten. Till exempel tenderar en positiv avvikare att överskatta koefficienten.
En bra lösning för att hantera detta problem är att standardisera variabeln. Standardisering betyder en standardavvikelse på en och medelvärde noll. Processen med standardisering innefattar två steg. Först och främst subtraherar det medelvärdet för variabeln. För det andra delar den med variansen så att fördelningen har en enhetsvarians
Biblioteket sklearn hjälper till att standardisera variabler. Du kan använda förbehandlingen av modulen med objektskalan för detta ändamål.
Du kan använda funktionen nedan för att skala en dataset. Observera att du inte skalar etikettkolumnen och kategoriska variabler.
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
Du kan använda funktionen för att konstruera det skalade tåget / testuppsättningen.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Grundläggande regression: riktmärke
Först och främst tränar du och testar en modell utan interaktion. Syftet är att se modellens prestandamätvärde.
Sättet att träna modellen är precis som självstudien om API på hög nivå . Du kommer att använda TensorFlow-beräknaren LinearRegressor.
Som en påminnelse måste du välja:

funktionerna att sätta i modellen
förvandla funktionerna
konstruera den linjära regressorn
konstruera input_fn-funktionen
träna modellen
testa modellen

Du använder alla variabler i datasetet för att träna modellen. Totalt finns det kontinuerliga variabler i en nivå och en kategorisk variabel
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Du konverterar funktionerna till en numerisk kolumn eller kategorisk kolumn
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'])]
Du skapar modellen med linearRegressor. Du lagrar modellen i mappen train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Produktion 
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}
Varje kolumn i tåget eller testdata omvandlas till en Tensor med funktionen 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)
Du uppskattar modellen på tågdata.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Produktion 
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.
Äntligen uppskattar du modellens prestanda på testuppsättningen
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Produktion 
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}
Förlusten av modellen är 1650. Detta är måttet att slå i nästa avsnitt

Förbättra modellen: Interaktionsperiod
Under den första delen av handledningen såg du ett intressant samband mellan variablerna. De olika visualiseringsteknikerna avslöjade att INDUS och NOS är sammankopplade och vänder för att förstora effekten på priset. Inte bara interaktionen mellan INDUS och NOS påverkar priset utan också denna effekt är starkare när den interagerar med DIS.
Det är dags att generalisera denna idé och se om du kan förbättra modellförutsedd modell.
Du måste lägga till två nya kolumner i varje dataset: train + test. För det skapar du en funktion för att beräkna interaktionsperioden och en annan för att beräkna den tredubbla interaktionsperioden. Varje funktion ger en enda kolumn. När de nya variablerna har skapats kan du sammanfoga dem till träningsdatasetet och testdataset.
Först och främst måste du skapa en ny variabel för interaktionen mellan INDUS och NOX.
Funktionen nedan returnerar två dataramar, träna och testa, med interaktionen mellan var_1 och var_2, i ditt fall INDUS och 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
Du lagrar de två nya kolumnerna
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
För det andra skapar du en andra funktion för att beräkna termen för trippelinteraktion.
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 när du har alla kolumner som behövs kan du lägga till dem för att träna och testa dataset. Du heter dessa två nya dataframar:

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

Nu räcker det; du kan uppskatta den nya modellen med interaktionsvillkoren och se hur prestandamätet är.
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)
Produktion 
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}
KODA
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)
Produktion 
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)
Produktion 
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}
Den nya förlusten är 1515. Bara genom att lägga till två nya variabler kunde du minska förlusten. Det betyder att du kan göra en bättre förutsägelse än med standardmodellen.