TensorFlow lineær regression med facet & Interaktionsperiode

I denne vejledning lærer du, hvordan du kontrollerer dataene og forbereder dem til at skabe en simpel lineær regressionsopgave.

Denne tutorial er opdelt i to dele:

• Se efter interaktion
• Test modellen

I den foregående vejledning brugte du Boston-datasættet til at estimere den gennemsnitlige pris for et hus. Boston-datasættet har en lille størrelse med kun 506 observationer. Dette datasæt betragtes som et benchmark for at prøve nye lineære regressionsalgoritmer.

Datasættet består af:

I denne vejledning estimerer vi medianprisen ved hjælp af en lineær regressor, men fokus er på en bestemt proces med maskinindlæring: "dataforberedelse."

En model generaliserer mønsteret i dataene. For at fange et sådant mønster skal du først finde det. En god praksis er at udføre en dataanalyse, før du kører en maskinlæringsalgoritme.

At vælge de rigtige funktioner gør hele forskellen i succesen med din model. Forestil dig, at du prøver at estimere et folks løn. Hvis du ikke inkluderer køn som et kovariat, ender du med et dårligt skøn.

En anden måde at forbedre modellen på er at se på sammenhængen mellem den uafhængige variabel. Tilbage til eksemplet kan du tænke på uddannelse som en fremragende kandidat til at forudsige løn, men også besættelse. Det er med rimelighed at sige, at besættelsen afhænger af uddannelsesniveauet, nemlig at videregående uddannelse ofte fører til en bedre besættelse. Hvis vi generaliserer denne idé, kan vi sige, at korrelationen mellem den afhængige variabel og en forklarende variabel kan forstørres af endnu en forklarende variabel.

For at fange den begrænsede effekt af uddannelse på erhverv kan vi bruge et interaktionsudtryk.

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

Hvis det er positivt, betyder det, at et ekstra uddannelsesniveau giver en højere stigning i husets medianværdi for et højt beskæftigelsesniveau. Med andre ord er der en interaktionseffekt mellem uddannelse og erhverv.

I denne vejledning vil vi forsøge at se, hvilke variabler der kan være en god kandidat til interaktionsbetingelser. Vi vil teste, om tilføjelse af denne form for information fører til bedre prisforudsigelse.

I denne vejledning lærer du

• Resumé statistik
• Facetter Oversigt
• Facetter Deep Dive
• Installer facet
• Oversigt
• Kurve
• Facetter Deep Dive
• TensorFlow
• Forberedelsesdata
• Grundlæggende regression: benchmark
• Forbedre modellen: Interaktionsudtryk

Resumé statistik

Der er et par trin, du kan følge, før du fortsætter til modellen. Som tidligere nævnt er modellen en generalisering af dataene. Den bedste praksis er at forstå dataene og foretage en forudsigelse. Hvis du ikke kender dine data, har du små chancer for at forbedre din model.

Som et første trin skal du indlæse dataene som en pandadataramme og oprette et træningssæt og testsæt.

Tips: Til denne vejledning skal du have matplotlit og seaborn installeret i Python. Du kan installere Python-pakke i farten med Jupyter. Du bør ikke gøre dette

!conda install -- yes matplotlib

men

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

Bemærk, at dette trin ikke er nødvendigt, hvis du har installeret matplotlib og seaborn.

Matplotlib er biblioteket til oprettelse af en graf i Python. Seaborn er et statistisk visualiseringsbibliotek bygget oven på matplotlib. Det giver attraktive og smukke grunde.

Koden nedenfor importerer de 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-datasættet. Du kan ringe til dets API for at importere dataene.

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

Funktionens navn er gemt i objektet feature_names i en matrix.

boston.feature_names

Produktion

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Du kan omdøbe kolonnerne.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Du konverterer variablen CHAS som en strengvariabel og mærker den med ja, hvis CHAS = 1 og nej, 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 ligetil at opdele datasættet. Du deler tilfældigt datasættet med 80 procent træningssæt og 20 procent testsæt. Pandaer har en indbygget omkostningsfunktion til at opdele en datarammeprøve.


Den første parameter frac er en værdi fra 0 til 1. Du indstiller den til 0,8 for tilfældigt at vælge 80 procent af datarammen.
Random_state giver mulighed for at få den samme dataramme returneret til 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:

Togsæt: 506 * 0,8 = 405
Test sæt: 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 
 
ALDER 
 
DIS 
 
RAD 
 
SKAT 
 
PTRATIO 
 
B 
 
LSTAT 
 
PRIS 
 

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

 

 

