Regresie liniară TensorFlow cu fațetă & Termen de interacțiune

În acest tutorial, veți învăța cum să verificați datele și să le pregătiți pentru a crea o sarcină de regresie liniară simplă.

Acest tutorial este împărțit în două părți:

• Căutați interacțiune
• Testați modelul

În tutorialul anterior, ați folosit setul de date Boston pentru a estima prețul mediu al unei case. Setul de date Boston are o dimensiune mică, cu doar 506 de observații. Acest set de date este considerat un reper pentru a încerca noi algoritmi de regresie liniară.

Setul de date este compus din:

Variabil	Descriere
zn	Proporția terenurilor rezidențiale zonate pentru loturi de peste 25.000 de metri pătrați.
indus	Proporția de acri de afaceri care nu sunt cu amănuntul pe oraș.
nox	concentrația de oxizi nitrici
rm	numărul mediu de camere pe locuință
vârstă	proporția unităților ocupate de proprietari construite înainte de 1940
dis	distanțe ponderate până la cinci centre de angajare din Boston
impozit	rata totală a impozitului pe proprietate pe 10.000 de dolari
ptratio	raportul elev-profesor de un oraș
medv	Valoarea medie a locuințelor ocupate de proprietari în mii de dolari
crim	rata criminalității pe cap de locuitor în funcție de oraș
chas	Variabilă falsă a râului Charles (1 dacă limitează râul; 0 în caz contrar)
B	proporția de negri de către oraș

În acest tutorial, vom estima prețul median folosind un regresor liniar, dar accentul este pus pe un anumit proces de învățare automată: „pregătirea datelor”.

Un model generalizează modelul din date. Pentru a surprinde un astfel de model, trebuie să îl găsiți mai întâi. O bună practică este de a efectua o analiză a datelor înainte de a rula orice algoritm de învățare automată.

Alegerea caracteristicilor potrivite face diferența în succesul modelului dvs. Imaginați-vă că încercați să estimați salariul unui popor, dacă nu includeți sexul ca un covariabil, veți ajunge la o estimare slabă.

O altă modalitate de a îmbunătăți modelul este de a analiza corelația dintre variabila independentă. Revenind la exemplu, vă puteți gândi la educație ca la un candidat excelent pentru a prezice salariul, dar și ocupația. Este corect să spunem că ocupația depinde de nivelul de educație, și anume învățământul superior duce deseori la o ocupație mai bună. Dacă generalizăm această idee, putem spune că corelația dintre variabila dependentă și o variabilă explicativă poate fi mărită cu încă o altă variabilă explicativă.

Pentru a surprinde efectul limitat al educației asupra ocupației, putem folosi un termen de interacțiune.

Dacă te uiți la ecuația salariului, devine:

Dacă este pozitiv, atunci implică faptul că un nivel suplimentar de educație produce o creștere mai mare a valorii medii a unei case pentru un nivel ridicat de ocupație. Cu alte cuvinte, există un efect de interacțiune între educație și ocupație.

În acest tutorial, vom încerca să vedem ce variabile pot fi un bun candidat pentru termenii de interacțiune. Vom testa dacă adăugarea acestui tip de informații duce la o mai bună predicție a prețului.

În acest tutorial, veți învăța

• Rezumatul statisticilor
• Prezentare generală a fațetelor
• Fațete Deep Dive
• Instalați fațeta
• Prezentare generală
• Grafic
• Fațete Deep Dive
• TensorFlow
• Date de pregătire
• Regresie de bază: etalon
• Îmbunătățiți modelul: termen de interacțiune

Rezumatul statisticilor

Există câțiva pași pe care îi puteți urma înainte de a trece la model. După cum sa menționat anterior, modelul este o generalizare a datelor. Cea mai bună practică de potrivire este să înțelegeți datele și să faceți o predicție. Dacă nu vă cunoașteți datele, aveți șanse reduse de a vă îmbunătăți modelul.

Ca prim pas, încărcați datele ca un cadru de date pandas și creați un set de antrenament și un set de testare.

Sfaturi: Pentru acest tutorial, trebuie să aveți matplotlit și seaborn instalate în Python. Puteți instala pachetul Python din mers cu Jupyter. Nu ar trebui să faci asta

!conda install -- yes matplotlib

dar

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

Rețineți că acest pas nu este necesar dacă aveți instalat matplotlib și seaborn.

