TensorFlow lineær regresjon med fasetter og interaksjonsterm
Evelyn Clarke
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 interaksjon
- Test modellen
på tidligere 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 anses som en målestokk for å prøve nye lineære regresjonsalgoritmer.
Datasettet er sammensatt av:
| Variabel | Tekniske beskrivelser |
|---|---|
| zn | Andelen boligareal som er regulert for tomter over 25,000 XNUMX sq.ft. |
| Indus | Andel ikke-detaljhandel dekar per by. |
| nox | konsentrasjon av nitrogenoksider |
| rm | gjennomsnittlig antall rom per bolig |
| alder | andelen eierboliger bygget før 1940 |
| DIS | vektede avstander til fem Boston sysselsettingssentre |
| skatt | full verdi eiendomsskattesats per dollar 10,000 XNUMX |
| ptratio | elev-lærer-forholdet i en by |
| medv | Medianverdien av eierboliger i tusen dollar |
| krim | kriminalitet per innbygger etter by |
| chas | Charles River dummyvariabel (1 hvis grenser til elven; 0 ellers) |
| B | andelen svarte ved byen |
I denne opplæringen vil vi estimere medianprisen ved å bruke en lineær regressor, men fokuset er på én bestemt prosess med maskinlæring: "dataforberedelse."
En modell generaliserer mønsteret i dataene. For å fange et slikt mønster, må du først finne det. En god praksis er å utføre en dataanalyse før du kjører en maskinlæringsalgoritme.
Å velge de riktige funksjonene utgjør hele forskjellen i suksessen til modellen din. Tenk deg at du prøver å anslå lønnen til et folk, hvis du ikke inkluderer kjønn som en kovariat, ender du opp med et dårlig anslag.
En annen måte å forbedre modellen på er å se på korrelasjonen mellom den uavhengige variabelen. Tilbake til eksempelet, du kan tenke på utdanning som en utmerket kandidat til å forutsi lønnen, men også yrket. Det er rimelig å si at yrket avhenger av utdanningsnivået, nemlig høyere utdanning fører ofte til et 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 opp den begrensede effekten av utdanning på yrke, kan vi bruke et interaksjonsbegrep.
Hvis du ser på lønnsligningen, blir den:
If 
er positivt, så innebærer det at et tilleggsutdanningsnivå gir en høyere økning i medianverdien til et hus for et høyt yrkesnivå. Det er med andre ord en interaksjonseffekt mellom utdanning og yrke.
I denne opplæringen skal vi prøve å se hvilke variabler som kan være en god kandidat for interaksjonsbegreper. Vi vil teste om å legge til denne typen informasjon fører til bedre prisprediksjon.
Sammendragsstatistikk
Det er noen få trinn du kan følge før du fortsetter til modellen. Som nevnt tidligere er modellen en generalisering av dataene. Den beste praksisen er å forstå dataene og lage en prediksjon. 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 lag et treningssett og testsett.
Tips: For denne opplæringen må du ha matplotlit og seaborn installert i Python. Du kan installere Python pakke på farten med Jupyter. Du Burde ikke gjør 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 flotte tomter.
Koden nedenfor importerer de nødvendige bibliotekene.
import pandas as pd from sklearn import datasets import tensorflow as tf from sklearn.datasets import load_boston import 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 funksjonsnavn i en matrise.
boston.feature_names
Produksjon
array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')
Du kan gi nytt navn til kolonnene.
df.columns = boston.feature_names df['PRICE'] = boston.target df.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 no
1 no
2 no
3 no
4 no
Name: CHAS, dtype: object
Med pandaer er det enkelt å dele opp datasettet. Du deler opp datasettet tilfeldig med 80 prosent treningssett og 20 prosent testsett. pandaer har en innebygd kostnadsfunksjon for å dele et datarammeeksempel.
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 gjør det mulig å få samme dataramme returnert for alle.
### Create train/test set df_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 | SKATT | 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; den er ofte feilbalansert og overstrødd med ekstreme verdier som kaster av seg analyse og maskinlæringstrening.
Det første trinnet for å få ryddet opp i datasettet er å forstå hvor det trenger rensing. Å rydde opp i et datasett kan være vanskelig å gjøre, spesielt på enhver generaliserbar måte
Google Research-teamet har utviklet et verktøy for denne jobben kalt fasetter som hjelper til med å visualisere dataene og dele dem på alle slags måter. Dette er et godt utgangspunkt for å forstå hvordan datasettet er lagt opp.
Fasetter lar deg finne hvor dataene ikke helt ser ut slik du tenker.
Bortsett fra nettappen deres, gjør Google det enkelt å bygge inn verktøysettet i en Jupyter notisbok.
Det er to deler til fasetter:
- Fasettoversikt
- Fasett dypdykk
Fasettoversikt
Fasettoversikt gir en oversikt over datasettet. Fasettoversikt deler kolonnene med dataene inn i rader med fremtredende informasjon som vises
- prosentandelen manglende observasjon
- min og maks verdier
- statistikk som gjennomsnitt, median og standardavvik.
- Den 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 opplæringssettet 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 en maskinlæringsoppgave. Med dette verktøyet går du ikke glipp av dette avgjørende trinnet, og det fremhever noen avvik.
Fasett dypdykk
Facets Deep Dive er et kult verktøy. Det gjør det mulig å ha litt klarhet på datasettet ditt og zoome helt inn for å se en individuell del av data. Det betyr at du kan fasettere dataene etter rad og kolonne på tvers av alle funksjonene i datasettet.
Vi vil bruke disse to verktøyene med Boston-datasettet.
Merknader: Du kan ikke bruke Facets Overview og Facets Deep Dive samtidig. Du må tømme den bærbare datamaskinen først for å bytte verktøy.
Installer Facet
Du kan bruke Facet-webappen for det meste av analysen. I denne opplæringen vil du se hvordan du bruker den i en Jupyter Notebook.
Først av alt må du installere nbextensions. 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 depotene på datamaskinen din. Du har to valg:
Valg 1) Kopier og lim inn denne koden i terminalen (Anbefales)
Hvis du ikke har Git installert på maskinen din, gå til denne URL-en https://git-scm.com/download/win og følg instruksjonene. Når du er ferdig, kan du bruke git-kommandoen i terminalen for Mac-bruker eller Anaconda-ledeteksten Windows bruker
git clone https://github.com/PAIR-code/facets
Valg 2) Gå til https://github.com/PAIR-code/facets og last ned depotene.
Hvis du velger det første alternativet, havner filen i nedlastningsfilen 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 Facets, må du installere den i Jupyter Notisbok. Du må sette arbeidskatalogen til banen der fasetter er plassert.
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, du har to alternativer. Hvis du har installert Jupyter med Conda for alle brukerne, kopier denne koden:
kan bruke jupyter nbextension install facets-dist/
jupyter nbextension install facets-dist/
Bruk ellers:
jupyter nbextension install facets-dist/ --user
Greit, du er klar. La oss åpne Fasettoversikt.
Oversikt
Oversikt bruker en Python skript for å beregne statistikken. Du må importere skriptet som heter generic_feature_statistics_generator til Jupyter. Ikke bekymre deg; skriptet ligger i fasettfilene.
Du må finne veien. Det er lett gjort. 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 banen din.
# Add the facets overview python code to the python path# Add t
import sys
sys.path.append('/Users/Thomas/facets/facets_overview/python')
Du kan importere skriptet med koden nedenfor.
from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
I windows blir den samme koden
import sys sys.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 ønsker å 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å tabellen som vises, og du bruker navnet på tabellen du vil beregne sammendraget. I ditt eksempel er tabellen som inneholder dataene df_train
# Calculate the feature statistics proto from the datasets and stringify it for use in facets overview
import base64
gfsg = 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 kopierer og limer du bare inn koden nedenfor. Koden kommer direkte fra GitHub. Du bør kunne se dette:
# Display the facets overview visualization for this data# Displ
from IPython.core.display import display, HTML
HTML_TEMPLATE = """<link rel="import" href="/no/nbextensions/facets-dist/facets-jupyter.html" >
<facets-overview id="elem"></facets-overview>
<script>
document.querySelector("#elem").protoInput = "{protostr}";
</script>"""
html = HTML_TEMPLATE.format(protostr=protostr)
display(HTML(html))
Graph
Etter at du har sjekket dataene og deres distribusjon, 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 inline
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style="ticks")
# Compute the correlation matrix
corr = df.corr('pearson')
# Generate a mask for the upper triangle
mask = np.zeros_like(corr, dtype=np.bool)
mask[np.triu_indices_from(mask)] = True
# Set up the matplotlib figure
f, ax = plt.subplots(figsize=(11, 9))
# Generate a custom diverging colormap
cmap = sns.diverging_palette(220, 10, as_cmap=True)
# Draw the heatmap with the mask and correct aspect ratio
sns.heatmap(corr, mask=mask, cmap=cmap, vmax=.3, center=0,annot=True,
square=True, linewidths=.5, cbar_kws={"shrink": .5})
Produksjon
<matplotlib.axes._subplots.AxesSubplot at 0x1a184d6518>
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 PRIS. 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 intercept-termen og DIS kan også være interessant å fokusere på.
Du kan gå litt dypere ved å plotte et parnett. Det vil illustrere mer detaljert korrelasjonskartet du plottet før.
Parnettet vi er sammensatt som følger:
- Øvre del: Spredde tomt med påsatt linje
- Diagonal: Plott med kjernetetthet
- Nedre del: Multivariat kjernetetthetsplott
Du velger fokus på fire uavhengige variabler. Valget tilsvarer variablene med sterk korrelasjon med PRIS
- INDUS
- NOX
- RM
- LSTAT
dessuten PRISEN.
Merknader at standardfeilen legges til som standard i spredningsplottet.
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:
- Pris er negativt korrelert med INDUS, NOX og LSTAT; positivt korrelert med RM.
- Det er en litt ikke-linearitet med LSTAT og PRIS
- 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 kjernedensiteten er interessant på en måte den farger der de fleste punktene er. Forskjellen med spredningsplottet 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 den multivariate tettheten for INDUS og NOX, kan du se den positive korrelasjonen og de to klyngene. Når andelen av industrien er over 18, er nitrogenoksidkonsentrasjonen 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 laget 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 en rullegardinmeny der du kan endre arrangementet av dataene til å kontrollere fasettering, plassering og farge. Til høyre er det en detaljert visning av en bestemt rad med data. Det betyr at du kan klikke på en hvilken som helst prikk med data i sentervisualiseringen for å se detaljene om det aktuelle datapunktet.
Under datavisualiseringstrinnet er du interessert i å se etter den parvise korrelasjonen mellom den uavhengige variabelen på prisen på huset. Det involverer imidlertid 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-plott og farge prikken. Du kan dele variabelen PRICE i fire kategorier, der hver kategori er en kvartil (dvs. 0.25, 0.5, 0.75). Du kaller denne nye variabelen Q_PRICE.
## Check non linearity with important features df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"]) ## Show non linearity between RM and LSTAT ax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")
Fasett dypdykk
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 64 jsonstr = 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 data
from IPython.core.display import display, HTML
# Create Facets template
HTML_TEMPLATE = """<link rel="import" href="/no/nbextensions/facets-dist/facets-jupyter.html">
<facets-dive sprite-image-width="{sprite_size}" sprite-image-height="{sprite_size}" id="elem" height="600"></facets-dive>
<script>
document.querySelector("#elem").data = {jsonstr};
</script>"""
# Load the json dataset and the sprite_size into the template
html = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)
# Display the template
display(HTML(html))
Du er interessert i å se om det er en sammenheng mellom bransjerate, oksidkonsentrasjon, avstand til jobbsenteret og prisen på boligen.
For det deler du først dataene etter bransjeområde og farge med priskvartilen:
- Velg fasetering X og velg INDUS.
- Velg Display og velg DIS. Det vil farge prikkene med kvartilen til boligprisen
her betyr mørkere farger at avstanden til det første jobbsenteret er langt.
Så langt viser det igjen det du vet, lavere bransjerate, høyere pris. Nå kan du se fordelingen etter INDUX, etter NOX.
- Velg fasettering Y og velg NOX.
Nå kan du se at huset langt fra det første jobbsenteret har lavest industriandel og derfor lavest oksidkonsentrasjon. Hvis du velger å vise typen med Q_PRICE og zoomer nede i venstre hjørne, kan du se hvilken type pris det er.
Du har nok et hint om at samspillet mellom IND, NOX og DIS kan være gode kandidater til å forbedre modellen.
tensorflow
I denne delen vil du estimere den lineære klassifikatoren med TensorFlow estimators API. Du vil fortsette som følger:
- Forbered dataene
- Estimer en referansemodell: Ingen interaksjon
- Estimer en modell med interaksjon
Husk at målet med maskinlæring er å minimere feilen. I dette tilfellet vil modellen med lavest gjennomsnittlig kvadratfeil vinne. TensorFlow-estimatoren beregner denne beregningen automatisk.
Forberedelsesdata
I de fleste tilfeller må du transformere dataene dine. Derfor er Facets Overview fascinerende. Fra oppsummeringsstatistikken så du at det er uteliggere. Disse verdiene påvirker estimatene fordi de ikke ser ut som befolkningen du analyserer. Outliers påvirket vanligvis resultatene. For eksempel har en positiv uteligger en tendens til å overvurdere koeffisienten.
En god løsning for å takle dette problemet er å standardisere variabelen. Standardisering betyr et standardavvik på én og middel på null. Prosessen med standardisering involverer to trinn. Først av alt trekker den gjennomsnittsverdien av variabelen. For det andre deler den på standardavviket slik at fordelingen får et enhetsstandardavvik.
Biblioteket sklearn er nyttig for å standardisere variabler. Du kan bruke modulen forbehandling med objektskalaen til dette formålet.
Du kan bruke funksjonen nedenfor for å skalere et datasett. Merk at du ikke skalerer etikettkolonnen og kategoriske variabler.
from sklearn import preprocessing
def 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: Benchmark
Først og fremst trener og tester du en modell uten interaksjon. Hensikten er å se ytelsesmetrikken til modellen.
Måten å trene modellen på er akkurat som veiledningen på API på høyt nivå. Du vil bruke TensorFlow-estimatoren LinearRegressor.
Som en påminnelse må du velge:
- funksjonene som skal settes inn i modellen
- transformere funksjonene
- konstruer den lineære regressoren
- konstruer input_fn-funksjonen
- trene modellen
- test modellen
Du bruker alle variablene i datasettet for å trene modellen. Totalt er det elevel kontinuerlige variabler og en kategorisk variabel
## Add features to the bucket: ### Define continuous list CONTI_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 lager 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a19e76ac8>, '_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 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å togdataene.
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 = 1 INFO:tensorflow:global_step/sec: 144.457 INFO:tensorflow:loss = 76982.734, step = 101 (0.697 sec) INFO:tensorflow:global_step/sec: 258.392 INFO:tensorflow:loss = 21246.334, step = 201 (0.383 sec) INFO:tensorflow:global_step/sec: 227.998 INFO:tensorflow:loss = 30534.78, step = 301 (0.439 sec) INFO:tensorflow:global_step/sec: 210.739 INFO:tensorflow:loss = 36794.5, step = 401 (0.477 sec) INFO:tensorflow:global_step/sec: 234.237 INFO:tensorflow:loss = 8562.981, step = 501 (0.425 sec) INFO:tensorflow:global_step/sec: 238.1 INFO:tensorflow:loss = 34465.08, step = 601 (0.420 sec) INFO:tensorflow:global_step/sec: 237.934 INFO:tensorflow:loss = 12241.709, step = 701 (0.420 sec) INFO:tensorflow:global_step/sec: 220.687 INFO:tensorflow:loss = 11019.228, step = 801 (0.453 sec) INFO:tensorflow:global_step/sec: 232.702 INFO: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. <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a19e76320>
Til slutt anslår du ytelsen 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:43
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train_Boston/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-29-02:40:43
INFO: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 av modellen er 1650. Dette er metrikken å slå i neste avsnitt
Forbedre modellen: Interaksjonsbegrep
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 knyttet sammen og svinger for å forstørre effekten på prisen. Ikke bare samspillet mellom INDUS og NOS påvirker prisen, men også denne effekten er sterkere når den samhandler med DIS.
Det er på tide å generalisere denne ideen og se om du kan forbedre den modellpredikerte modellen.
Du må legge til to nye kolonner til hvert datasett: tog + test. For det oppretter du én funksjon for å beregne interaksjonsleddet og en annen for å beregne trippelinteraksjonsleddet. Hver funksjon produserer en enkelt kolonne. Etter at de nye variablene er opprettet, kan du koble dem sammen til treningsdatasettet og testdatasettet.
Først av alt må du lage en ny variabel for interaksjonen mellom INDUS og NOX.
Funksjonen nedenfor returnerer to datarammer, train og test, med interaksjonen 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 annen funksjon for å beregne trippelinteraksjonsleddet.
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, test
interation_ind_ns_dis_train, interation_ind_ns_dis_test= triple_interaction_term('INDUS', 'NOX', 'DIS','INDUS_NOS_DIS')
Nå som du har alle kolonnene du trenger, kan du legge dem til for å trene og teste datasettet. Du navngir 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 interaksjonsvilkårene 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 list
continuous_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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a1a5d5860>, '_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 = 1 INFO:tensorflow:global_step/sec: 124.844 INFO:tensorflow:loss = 65522.3, step = 101 (0.803 sec) INFO:tensorflow:global_step/sec: 182.704 INFO:tensorflow:loss = 15384.148, step = 201 (0.549 sec) INFO:tensorflow:global_step/sec: 208.189 INFO:tensorflow:loss = 22020.305, step = 301 (0.482 sec) INFO:tensorflow:global_step/sec: 213.855 INFO:tensorflow:loss = 28208.812, step = 401 (0.468 sec) INFO:tensorflow:global_step/sec: 209.758 INFO:tensorflow:loss = 7606.877, step = 501 (0.473 sec) INFO:tensorflow:global_step/sec: 196.618 INFO:tensorflow:loss = 26679.76, step = 601 (0.514 sec) INFO:tensorflow:global_step/sec: 196.472 INFO:tensorflow:loss = 11377.163, step = 701 (0.504 sec) INFO:tensorflow:global_step/sec: 172.82 INFO:tensorflow:loss = 8592.07, step = 801 (0.578 sec) INFO:tensorflow:global_step/sec: 168.916 INFO: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. <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1a5d5e10>
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:14
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train_Boston_1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-29-02:41:14
INFO: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, kunne du redusere tapet. Det betyr at du kan gjøre en bedre prediksjon enn med benchmark-modellen.
