TensorFlow Lineær regresjon med fasett og amp; Interaksjonsperiode

I denne opplæringen lærer du hvordan du sjekker dataene og forbereder dem til å lage en enkel lineær regresjonsoppgave.

Denne opplæringen er delt inn i to deler:

• Se etter samhandling
• Test modellen

I forrige opplæring brukte du Boston-datasettet til å estimere medianprisen på et hus. Boston-datasettet har en liten størrelse, med bare 506 observasjoner. Dette datasettet betraktes som et referanseindeks for å prøve nye lineære regresjonsalgoritmer.

Datasettet består av:

Variabel	Beskrivelse
zn	Andelen boligmark sone for mye over 25.000 kvm.
indus	Andelen ikke-detaljhandelshektar per by.
nox	nitrogenoksidkonsentrasjon
rm	gjennomsnittlig antall rom per bolig
alder	andelen eierboliger som ble bygget før 1940
dis	vektede avstander til fem Boston-arbeidssentre
avgift	fullverdig eiendomsskatt per dollar 10.000
ptratio	elev-lærer-forholdet ved en by
medv	Medianverdien av eierboliger i tusen dollar
crim	per innbygger kriminalitetsrate etter by
chas	Charles River dummyvariabel (1 hvis grenser til elv; 0 ellers)
B	andelen svarte av byen

I denne opplæringen vil vi estimere medianprisen ved hjelp av en lineær regressor, men fokuset er på en bestemt prosess med maskinlæring: "data klargjøring."

En modell generaliserer mønsteret i dataene. For å fange et slikt mønster, må du finne det først. En god praksis er å utføre en dataanalyse før du kjører noen maskinlæringsalgoritme.

Å velge de riktige funksjonene gjør hele forskjellen i suksessen til modellen din. Tenk deg at du prøver å estimere lønnen til et folk. Hvis du ikke inkluderer kjønn som et kovariat, ender du opp med et dårlig estimat.

En annen måte å forbedre modellen på er å se på sammenhengen mellom den uavhengige variabelen. Tilbake til eksemplet kan du tenke på utdanning som en utmerket kandidat til å forutsi lønn, men også yrke. Det er rettferdig å si at okkupasjonen avhenger av utdanningsnivået, nemlig at høyere utdanning ofte fører til en bedre yrke. Hvis vi generaliserer denne ideen, kan vi si at korrelasjonen mellom den avhengige variabelen og en forklaringsvariabel kan forstørres av enda en forklaringsvariabel.

For å fange den begrensede effekten av utdanning på yrke, kan vi bruke et samhandlingsbegrep.

Hvis du ser på lønnsligningen, blir den:

Hvis det er positivt, innebærer det at et ekstra utdanningsnivå gir en høyere økning i medianverdien til et hus for et høyt yrkesnivå. Det er med andre ord en samhandlingseffekt mellom utdanning og yrke.

I denne opplæringen vil vi prøve å se hvilke variabler som kan være en god kandidat for interaksjonsvilkår. Vi vil teste om å legge til denne typen informasjon fører til bedre prisforutsigelser.

I denne veiledningen vil du lære

• Oppsummeringsstatistikk
• Fasetter Oversikt
• Facets Deep Dive
• Installer Facet
• Oversikt
• Kurve
• Facets Deep Dive
• TensorFlow
• Forberedelsesdata
• Grunnleggende regresjon: Referanse
• Forbedre modellen: Interaksjonsperiode

Oppsummeringsstatistikk

Det er noen få trinn du kan følge før du går videre til modellen. Som nevnt tidligere er modellen en generalisering av dataene. Den beste fremgangsmåten er å forstå dataene og gjøre en spådom. Hvis du ikke kjenner dataene dine, har du små sjanser til å forbedre modellen din.

Som et første trinn, last inn dataene som en panda-dataramme og opprett et treningssett og testsett.

Tips: For denne opplæringen må du ha matplotlit og seaborn installert i Python. Du kan installere Python-pakken på farten med Jupyter. Du burde ikke gjøre dette

!conda install -- yes matplotlib

men

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