Data er rodet; det er ofte misbalanceret og drysset med afviklingsværdier, der smider analysen og maskinlæringstræningen af.
Det første skridt til at få datasættet renset er at forstå, hvor det skal rengøres. Oprydning af et datasæt kan være vanskelig at gøre, især på en generaliserbar måde
Google Research-teamet har udviklet et værktøj til dette job kaldet Facetter, der hjælper med at visualisere dataene og skære dem på alle mulige måder. Dette er et godt udgangspunkt for at forstå, hvordan datasættet er lagt ud.
Facetter giver dig mulighed for at finde, hvor dataene ikke helt ser ud, som du tænker.
Bortset fra deres webapp gør Google det let at integrere værktøjssættet i en Jupyter-notesbog.
Der er to dele til facetter:

Facetter Oversigt


Facetter Deep Dive


Facetter Oversigt
Facets Oversigt giver et overblik over datasættet. Facetsoversigt opdeler datakolonnerne i rækker med vigtige oplysninger, der vises

procentdelen af ​​manglende observation
min og max værdier
statistikker som gennemsnit, median og standardafvigelse.
Det tilføjer også en kolonne, der viser procentdelen af ​​værdier, der er nuller, hvilket er nyttigt, når de fleste af værdierne er nuller.
Det er muligt at se disse distributioner på testdatasættet samt træningssættet for hver funktion. Det betyder, at du kan dobbelttjekke, at testen har en lignende fordeling som træningsdataene.

Dette er i det mindste det minimum, der skal gøres inden nogen maskinlæringsopgave. Med dette værktøj går du ikke glip af dette afgørende trin, og det fremhæver nogle abnormiteter.

Facetter Deep Dive
Facets Deep Dive er et sejt værktøj. Det tillader at have en vis klarhed i dit datasæt og zoome helt ind for at se et individuelt stykke data. Det betyder, at du kan facettere dataene efter række og kolonne på tværs af funktionerne i datasættet.
Vi bruger disse to værktøjer med Boston-datasættet.
Bemærk : Du kan ikke bruge Facets Oversigt og Facets Deep Dive på samme tid. Du skal rydde den bærbare computer først for at skifte værktøj.

Installer facet
Du kan bruge Facet-webappen til det meste af analysen. I denne vejledning vil du se, hvordan du bruger det i en Jupyter Notebook.
Først og fremmest skal du installere udvidelser. Det gøres med denne kode. Du kopierer og indsætter følgende kode i terminalen på din maskine.
pip install jupyter_contrib_nbextensions 
Lige derefter skal du klone arkiverne på din computer. Du har to valg:
Mulighed 1) Kopier og indsæt denne kode i terminalen (anbefales)
Hvis du ikke har Git installeret på din maskine, skal du gå til denne URL https://git-scm.com/download/win og følge instruktionerne. Når du er færdig, kan du bruge git-kommandoen i terminalen til Mac-bruger eller Anaconda-prompt til Windows-bruger
git clone https://github.com/PAIR-code/facets 
Mulighed 2) Gå til https://github.com/PAIR-code/facets og download repositories.

Hvis du vælger den første mulighed, ender filen i din downloadfil. Du kan enten lade filen downloade eller trække den til en anden sti.
Du kan kontrollere, hvor facetter er gemt med denne kommandolinje:
echo `pwd`/`ls facets` 
Nu hvor du har fundet facetter, skal du installere det i Jupyter Notebook. Du skal indstille arbejdsmappen til den sti, hvor facetter er placeret.
Din nuværende arbejdsmappe og placering af Facets zip skal være den samme.

Du skal rette arbejdsmappen til Facet:
cd facets
For at installere facetter i Jupyter har du to muligheder. Hvis du installerede Jupyter med Conda til alle brugerne, skal du kopiere denne kode:
kan bruge jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
Ellers skal du bruge:
jupyter nbextension install facets-dist/ --user
Okay, du er klar. Lad os åbne facetoversigt.

Oversigt
Oversigt bruger et Python-script til at beregne statistikken. Du skal importere scriptet kaldet generic_feature_statistics_generator til Jupyter. Bare rolig; scriptet er placeret i facetterne.
Du skal finde stien. Det gøres let. Du åbner facetter, åbner filen facets_overview og derefter python. Kopier stien

Derefter skal du gå tilbage til Jupyter og skrive følgende kode. Skift stien '/ Brugere / Thomas / facetter / facets_overview / python' til din sti.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Du kan importere scriptet med nedenstående kode.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
I windows bliver den samme kode
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
For at beregne funktionsstatistikkerne skal du bruge funktionen GenericFeatureStatisticsGenerator (), og du bruger objektet ProtoFromDataFrames. Du kan videregive datarammen i en ordbog. For eksempel, hvis vi vil oprette en oversigtsstatistik for togsættet, kan vi gemme informationen i en ordbog og bruge den i objektet 'ProtoFromDataFrames'


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