Matplotlib este biblioteca pentru a crea un grafic în Python. Seaborn este o bibliotecă de vizualizare statistică construită deasupra matplotlib. Oferă parcele atractive și frumoase.

Codul de mai jos importă bibliotecile necesare.

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

Biblioteca sklearn include setul de date Boston. Puteți apela API-ul său pentru a importa datele.

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

Numele caracteristicii este stocat în obiectul feature_names într-o matrice.

boston.feature_names

Ieșire

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Puteți redenumi coloanele.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Conversiați variabila CHAS ca o variabilă șir și o etichetați cu yes dacă CHAS = 1 și nu dacă CHAS = 0


df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
Cu pandele, este simplu să împărțiți setul de date. Împărțiți aleatoriu setul de date cu un set de antrenament de 80% și un set de testare de 20%. Pandele au o funcție de cost încorporată pentru a împărți un eșantion de cadre de date.
Primul parametru frac este o valoare de la 0 la 1. Îl setați la 0,8 pentru a selecta aleatoriu 80 la sută din cadrul de date.
Random_state permite să fie returnat același cadru de date pentru toată lumea.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Puteți obține forma datelor. Ar trebui să fie:

Set tren: 506 * 0,8 = 405
Set de testare: 506 * 0,2 = 101

print(df_train.shape, df_test.shape)
Ieșire 
(405, 14) (101, 14) 
 
df_test.head(5)
Ieșire
 

 
 
 
 
CRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
VÂRSTĂ 
 
DIS 
 
RAD 
 
IMPOZIT 
 
PTRATIO 
 
B 
 
LSTAT 
 
PREȚ 
 

 
 
0 
 
0,00632 
 
18.0 
 
2.31 
 
Nu 
 
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 
 
Nu 
 
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 
 
Nu 
 
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 
 
Nu 
 
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 
 
Nu 
 
0,524 
 
6.172 
 
96.1 
 
5,9505 
 
5.0 
 
311.0 
 
15.2 
 
396,90 
 
19.15 
 
27.1 
 

 

 

Datele sunt dezordonate; este deseori dezechilibrat și presărat cu valori anterioare care aruncă analiza și instruirea automată.
Primul pas pentru a curăța setul de date este să înțelegeți unde trebuie curățat. Curățarea unui set de date poate fi dificil de făcut, în special în orice mod generalizabil
Echipa de cercetare Google a dezvoltat un instrument pentru acest job numit Facetele, care ajută la vizualizarea datelor și felierea acestora în tot felul de maniere. Acesta este un bun punct de plecare pentru a înțelege modul în care este setat setul de date.
Fațetele vă permit să găsiți unde datele nu arată chiar așa cum gândiți.
Cu excepția aplicației web, Google facilitează încorporarea setului de instrumente într-un notebook Jupyter.
Există două părți ale fațetelor:

Prezentare generală a fațetelor


Fațete Deep Dive


Prezentare generală a fațetelor
Facets Overview oferă o prezentare generală a setului de date. Prezentare generală a fațetelor împarte coloanele datelor în rânduri de informații relevante afișate

procentul de observație lipsă
valorile min și max
statistici precum media, mediana și deviația standard.
De asemenea, adaugă o coloană care arată procentul de valori care sunt zero, ceea ce este util atunci când majoritatea valorilor sunt zero.
Este posibil să vedeți aceste distribuții pe setul de date de testare, precum și setul de instruire pentru fiecare caracteristică. Înseamnă că puteți verifica de două ori dacă testul are o distribuție similară cu datele de antrenament.

Acesta este cel puțin minimul de făcut înainte de orice sarcină de învățare automată. Cu acest instrument, nu ratați acest pas crucial și evidențiază unele anomalii.

Fațete Deep Dive
Facets Deep Dive este un instrument interesant. Vă permite să aveți o anumită claritate asupra setului de date și să măriți până la capăt pentru a vedea o bucată de date individuală. Înseamnă că puteți face fațeta datelor pe rând și coloană pe oricare dintre caracteristicile setului de date.
Vom folosi aceste două instrumente cu setul de date Boston.
Notă : Nu puteți utiliza Facets Overview și Facets Deep Dive în același timp. Mai întâi trebuie să ștergeți caietul pentru a schimba instrumentul.