Merk at dette trinnet ikke er nødvendig hvis du har installert matplotlib og seaborn.

Matplotlib er biblioteket for å lage en graf i Python. Seaborn er et statistisk visualiseringsbibliotek bygget på toppen av matplotlib. Det gir attraktive og vakre tomter.

Koden nedenfor importerer nødvendige biblioteker.

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

Biblioteket sklearn inkluderer Boston-datasettet. Du kan ringe API-en for å importere dataene.

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

Funksjonens navn lagres i objektet feature_names i en matrise.

boston.feature_names

Produksjon

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Du kan gi nytt navn til kolonnene.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Du konverterer variabelen CHAS som en strengvariabel og merker den med ja hvis CHAS = 1 og nei hvis 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 pandaer er det greit å dele datasettet. Du deler datasettet tilfeldig med 80 prosent treningssett og 20 prosent testsett. Pandaer har en innebygd kostnadsfunksjon for å dele et datarammeprøve.


Den første parameteren frac er en verdi fra 0 til 1. Du setter den til 0,8 for å velge tilfeldig 80 prosent av datarammen.
Random_state tillater å få den samme datarammen returnert for alle.
### 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å dataene. Det bør være:

Togsett: 506 * 0,8 = 405
Testsett: 506 * 0,2 = 101

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

 
 
 
 
CRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
ALDER 
 
DIS 
 
RAD 
 
AVGIFT 
 
PTRATIO 
 
B 
 
LSTAT 
 
PRIS 
 

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

 

 

Data er rotete; det er ofte ubalansert og strødd med avvikende verdier som kaster bort analysen og maskinlæringstrening.
Det første trinnet for å få oppryddet datasettet er å forstå hvor det trenger rengjøring. Å rydde opp i et datasett kan være vanskelig å gjøre, spesielt på en generaliserbar måte
Google Research-teamet har utviklet et verktøy for denne jobben kalt Facets som hjelper til med å visualisere dataene og skjære dem på alle slags måter. Dette er et godt utgangspunkt for å forstå hvordan datasettet er lagt ut.
Med fasetter kan du finne hvor dataene ikke ser helt ut slik du tenker.
Bortsett fra deres webapp, gjør Google det enkelt å bygge inn verktøysettet i en Jupyter-notatbok.
Det er to deler til fasetter:

Fasetter Oversikt


Facets Deep Dive


Fasetter Oversikt
Facets Overview gir en oversikt over datasettet. Oversikt over fasetter deler datakolonnene i rader med fremtredende informasjon som vises

prosentandelen av manglende observasjon
min- og maksverdier
statistikk som gjennomsnitt, median og standardavvik.
Det legger også til en kolonne som viser prosentandelen av verdier som er null, noe som er nyttig når de fleste verdiene er null.
Det er mulig å se disse distribusjonene på testdatasettet samt treningssettet for hver funksjon. Det betyr at du kan dobbeltsjekke at testen har en lignende fordeling som treningsdataene.

Dette er i det minste minimum å gjøre før noen maskinlæringsoppgaver. Med dette verktøyet går du ikke glipp av dette viktige trinnet, og det fremhever noen avvik.

Facets Deep Dive
Facets Deep Dive er et kult verktøy. Det tillater å ha litt klarhet i datasettet ditt og zoome helt inn for å se et individuelt stykke data. Det betyr at du kan fasettere dataene etter rad og kolonne over alle funksjonene i datasettet.
Vi vil bruke disse to verktøyene med Boston-datasettet.
Merk : Du kan ikke bruke Facets Overview og Facets Deep Dive samtidig. Du må rydde notatboken først for å endre verktøyet.