Navn er navnet på tabellen, og du bruger navnet på den tabel, du vil beregne resuméet. I dit eksempel er tabellen, der indeholder 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")
Endelig skal du bare kopiere og indsætte koden nedenfor. Koden kommer direkte fra GitHub. Du skal 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 kontrolleret dataene og deres fordeling, kan du plotte en korrelationsmatrix. Korrelationsmatrixen beregner Pearson-koefficienten. Denne koefficient er bundet mellem -1 og 1, med en positiv værdi indikerer en positiv korrelation og negativ værdi en negativ korrelation.
Du er interesseret i at se, hvilke variabler der kan være en god kandidat til interaktionsbetingelser.
## 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

Fra matrixen kan du se:

LSTAT
RM

Er stærkt korreleret med PRICE. Et andet spændende træk er den stærke positive sammenhæng mellem NOX og INDUS, hvilket betyder, at de to variabler bevæger sig i samme retning. Derudover er der også korreleret med PRISEN. DIS er også stærkt korreleret med IND og NOX.
Du har nogle første antydninger om, at IND og NOX kan være gode kandidater til aflytningsperioden, og DIS kan også være interessant at fokusere på.
Du kan gå lidt dybere ved at plotte et par gitter. Det illustrerer mere detaljeret det korrelationskort, du planlagde før.
Parret gitter vi er sammensat som følger:

Øverste del: Spredningsdiagram med monteret linje
Diagonal: plot af kernetæthed
Nederste del: Multivariat plot af kernetæthed

Du vælger fokus på fire uafhængige variabler. Valget svarer til variablerne med stærk korrelation med PRICE

INDUS
NOX
RM
LSTAT

desuden PRISEN.
Bemærk , at standardfejlen tilføjes som standard til 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)
Produktion 

Lad os begynde med den øverste del:

Prisen er negativt korreleret med INDUS, NOX og LSTAT; positivt korreleret med RM.
Der er en lidt ikke-linearitet med LSTAT og PRICE
Der er som en lige linje, når prisen er lig med 50. Fra beskrivelsen af ​​datasættet er PRICE afkortet til en værdi af 50

Diagonal

NOX ser ud til at have to klynger, en omkring 0,5 og en omkring 0,85.

For at kontrollere mere om det kan du se på den nederste del. Den multivariate kernetæthed er interessant på en måde, at den farver, hvor de fleste punkter er. Forskellen med spredningsdiagrammet tegner en sandsynlighedsdensitet, selvom der ikke er noget punkt i datasættet for en given koordinat. Når farven er stærkere, indikerer den en høj koncentration af punkt omkring dette område.
Hvis du kontrollerer den multivariate tæthed for INDUS og NOX, kan du se den positive korrelation og de to klynger. Når industriens andel er over 18, er nitrogenoxidkoncentrationen over 0,6.
Du kan tænke på at tilføje en interaktion mellem INDUS og NOX i det lineære forhold.
Endelig kan du bruge de andet værktøjer oprettet af Google, Facets Deep Dive. Interfacet er opdelt i fire hovedsektioner. Det centrale område i midten er en zoombar visning af dataene. Øverst på panelet er der rullemenuen, hvor du kan ændre placeringen af ​​dataene til at kontrollere facettering, positionering og farve. Til højre er der en detaljeret visning af en bestemt datarække. Det betyder, at du kan klikke på en hvilken som helst prik af data i centervisualiseringen for at se detaljerne om det specifikke datapunkt.
Under datavisualiseringstrinnet er du interesseret i at kigge efter den parvise sammenhæng mellem den uafhængige variabel på husets pris. Det involverer dog mindst tre variabler, og 3D-plot er komplicerede at arbejde med.
En måde at tackle dette problem på er at oprette en kategorisk variabel. Det vil sige, vi kan oprette et 2D-plot, farve prikken. Du kan opdele variablen PRIS i fire kategorier, hvor hver kategori er en kvartil (dvs. 0,25, 0,5, 0,75). Du kalder denne nye variabel 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")


Facetter Deep Dive
For at åbne Deep Dive skal du omdanne dataene til et json-format. Pandaer som et objekt til det. Du kan bruge to_json efter Pandas-datasættet.
Den første kodelinje håndterer størrelsen på datasættet.
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. Når du har kørt koden, skal 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 interesseret i at se, om der er en sammenhæng mellem branchehastighed, oxidkoncentration, afstand til jobcentret og husets pris.
Til det delte du først dataene efter brancheområde og farve med priskvartilen:

Vælg facettering X, og vælg INDUS.
Vælg Display, og vælg DIS. Det vil farve prikkerne med kvartil af husprisen

her betyder mørkere farver afstanden til det første jobcenter er langt.
Indtil videre viser det igen, hvad du ved, lavere branche, højere pris. Nu kan du se fordelingen efter INDUX, efter NOX.