Instalați fațeta
Puteți utiliza aplicația web Facet pentru cea mai mare parte a analizei. În acest tutorial, veți vedea cum să-l utilizați într-un notebook Jupyter.
În primul rând, trebuie să instalați nbextensions. Se face cu acest cod. Copiați și lipiți următorul cod în terminalul mașinii dvs.
pip install jupyter_contrib_nbextensions 
Imediat după aceea, trebuie să clonați depozitele din computer. Aveți două opțiuni:
Opțiunea 1) Copiați și lipiți acest cod în terminal (recomandat)
Dacă nu aveți Git instalat pe computerul dvs., accesați această adresă URL https://git-scm.com/download/win și urmați instrucțiunile. Odată ce ați terminat, puteți utiliza comanda git din terminal pentru utilizatorul Mac sau solicitarea Anaconda pentru utilizatorul Windows
git clone https://github.com/PAIR-code/facets 
Opțiunea 2) Accesați https://github.com/PAIR-code/facets și descărcați depozitele.

Dacă alegeți prima opțiune, fișierul ajunge în fișierul dvs. de descărcare. Puteți lăsa fișierul să se descarce sau să îl trageți pe o altă cale.
Puteți verifica unde este stocată Facets cu această linie de comandă:
echo `pwd`/`ls facets` 
Acum că ați localizat fațete, trebuie să o instalați în Jupyter Notebook. Trebuie să setați directorul de lucru pe calea în care se află fațetele.
Actualul dvs. director de lucru și locația zip-ului Facets ar trebui să fie aceleași.

Trebuie să îndreptați directorul de lucru către Facet:
cd facets
Pentru a instala fațete în Jupyter, aveți două opțiuni. Dacă ați instalat Jupyter cu Conda pentru toți utilizatorii, copiați acest cod:
poate folosi jupyter nbextension install facets-dist /
jupyter nbextension install facets-dist/
În caz contrar, utilizați:
jupyter nbextension install facets-dist/ --user
Bine, ești pregătit. Să deschidem Facet Overview.

Prezentare generală
Prezentarea generală utilizează un script Python pentru a calcula statisticile. Trebuie să importați scriptul numit generic_feature_statistics_generator în Jupyter. Nu vă faceți griji; scriptul se află în fișierele cu fațete.
Trebuie să-i localizezi calea. Se face ușor. Deschideți fațete, deschideți fișierul facets_overview și apoi python. Copiați calea

După aceea, reveniți la Jupyter și scrieți următorul cod. Schimbați calea „/ Users / Thomas / facets / facets_overview / python” pe calea dvs.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Puteți importa scriptul cu codul de mai jos.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
În Windows, același cod devine
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Pentru a calcula statisticile caracteristicilor, trebuie să utilizați funcția GenericFeatureStatisticsGenerator () și să utilizați obiectul ProtoFromDataFrames. Puteți trece cadrul de date într-un dicționar. De exemplu, dacă dorim să creăm o statistică rezumativă pentru setul de trenuri, putem stoca informațiile într-un dicționar și le putem folosi în obiectul „ProtoFromDataFrames“


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

Nume este numele afișării tabelului și utilizați numele tabelului pe care doriți să îl calculați. În exemplul dvs., tabelul care conține datele este 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")
În cele din urmă, trebuie doar să copiați și să lipiți codul de mai jos. Codul vine direct de la GitHub. Ar trebui să puteți vedea acest lucru:

# 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))
 
Grafic
După ce verificați datele și distribuția acestora, puteți trasa o matrice de corelație. Matricea de corelație calculează coeficientul Pearson. Acest coeficient este legat între -1 și 1, cu o valoare pozitivă indică o corelație pozitivă și o valoare negativă o corelație negativă.
Sunteți interesat să vedeți ce variabile pot fi un bun candidat pentru termenii de interacțiune.
## 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})
Ieșire 

png

Din matrice, puteți vedea:

LSTAT
RM

Sunt puternic corelate cu PRICE. O altă caracteristică interesantă este corelația puternică pozitivă dintre NOX și INDUS, ceea ce înseamnă că aceste două variabile se mișcă în aceeași direcție. În plus, există și corelații cu PREȚUL. DIS este, de asemenea, puternic corelat cu IND și NOX.
Aveți câteva indicii despre faptul că IND și NOX pot fi candidați buni pentru termenul de interceptare, iar DIS ar putea fi, de asemenea, interesant să vă concentrați.
Puteți merge puțin mai adânc trasând o grilă de perechi. Acesta va ilustra mai detaliat harta de corelație pe care ați trasat-o anterior.
Grila de perechi sunt compuse după cum urmează:

Partea superioară: parcela împrăștiată cu linie montată
Diagonală: graficul densității nucleului
Partea inferioară: grafic de densitate a nucleului multivariat

Alegeți focalizarea pe patru variabile independente. Alegerea corespunde variabilelor cu corelație puternică cu PRICE

INDUS
NOX
RM
LSTAT

mai mult, PRETUL.
Rețineți că eroarea standard este adăugată în mod implicit la graficul de împrăștiere.
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)
Ieșire 

Să începem cu partea de sus:

Prețul este corelat negativ cu INDUS, NOX și LSTAT; corelat pozitiv cu RM.
Există o ușor neliniaritate cu LSTAT și PRICE
Există ca o linie dreaptă când prețul este egal cu 50. Din descrierea setului de date, PRICE a fost trunchiat la valoarea de 50

Diagonală

NOX pare să aibă două clustere, unul în jurul valorii de 0,5 și unul în jurul valorii de 0,85.

Pentru a verifica mai multe despre aceasta, puteți privi partea inferioară. Densitatea kernelului multivariat este interesantă într-un sens, colorează acolo unde sunt majoritatea punctelor. Diferența cu graficul de dispersie atrage o densitate de probabilitate, chiar dacă nu există niciun punct în setul de date pentru o coordonată dată. Când culoarea este mai puternică, indică o concentrație mare de punct în jurul acestei zone.
Dacă verificați densitatea multivariată pentru INDUS și NOX, puteți vedea corelația pozitivă și cele două clustere. Când ponderea industriei este peste 18, concentrația de oxizi nitric este mai mare de 0,6.
Vă puteți gândi să adăugați o interacțiune între INDUS și NOX în relația liniară.
În cele din urmă, puteți utiliza al doilea instrument creat de Google, Facets Deep Dive. Interfața este împărțită în patru secțiuni principale. Zona centrală din centru este o afișare zoomabilă a datelor. În partea de sus a panoului, se află meniul derulant în care puteți schimba dispunerea datelor pentru a controla fațetarea, poziționarea și culoarea. În dreapta, există o vedere detaliată a unui rând specific de date. Înseamnă că puteți face clic pe orice punct de date din vizualizarea centrală pentru a vedea detaliile despre acel punct de date.
În timpul etapei de vizualizare a datelor, sunteți interesat să căutați corelația pereche între variabila independentă a prețului casei. Cu toate acestea, implică cel puțin trei variabile, iar graficele 3D sunt complicate de lucrat.
O modalitate de abordare a acestei probleme este crearea unei variabile categorice. Adică, putem crea un grafic 2D o culoare punct. Puteți împărți variabila PRICE în patru categorii, fiecare categorie fiind o quartilă (adică 0,25, 0,5, 0,75). Numiți această nouă variabilă 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")


Fațete Deep Dive
Pentru a deschide Deep Dive, trebuie să transformați datele într-un format json. Pandele ca obiect pentru asta. Puteți utiliza to_json după setul de date Pandas.
Prima linie de cod gestionează dimensiunea setului de date.
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')
Codul de mai jos provine de la Google GitHub. După ce rulați codul, ar trebui să puteți vedea acest lucru:

# 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))
Sunteți interesat să vedeți dacă există o legătură între rata industriei, concentrația de oxid, distanța până la centrul de muncă și prețul casei.
Pentru aceasta, mai întâi împărțiți datele în funcție de gama și culoarea industriei cu quartila de preț:

Selectați fațetarea X și alegeți INDUS.
Selectați Afișare și alegeți DIS. Acesta va colora punctele cu quartila prețului casei

aici, culorile mai închise înseamnă că distanța până la primul centru de muncă este departe.
Până în prezent, arată din nou ceea ce știi, rata industrială mai mică, prețul mai mare. Acum puteți vedea defalcarea pe INDUX, pe NOX.

Selectați fațetarea Y și alegeți NOX.

Acum puteți vedea că casa, departe de primul centru de muncă, are cea mai mică pondere din industrie și, prin urmare, cea mai mică concentrație de oxid. Dacă alegeți să afișați tipul cu Q_PRICE și să măriți colțul din stânga jos, puteți vedea ce tip de preț este.
Aveți un alt indiciu că interacțiunea dintre IND, NOX și DIS poate fi un bun candidat pentru a îmbunătăți modelul.

TensorFlow
În această secțiune, veți estima clasificatorul liniar cu TensorFlow estimators API. Veți proceda după cum urmează:

Pregătiți datele
Estimează un model de referință: fără interacțiune
Estimează un model cu interacțiune

Amintiți-vă, scopul învățării automate este minimizarea erorii. În acest caz, va câștiga modelul cu cea mai mică eroare pătrată medie. Estimatorul TensorFlow calculează automat această valoare.
Date de pregătire
În majoritatea cazurilor, trebuie să vă transformați datele. De aceea, Facets Overview este fascinant. Din statistica sumară, ați văzut că există valori aberante. Aceste valori afectează estimările deoarece nu arată ca populația pe care o analizați. Valorile aberante au influențat de obicei rezultatele. De exemplu, o valoare anterioară pozitivă tinde să supraestimeze coeficientul.
O soluție bună pentru a aborda această problemă este standardizarea variabilei. Standardizarea înseamnă o abatere standard de unu și înseamnă zero. Procesul de standardizare presupune doi pași. În primul rând, scade valoarea medie a variabilei. În al doilea rând, se împarte la varianță astfel încât distribuția să aibă o varianță unitară
Biblioteca sklearn este utilă pentru standardizarea variabilelor. Puteți utiliza preprocesarea modulului cu scala obiectelor în acest scop.
Puteți utiliza funcția de mai jos pentru a scala un set de date. Rețineți că nu scalați coloana etichetei și variabilele categorice.
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
Puteți utiliza funcția pentru a construi setul de tren / test scalat.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Regresie de bază: etalon
În primul rând, antrenezi și testezi un model fără interacțiune. Scopul este de a vedea metrica de performanță a modelului.
Modul de a instrui modelul este exact ca și tutorialul pentru API de nivel înalt . Veți utiliza estimatorul TensorFlow LinearRegressor.
Ca memento, trebuie să alegeți:

caracteristicile de pus în model
transformă caracteristicile
construiți regresorul liniar
construiți funcția input_fn
antrenează modelul
testați modelul

Utilizați toate variabilele din setul de date pentru a antrena modelul. În total, există un număr de variabile continue și o variabilă categorică
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Puteți converti caracteristicile într-o coloană numerică sau coloană categorică
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'])]
Creați modelul cu linearRegressor. Stocați modelul în folderul train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Ieșire 
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}
Fiecare coloană din tren sau date de testare este convertită într-un tensor cu funcția 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)
Estimați modelul pe datele trenului.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Ieșire 
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.
În cele din urmă, estimați performanțele modelului pe setul de testare
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Ieșire 
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}
Pierderea modelului este 1650. Aceasta este metrica de bătut în secțiunea următoare

Îmbunătățiți modelul: termen de interacțiune
În prima parte a tutorialului, ați văzut o relație interesantă între variabile. Diferitele tehnici de vizualizare au arătat că INDUS și NOS sunt legate între ele și se transformă pentru a mări efectul asupra prețului. Nu numai interacțiunea dintre INDUS și NOS afectează prețul, ci și acest efect este mai puternic atunci când interacționează cu DIS.
Este timpul să generalizați această idee și să vedeți dacă puteți îmbunătăți modelul prevăzut de model.
Trebuie să adăugați două coloane noi la fiecare set de seturi de date: tren + test. Pentru aceasta, creați o funcție pentru a calcula termenul de interacțiune și alta pentru a calcula termenul de interacțiune triplă. Fiecare funcție produce o singură coloană. După crearea noilor variabile, le puteți concatena cu setul de date de antrenament și setul de date de testare.
În primul rând, trebuie să creați o nouă variabilă pentru interacțiunea dintre INDUS și NOX.
Funcția de mai jos returnează două cadre de date, tren și test, cu interacțiunea dintre var_1 și var_2, în cazul dvs. INDUS și 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
Stocați cele două coloane noi
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
În al doilea rând, creați o a doua funcție pentru a calcula triplul termen de interacțiune.
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')
Acum că aveți toate coloanele necesare, le puteți adăuga pentru a antrena și testa setul de date. Numiți aceste două noi date cadru:

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)
Ieșire 

Aia este; puteți estima noul model cu termenii de interacțiune și puteți vedea cum este metrica performanței.
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)
Ieșire 
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}
COD
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)
Ieșire 
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)
Ieșire 
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}
Noua pierdere este 1515. Doar adăugând două variabile noi, ați reușit să reduceți pierderea. Înseamnă că puteți face o predicție mai bună decât cu modelul de referință.