Installer Facet
Du kan bruke Facet-nettappen for det meste av analysen. I denne opplæringen vil du se hvordan du bruker den i en Jupyter Notebook.
Først og fremst må du installere utvidelser. Det gjøres med denne koden. Du kopierer og limer inn følgende kode i terminalen på maskinen din.
pip install jupyter_contrib_nbextensions 
Rett etter det må du klone lagringsplassene på datamaskinen din. Du har to valg:
Alternativ 1) Kopier og lim inn denne koden i terminalen (anbefalt)
Hvis du ikke har Git installert på maskinen din, kan du gå til denne URL-adressen https://git-scm.com/download/win og følge instruksjonene. Når du er ferdig, kan du bruke git-kommandoen i terminalen for Mac-brukere eller Anaconda-meldinger for Windows-brukere
git clone https://github.com/PAIR-code/facets 
Alternativ 2) Gå til https://github.com/PAIR-code/facets og last ned repositoriene.

Hvis du velger det første alternativet, havner filen i nedlastingsfilen din. Du kan enten la filen lastes ned eller dra den til en annen bane.
Du kan sjekke hvor fasetter er lagret med denne kommandolinjen:
echo `pwd`/`ls facets` 
Nå som du har funnet fasetter, må du installere det i Jupyter Notebook. Du må sette arbeidskatalogen til banen der fasetter ligger.
Din nåværende arbeidskatalog og plassering av Facets zip bør være den samme.

Du må peke arbeidskatalogen til Facet:
cd facets
For å installere fasetter i Jupyter har du to alternativer. Hvis du installerte Jupyter med Conda for alle brukerne, kopier du denne koden:
kan bruke jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
Bruk ellers:
jupyter nbextension install facets-dist/ --user
OK, du er klar. La oss åpne Facet Oversikt.

Oversikt
Oversikt bruker et Python-skript for å beregne statistikken. Du må importere skriptet kalt generic_feature_statistics_generator til Jupyter. Ikke bekymre deg; skriptet ligger i fasettfilene.
Du må finne stien. Det gjøres enkelt. Du åpner fasetter, åpner filen facets_overview og deretter python. Kopier banen

Etter det, gå tilbake til Jupyter, og skriv følgende kode. Endre banen '/ Users / Thomas / facets / facets_overview / python' til din bane.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Du kan importere skriptet med koden nedenfor.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
I windows blir den samme koden
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
For å beregne funksjonsstatistikken, må du bruke funksjonen GenericFeatureStatisticsGenerator (), og du bruker objektet ProtoFromDataFrames. Du kan sende datarammen i en ordbok. For eksempel, hvis vi vil lage en sammendragsstatistikk for togsettet, kan vi lagre informasjonen i en ordbok og bruke den i objektet `` ProtoFromDataFrames ''


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

Navn er navnet på tabellvisningene, og du bruker navnet på tabellen du vil beregne sammendraget. I eksempelet ditt er tabellen som inneholder dataene 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")
Til slutt, du bare kopierer og limer inn koden nedenfor. Koden kommer direkte fra GitHub. Du bør kunne se dette:

# 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))
 
Kurve
Når du har sjekket dataene og fordelingen av dem, kan du plotte en korrelasjonsmatrise. Korrelasjonsmatrisen beregner Pearson-koeffisienten. Denne koeffisienten er bundet mellom -1 og 1, med en positiv verdi indikerer en positiv korrelasjon og negativ verdi en negativ korrelasjon.
Du er interessert i å se hvilke variabler som kan være en god kandidat for interaksjonsvilkår.
## 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})
Produksjon 

png

Fra matrisen kan du se:

LSTAT
RM

Er sterkt korrelert med PRICE. En annen spennende funksjon er den sterke positive korrelasjonen mellom NOX og INDUS, som betyr at de to variablene beveger seg i samme retning. Dessuten er det også korrelert med PRISEN. DIS er også sterkt korrelert med IND og NOX.
Du har et første hint om at IND og NOX kan være gode kandidater for avlyttingsperioden, og DIS kan også være interessant å fokusere på.
Du kan gå litt dypere ved å tegne et par rutenett. Det vil illustrere mer detaljert korrelasjonskartet du planla før.
Parruten vi er sammensatt som følger:

Øvre del: Spredningsplott med montert linje
Diagonal: Kjernetetthetsplott
Nedre del: Multivariat kjerntetthetsplott

Du velger fokus på fire uavhengige variabler. Valget tilsvarer variablene med sterk korrelasjon med PRICE

INDUS
NOX
RM
LSTAT