Vælg facettering Y, og vælg NOX.

Nu kan du se, at huset langt fra det første jobcenter har den laveste andel i branchen og derfor den laveste oxidkoncentration. Hvis du vælger at vise typen med Q_PRICE og zoome i nederste venstre hjørne, kan du se, hvilken type pris det er.
Du har endnu et tip om, at interaktionen mellem IND, NOX og DIS kan være gode kandidater til at forbedre modellen.

TensorFlow
I dette afsnit estimerer du den lineære klassifikator med TensorFlow estimators API. Du fortsætter som følger:

Forbered dataene
Anslå en benchmark-model: Ingen interaktion
Anslå en model med interaktion

Husk, at målet med maskinlæring er at minimere fejlen. I dette tilfælde vinder modellen med den laveste gennemsnitlige kvadratiske fejl. TensorFlow estimator beregner automatisk denne metric.
Forberedelsesdata
I det meste af tilfældet skal du transformere dine data. Derfor er facets oversigt fascinerende. Fra den sammenfattende statistik så du, at der er afvigelser. Disse værdier påvirker estimaterne, fordi de ikke ligner den population, du analyserer. Outliers normalt partisk resultaterne. For eksempel har en positiv outlier tendens til at overvurdere koefficienten.
En god løsning til at tackle dette problem er at standardisere variablen. Standardisering betyder en standardafvigelse på en og betyder nul. Standardiseringsprocessen involverer to trin. Først og fremmest subtraherer den gennemsnitlige værdi af variablen. For det andet deler den med variansen, så fordelingen har en enhedsvarians
Biblioteket sklearn er nyttigt at standardisere variabler. Du kan bruge modulet til forbehandling med objektskalaen til dette formål.
Du kan bruge nedenstående funktion til at skalere et datasæt. Bemærk, at du ikke skalerer etiketkolonnen og de 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 bruge funktionen til at konstruere det skalerede tog / testsæt.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Grundlæggende regression: benchmark
Først og fremmest træner og tester du en model uden interaktion. Formålet er at se modelens præstationsmåling.
Måden at træne modellen på er nøjagtigt som vejledningen om API på højt niveau . Du bruger TensorFlow estimator LinearRegressor.
Som en påmindelse skal du vælge:

de funktioner, der skal placeres i modellen
omdanne funktionerne
konstruere den lineære regressor
konstruer input_fn-funktionen
træne modellen
test modellen

Du bruger alle variablerne i datasættet til at træne modellen. I alt er der løbende kontinuerlige variabler 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 funktionerne 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 opretter modellen med linearRegressor. Du gemmer 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}
Hver kolonne i toget eller testdata konverteres til 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 estimerer modellen på togedataene.
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.
Endelig estimerer du præstationerne for modellen på testsættet
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}
Tabet af modellen er 1650. Dette er metricen, der skal slå i næste afsnit

Forbedre modellen: Interaktionsudtryk
I løbet af den første del af vejledningen så du et interessant forhold mellem variablerne. De forskellige visualiseringsteknikker afslørede, at INDUS og NOS er knyttet sammen og drejer for at forstørre effekten på prisen. Ikke kun interaktionen mellem INDUS og NOS påvirker prisen, men også denne effekt er stærkere, når den interagerer med DIS.
Det er på tide at generalisere denne idé og se, om du kan forbedre den model forudsagte model.
Du skal tilføje to nye kolonner til hvert datasæt: tog + test. Til det opretter du en funktion til at beregne interaktionsudtrykket og en anden til at beregne det tredobbelte interaktionsudtryk. Hver funktion producerer en enkelt kolonne. Når de nye variabler er oprettet, kan du sammenkæde dem til træningsdatasættet og testdatasættet.
Først og fremmest skal du oprette en ny variabel til interaktionen mellem INDUS og NOX.
Funktionen nedenfor returnerer to datarammer, træner og test med interaktionen mellem var_1 og var_2, i dit tilfælde 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 gemmer de to nye kolonner
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
For det andet opretter du en anden funktion til at beregne det tredobbelte interaktionsudtryk.
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 hvor du har alle nødvendige kolonner, kan du tilføje dem til at træne og teste datasæt. Du navngiver disse to nye datarammer:

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 

Det er det; Du kan estimere den nye model med interaktionsbetingelserne og se, hvordan er performance-metricen.
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}
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)
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}
Det nye tab er 1515. Bare ved at tilføje to nye variabler var du i stand til at reducere tabet. Det betyder, at du kan foretage en bedre forudsigelse end med benchmark-modellen.
                    


                    

                      

                        
                          
Share on Facebook
                            

                          
                        
                      
                      

                        
                          
Share on Twitter