dessuten PRISEN.
Merk at standardfeilen er lagt til som standard i spredningsdiagrammet.
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)
Produksjon 

La oss begynne med den øvre delen:

Prisen er negativt korrelert med INDUS, NOX og LSTAT; positivt korrelert med RM.
Det er en litt ikke-linearitet med LSTAT og PRICE
Det er som en rett linje når prisen er lik 50. Fra beskrivelsen av datasettet har PRICE blitt avkortet til verdien 50

Diagonal

NOX ser ut til å ha to klynger, en rundt 0,5 og en rundt 0,85.

For å sjekke mer om det, kan du se på den nedre delen. Den multivariate kjernetettheten er interessant på en måte at den farger der de fleste poengene er. Forskjellen med spredningsdiagrammet tegner en sannsynlighetstetthet, selv om det ikke er noe poeng i datasettet for en gitt koordinat. Når fargen er sterkere, indikerer det en høy konsentrasjon av punkt rundt dette området.
Hvis du sjekker multivariat tetthet for INDUS og NOX, kan du se den positive korrelasjonen og de to klyngene. Når andelen av industrien er over 18, er nitrogenoksydkonsentrasjonen over 0,6.
Du kan tenke på å legge til en interaksjon mellom INDUS og NOX i det lineære forholdet.
Til slutt kan du bruke de andre verktøyene opprettet av Google, Facets Deep Dive. Grensesnittet er delt opp i fire hovedseksjoner. Det sentrale området i midten er en zoombar visning av dataene. På toppen av panelet er det rullegardinmenyen der du kan endre oppstillingen av dataene til å kontrollere fasettering, posisjonering og farge. Til høyre er det en detaljert oversikt over en bestemt datarad. Det betyr at du kan klikke på en hvilken som helst prikk med data i sentralvisualiseringen for å se detaljene om det aktuelle datapunktet.
I løpet av datavisualiseringstrinnet er du interessert i å lete etter den parvise korrelasjonen mellom den uavhengige variabelen på husprisen. Imidlertid involverer det minst tre variabler, og 3D-plott er kompliserte å jobbe med.
En måte å takle dette problemet på er å lage en kategorisk variabel. Det vil si at vi kan lage et 2D-plot og farge prikken. Du kan dele variabelen PRIS i fire kategorier, med hver kategori er en kvartil (dvs. 0,25, 0,5, 0,75). Du kaller denne nye variabelen 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
For å åpne Deep Dive, må du transformere dataene til et json-format. Pandaer som et objekt for det. Du kan bruke to_json etter Pandas-datasettet.
Den første linjen med kode håndterer størrelsen på datasettet.
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 nedenfor kommer fra Google GitHub. Etter at du har kjørt koden, bør du kunne se dette:

# 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 er interessert i å se om det er en sammenheng mellom bransjetakt, oksydkonsentrasjon, avstand til jobbsenteret og husprisen.
For det delte du først dataene etter bransjeområde og farge med priskvartilen:

Velg faceting X og velg INDUS.
Velg Skjerm og velg DIS. Det vil farge prikkene med kvartilen til husprisen

her betyr mørkere farger at avstanden til det første jobbsenteret er langt.
Så langt viser det igjen hva du vet, lavere bransjerate, høyere pris. Nå kan du se på fordelingen av INDUX, av NOX.

Velg fasettering Y og velg NOX.

Nå kan du se huset langt fra det første jobbsenteret har den laveste bransjeandelen og derfor den laveste oksydkonsentrasjonen. Hvis du velger å vise typen med Q_PRICE og zoome ned i venstre hjørne, kan du se hvilken type pris det er.
Du har et annet hint om at samspillet mellom IND, NOX og DIS kan være gode kandidater for å forbedre modellen.

TensorFlow
I denne delen vil du estimere den lineære klassifisereren med TensorFlow estimators API. Du fortsetter som følger:

Forbered dataene
Anslå en referansemodell: Ingen interaksjon
Anslå en modell med interaksjon

Husk at målet med maskinlæring er å minimere feilen. I dette tilfellet vinner modellen med den laveste gjennomsnittlige kvadratfeilen. TensorFlow-estimatoren beregner automatisk denne beregningen.
Forberedelsesdata
I det meste av saken må du transformere dataene dine. Derfor er fasettoversikt fascinerende. Fra sammendragsstatistikken så du at det er avvik. Disse verdiene påvirker estimatene fordi de ikke ser ut som befolkningen du analyserer. Outliers vanligvis partisk resultatene. For eksempel har en positiv outlier en tendens til å overvurdere koeffisienten.
En god løsning for å takle dette problemet er å standardisere variabelen. Standardisering betyr et standardavvik på en og betyr null. Prosessen med standardisering innebærer to trinn. Først og fremst trekker den gjennomsnittsverdien til variabelen. For det andre deler den seg med variansen slik at fordelingen har en enhetsvarians
Biblioteket sklearn er nyttig for å standardisere variabler. Du kan bruke forbehandling av modulen med objektskalaen til dette formålet.
Du kan bruke funksjonen nedenfor til å skalere et datasett. Merk at du ikke skalerer etikettkolonnen og kategoriske 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 bruke funksjonen til å konstruere det skalerte toget / testsettet.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Grunnleggende regresjon: Referanse
Først av alt, du trener og tester en modell uten interaksjon. Hensikten er å se ytelsesberegningen for modellen.
Måten å trene modellen på er nøyaktig som opplæringen om API på høyt nivå . Du vil bruke TensorFlow estimator LinearRegressor.
Som en påminnelse må du velge:

funksjonene å sette i modellen
forvandle funksjonene
konstruere den lineære regressoren
konstruer funksjonen input_fn
trene modellen
test modellen

Du bruker alle variablene i datasettet for å trene modellen. Totalt er det kontinuerlige variabler i en nivå og 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 konverterer funksjonene til en numerisk kolonne eller kategorisk kolonne
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 oppretter modellen med linearRegressor. Du lagrer modellen i mappen train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Produksjon 
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}
Hver kolonne i toget eller testdata blir konvertert til en Tensor med funksjonen 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 estimerer modellen på togsdataene.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Produksjon 
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.
Til slutt estimerer du prestasjonene til modellen på testsettet
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Produksjon 
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}
Tapet på modellen er 1650. Dette er beregningen å slå i neste avsnitt

Forbedre modellen: Interaksjonsperiode
I løpet av den første delen av opplæringen så du et interessant forhold mellom variablene. De forskjellige visualiseringsteknikkene avslørte at INDUS og NOS er koblet sammen og svinger for å forstørre effekten på prisen. Ikke bare interaksjonen mellom INDUS og NOS påvirker prisen, men også denne effekten er sterkere når den interagerer med DIS.
Det er på tide å generalisere denne ideen og se om du kan forbedre modellforutsagt modell.
Du må legge til to nye kolonner i hvert datasett: tog + test. For det oppretter du en funksjon for å beregne interaksjonsuttrykket og en annen for å beregne det tredoble samhandlingsbegrepet. Hver funksjon produserer en enkelt kolonne. Etter at de nye variablene er opprettet, kan du sammenkoble dem til treningsdatasettet og testdatasettet.
Først og fremst må du lage en ny variabel for samspillet mellom INDUS og NOX.
Funksjonen nedenfor returnerer to datarammer, tog og test, med samspillet mellom var_1 og var_2, i ditt tilfelle INDUS og 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 lagrer de to nye kolonnene
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
For det andre oppretter du en ny funksjon for å beregne trippelinteraksjonsbegrepet.
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')
Nå som du har alle kolonnene som trengs, kan du legge dem til i å trene og teste datasettet. Du kaller disse to nye datarammene:

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

Det er det; Du kan estimere den nye modellen med samhandlingsbetingelsene og se hvordan ytelsesberegningen er.
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)
Produksjon 
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}
KODE
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)
Produksjon 
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)
Produksjon 
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}
Det nye tapet er 1515. Bare ved å legge til to nye variabler, var du i stand til å redusere tapet. Det betyr at du kan gi en bedre spådom enn med referansemodellen.