TensorFlow linearna regresija s izrazom aspekta i interakcije

U ovom vodiču naučit ćete kako provjeriti podatke i pripremiti ih za izradu jednostavnog zadatka linearne regresije.

Ovaj vodič je podijeljen u dva dijela:

• Potražite interakciju
• Testirajte model

u prethodni vodič, koristili ste skup podataka iz Bostona za procjenu srednje cijene kuće. Bostonski skup podataka malen je, sa samo 506 opažanja. Ovaj skup podataka smatra se mjerilom za isprobavanje novih algoritama linearne regresije.

Skup podataka sastoji se od:

Varijabla	Description
zn	Udio stambenog zemljišta u zonama za parcele veće od 25,000 sq.ft.
industrijski	Udio ne-maloprodajnih poslovnih hektara po gradu.
NOx	koncentracija dušikovih oksida
rm	prosječan broj soba po stanu
starost	udio jedinica u kojima stanuju vlasnici izgrađenih prije 1940
reći	mjerene udaljenosti do pet bostonskih centara za zapošljavanje
porez	stopa poreza na imovinu pune vrijednosti za 10,000 dolara
ptratio	omjer učenika i nastavnika po gradu
medv	Srednja vrijednost domova u kojima žive vlasnici u tisućama dolara
zločinački	stopa kriminala po glavi stanovnika po gradu
Chas	Charles River lažna varijabla (1 ako ograničava rijeku; 0 inače)
B	udio crnaca po gradu

U ovom vodiču ćemo procijeniti srednju cijenu koristeći linearni regresor, ali fokus je na jednom određenom procesu stroj za učenje: “priprema podataka.”

Model generalizira obrazac u podacima. Da biste uhvatili takav uzorak, prvo ga morate pronaći. Dobra praksa je izvršiti analizu podataka prije pokretanja bilo kojeg algoritma strojnog učenja.

Odabir pravih značajki čini veliku razliku u uspjehu vašeg modela. Zamislite da pokušate procijeniti plaću ljudi, ako ne uključite spol kao kovarijatu, završit ćete s lošom procjenom.

Drugi način poboljšanja modela je promatranje korelacije između nezavisne varijable. Vratimo se primjeru, obrazovanje možete zamisliti kao izvrsnog kandidata za predviđanje plaće, ali i zanimanja. Pošteno je reći da zanimanje ovisi o stupnju obrazovanja, naime visoko obrazovanje često vodi do boljeg zanimanja. Ako generaliziramo ovu ideju, možemo reći da se korelacija između zavisne varijable i eksplanatorne varijable može povećati još jednom eksplanatornom varijablom.

Kako bismo obuhvatili ograničeni učinak obrazovanja na zanimanje, možemo upotrijebiti termin interakcije.

Ako pogledate jednadžbu plaća, ona postaje:

If je pozitivan, onda implicira da dodatna razina obrazovanja donosi veće povećanje srednje vrijednosti kuće za visoku razinu zanimanja. Drugim riječima, postoji učinak interakcije između obrazovanja i zanimanja.

U ovom vodiču pokušat ćemo vidjeti koje varijable mogu biti dobar kandidat za uvjete interakcije. Testirat ćemo vodi li dodavanje ove vrste informacija boljem predviđanju cijena.

Sumarna statistika

Postoji nekoliko koraka koje možete slijediti prije nego što prijeđete na model. Kao što je ranije spomenuto, model je generalizacija podataka. Najbolja praksa je razumjeti podatke i napraviti predviđanje. Ako ne poznajete svoje podatke, male su šanse da poboljšate svoj model.

Kao prvi korak, učitajte podatke kao pandas podatkovni okvir i izradite skup za obuku i skup za testiranje.

Savjeti: Za ovaj vodič morate imati instalirane matplotlit i seaborn Python. Možete instalirati Python paket u hodu sa Jupyter, Vas Ne bi trebao napravi to

!conda install -- yes matplotlib

ali

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

Imajte na umu da ovaj korak nije potreban ako imate instalirane matplotlib i seaborn.

Matplotlib je biblioteka za izradu grafikona Python. Seaborn je knjižnica za statističku vizualizaciju izgrađena na temelju matplotliba. Pruža atraktivne i lijepe parcele.

Kod u nastavku uvozi potrebne biblioteke.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
from sklearn.datasets import load_boston
import numpy as np

Knjižnica sklearn uključuje bostonski skup podataka. Možete pozvati njegov API za uvoz podataka.

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

Naziv značajke pohranjuje se u objektu feature_names u nizu.

boston.feature_names

Izlaz

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')

Možete preimenovati stupce.

df.columns = boston.feature_names
df['PRICE'] = boston.target
df.head(2)

Pretvorite varijablu CHAS kao varijablu niza i označite je s da ako je CHAS = 1 i ne ako je 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

S pandama je jednostavno podijeliti skup podataka. Skup podataka nasumično podijelite s 80 posto skupa za obuku i 20 posto skupa za testiranje. pande imaju ugrađenu funkciju troškova za dijeljenje uzorka okvira podataka.

Prvi parametar frac je vrijednost od 0 do 1. Postavite ga na 0.8 da biste nasumično odabrali 80 posto podatkovnog okvira.

Random_state omogućuje vraćanje istog podatkovnog okvira za sve.

### Create train/test set
df_train=df.sample(frac=0.8,random_state=200)
df_test=df.drop(df_train.index)

Možete dobiti oblik podataka. Trebalo bi biti:

• Garnitura vlakova: 506*0.8 = 405
• Ispitni set: 506*0.2 = 101

print(df_train.shape, df_test.shape)

Izlaz

(405, 14) (101, 14)

df_test.head(5)

Izlaz

	KRIM	ZN	INDUS	CHAS	NOX	RM	AGE	DIS	RAD	POREZ	PTRATIO	B	LSTAT	CIJENA
0	0.00632	18.0	2.31	Ne	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	Ne	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	Ne	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	Ne	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	Ne	0.524	6.172	96.1	5.9505	5.0	311.0	15.2	396.90	19.15	27.1

Podaci su zbrkani; često je neuravnotežen i posut izvanrednim vrijednostima koje odbacuju analizu i obuku strojnog učenja.

Prvi korak za čišćenje skupa podataka je razumijevanje gdje treba čišćenje. Čišćenje skupa podataka može biti teško izvesti, osobito na generalizirajući način

Googleov istraživački tim razvio je alat za ovaj posao tzv aspekti koji pomažu vizualizirati podatke i rezati ih na sve načine. Ovo je dobra polazna točka za razumijevanje načina na koji je skup podataka postavljen.

Aspekti vam omogućuju da pronađete gdje podaci ne izgledaju baš onako kako mislite.

Osim njihove web aplikacije, Google olakšava ugradnju kompleta alata u Jupyter bilježnica.

Dva su dijela aspekata:

• Pregled aspekata

• Facets Deep Dive

Pregled aspekata

Facets Overview daje pregled skupa podataka. Pregled aspekata dijeli stupce podataka u retke koji prikazuju istaknute informacije

1. postotak opažanja koje nedostaje
2. minimalne i maksimalne vrijednosti
3. statistike poput srednje vrijednosti, medijana i standardne devijacije.
4. Također dodaje stupac koji pokazuje postotak vrijednosti koje su nule, što je korisno kada je većina vrijednosti nula.
5. Moguće je vidjeti ove distribucije na testnom skupu podataka, kao i na skupu za obuku za svaku značajku. To znači da možete još jednom provjeriti ima li test sličnu distribuciju podacima o vježbanju.

Ovo je barem minimum koji treba učiniti prije bilo kakvog zadatka strojnog učenja. S ovim alatom ne propuštate ovaj ključni korak, a on naglašava neke abnormalnosti.

Facets Deep Dive

Facets Deep Dive je super alat. Omogućuje određenu jasnoću vašeg skupa podataka i zumiranje do kraja kako biste vidjeli pojedinačni dio podataka. To znači da možete rasporediti podatke po retku i stupcu preko bilo koje značajke skupa podataka.

Koristit ćemo ova dva alata s bostonskim skupom podataka.

bilješke: Ne možete koristiti Facets Overview i Facets Deep Dive u isto vrijeme. Prvo morate očistiti bilježnicu da biste promijenili alat.

Instalirajte Facet

Web-aplikaciju Facet možete koristiti za većinu analiza. U ovom vodiču vidjet ćete kako ga koristiti unutar a Jupyter Notebook.

Prije svega, trebate instalirati nbextensions. To se radi s ovim kodom. Kopirate i zalijepite sljedeći kod u terminal vašeg stroja.

pip install jupyter_contrib_nbextensions

Odmah nakon toga trebate klonirati repozitorije na svom računalu. Imate dva izbora:

Opcija 1) Kopirajte i zalijepite ovaj kod u terminal (Preporučeno)

Ako na svom računalu nemate instaliran Git, idite na ovaj URL https://git-scm.com/download/win i slijedite upute. Nakon što ste gotovi, možete koristiti naredbu git u terminalu za Mac korisnika ili Anaconda prompt za Windows korisnik

git clone https://github.com/PAIR-code/facets

Opcija 2) Idi na https://github.com/PAIR-code/facets i preuzmite spremišta.

Ako odaberete prvu opciju, datoteka će završiti u datoteci za preuzimanje. Možete dopustiti preuzimanje datoteke ili je povući na drugu stazu.

Možete provjeriti gdje su Faceti pohranjeni pomoću ove naredbene linije:

echo `pwd`/`ls facets`

Sada kada ste locirali Facets, morate ga instalirati Jupyter Bilježnica. Morate postaviti radni direktorij na stazu na kojoj se nalaze faceti.

Vaš trenutni radni direktorij i lokacija Facets zip trebaju biti isti.

Morate usmjeriti radni direktorij na Facet:

cd facets

Da biste instalirali Facets u Jupyter, imate dvije mogućnosti. Ako ste instalirali Jupyter s Condom za sve korisnike kopirajte ovaj kod:

može koristiti jupyter nbextension install facets-dist/

jupyter nbextension install facets-dist/

U suprotnom koristite:

jupyter nbextension install facets-dist/ --user

U redu, spremni ste. Otvorimo Facet Overview.

SAŽETAK

Pregled koristi a Python skripta za izračunavanje statistike. Morate uvesti skriptu pod nazivom generic_feature_statistics_generator Jupyter. Ne brinite; skripta se nalazi u datotekama faceta.

Morate locirati njegov put. Lako se radi. Otvorite facets, otvorite datoteku facets_overview i onda python. Kopirajte put

Nakon toga, vratite se na Jupyter, i napišite sljedeći kod. Promijenite put '/Users/Thomas/facets/facets_overview/python' u svoj put.

# Add the facets overview python code to the python path# Add t 
import sys
sys.path.append('/Users/Thomas/facets/facets_overview/python')

Možete uvesti skriptu pomoću donjeg koda.

from generic_feature_statistics_generator import 
GenericFeatureStatisticsGenerator

U Windowsima, isti kod postaje

import sys
sys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")

from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator

Da biste izračunali statistiku značajki, morate koristiti funkciju GenericFeatureStatisticsGenerator(), a vi koristite objekt ProtoFromDataFrames. Podatkovni okvir možete proslijediti u rječniku. Na primjer, ako želimo stvoriti sumarnu statistiku za set vlakova, možemo pohraniti informacije u rječnik i koristiti ih u objektu `ProtoFromDataFrames“

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

Naziv je naziv prikazane tablice, a vi koristite naziv tablice za koju želite izračunati sažetak. U vašem primjeru, tablica koja sadrži podatke je 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")

Na kraju, samo kopirajte i zalijepite kod u nastavku. Kod dolazi izravno s GitHuba. Trebali biste moći vidjeti ovo:

# Display the facets overview visualization for this data# Displ 
from IPython.core.display import display, HTML

HTML_TEMPLATE = """<link rel="import" href="/hr/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))

Grafikon

Nakon što provjerite podatke i njihovu distribuciju, možete iscrtati korelacijsku matricu. Korelacijska matrica izračunava Pearsonov koeficijent. Ovaj koeficijent je vezan između -1 i 1, pri čemu pozitivna vrijednost označava pozitivnu korelaciju, a negativna vrijednost negativnu korelaciju.

Zanima vas koje varijable mogu biti dobar kandidat za uvjete interakcije.

## 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})

Izlaz

<matplotlib.axes._subplots.AxesSubplot at 0x1a184d6518>

png

Iz matrice možete vidjeti:

• LSTAT
• RM

U velikoj su korelaciji s PRICE. Još jedna uzbudljiva značajka je jaka pozitivna korelacija između NOX i INDUS, što znači da se te dvije varijable kreću u istom smjeru. Osim toga, tu su i korelacije s CIJENOM. DIS je također u visokoj korelaciji s IND i NOX.

Imate neke prve naznake da IND i NOX mogu biti dobri kandidati za presretanje, a DIS bi također mogao biti zanimljiv za fokusiranje.

Možete ići malo dublje iscrtavanjem mreže parova. To će detaljnije ilustrirati mapu korelacije koju ste prije iscrtali.

Mreža parova sastavljena je na sljedeći način:

• Gornji dio: Raspršeni dijagram s uklopljenom linijom
• Dijagonala: dijagram gustoće jezgre
• Donji dio: Multivarijantni grafikon gustoće jezgre

Vi birate fokus na četiri nezavisne varijable. Izbor odgovara varijablama s jakom korelacijom s CIJENOM

• INDUS
• NOX
• RM
• LSTAT

štoviše, CIJENA.

bilješke da se standardna pogreška prema zadanim postavkama dodaje dijagramu raspršenosti.

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)

Izlaz

Počnimo s gornjim dijelom:

• Cijena je u negativnoj korelaciji s INDUS-om, NOX-om i LSTAT-om; u pozitivnoj korelaciji s RM.
• Postoji mala nelinearnost kod LSTAT-a i PRICE-a
• Postoji poput ravne linije kada je cijena jednaka 50. Iz opisa skupa podataka, PRICE je skraćen na vrijednost od 50

Dijagonala

• Čini se da NOX ima dva klastera, jedan oko 0.5 i jedan oko 0.85.

Da biste saznali više o tome, možete pogledati donji dio. Multivarijatna gustoća kernela je zanimljiva u smislu da boji tamo gdje je većina točaka. Razlika s dijagramom raspršenosti crta gustoću vjerojatnosti, iako nema točke u skupu podataka za danu koordinatu. Kada je boja jača, to ukazuje na visoku koncentraciju točaka oko ovog područja.

Ako provjerite multivarijantnu gustoću za INDUS i NOX, možete vidjeti pozitivnu korelaciju i dva klastera. Kada je udio industrije iznad 18, koncentracija dušikovih oksida je iznad 0.6.

Možete razmisliti o dodavanju interakcije između INDUS-a i NOX-a u linearni odnos.

Konačno, možete koristiti drugi alat koji je stvorio Google, Facets Deep Dive. Sučelje je podijeljeno u četiri glavna dijela. Središnje područje u sredini je zumirani prikaz podataka. Na vrhu ploče nalazi se padajući izbornik na kojem možete promijeniti raspored podataka kako biste kontrolirali fasetiranje, pozicioniranje i boju. S desne strane je detaljan prikaz određenog reda podataka. To znači da možete kliknuti bilo koju točku podataka u središnjoj vizualizaciji da biste vidjeli pojedinosti o toj određenoj podatkovnoj točki.

Tijekom koraka vizualizacije podataka, zainteresirani ste za traženje parne korelacije između nezavisne varijable o cijeni kuće. Međutim, uključuje najmanje tri varijable, a 3D dijagrami su komplicirani za rad.

Jedan od načina za rješavanje ovog problema je stvaranje kategoričke varijable. Odnosno, možemo stvoriti 2D crtež obojati točku. Varijablu CIJENA možete podijeliti u četiri kategorije, pri čemu je svaka kategorija kvartil (tj. 0.25, 0.5, 0.75). Ovu novu varijablu nazivate 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")

Facets Deep Dive

Da biste otvorili Deep Dive, trebate transformirati podatke u json format. Pande kao objekt za to. Možete koristiti to_json nakon Pandas skupa podataka.

Prvi redak koda obrađuje veličinu skupa podataka.

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

Kod u nastavku dolazi s Google GitHuba. Nakon što pokrenete kod, trebali biste moći vidjeti ovo:

# Display thde Dive visualization for this data
from IPython.core.display import display, HTML

# Create Facets template  
HTML_TEMPLATE = """<link rel="import" href="/hr/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))

Zanima vas postoji li veza između industrijske stope, koncentracije oksida, udaljenosti do centra za zapošljavanje i cijene kuće.

Za to prvo podijelite podatke prema rasponu industrije i boji s kvartilom cijene:

• Odaberite fasetu X i odaberite INDUS.
• Odaberite Display i odaberite DIS. Obojit će točkice kvartilom cijene kuće

ovdje tamnije boje znače da je udaljenost do prvog centra za zapošljavanje velika.

Za sada se ponovno pokazuje što znate, niža stopa industrije, viša cijena. Sada možete pogledati raščlambu po INDUX-u, po NOX-u.

• Odaberite fasetu Y i odaberite NOX.

Sada možete vidjeti da kuća daleko od prvog centra za zapošljavanje ima najniži udio u industriji i stoga najnižu koncentraciju oksida. Ako odaberete prikazati vrstu s Q_PRICE i zumirati donji lijevi kut, možete vidjeti koja je to vrsta cijene.

Imate još jednu naznaku da interakcija između IND, NOX i DIS može biti dobar kandidat za poboljšanje modela.

TensorFlow

U ovom ćete odjeljku procijeniti linearni klasifikator s TensorFlow API-jem za procjene. Postupit ćete na sljedeći način:

• Pripremite podatke
• Procijenite referentni model: Nema interakcije
• Procijeniti model s interakcijom

Zapamtite, cilj strojnog učenja je minimiziranje pogreške. U ovom slučaju će pobijediti model s najmanjom srednjom kvadratnom pogreškom. Procjenitelj TensorFlow automatski izračunava ovu metriku.

Podaci o pripremi

U većini slučajeva morate transformirati svoje podatke. Zato je Facets Overview fascinantan. Iz sažete statistike vidjeli ste da postoje odstupanja. Te vrijednosti utječu na procjene jer ne izgledaju poput populacije koju analizirate. Outlieri su obično pristrani u rezultatima. Na primjer, pozitivni outlier ima tendenciju precijeniti koeficijent.

Dobro rješenje za rješavanje ovog problema je standardizacija varijable. Standardizacija znači standardnu ​​devijaciju jedan i srednju vrijednost nula. Proces standardizacije uključuje dva koraka. Prije svega, oduzima srednju vrijednost varijable. Drugo, dijeli se standardnom devijacijom tako da distribucija ima jediničnu standardnu ​​devijaciju.

Knjižnica sklearn korisna je za standardizaciju varijabli. U tu svrhu možete koristiti pretprocesiranje modula s mjerilom objekta.

Možete upotrijebiti funkciju u nastavku za skaliranje skupa podataka. Imajte na umu da ne skalirate stupac oznake i kategoričke varijable.

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

Ovu funkciju možete koristiti za konstruiranje skaliranog skupa vlaka/testiranja.

df_train_scale = standardize_data(df_train)
df_test_scale = standardize_data(df_test)

Osnovna regresija: referentna vrijednost

Prije svega, trenirate i testirate model bez interakcije. Svrha je vidjeti metriku izvedbe modela.

Način treniranja modela je isti kao u vodiču API visoke razine. Koristit ćete TensorFlow procjenitelj LinearRegressor.

Podsjećamo, trebate odabrati:

• značajke koje treba staviti u model
• transformirati značajke
• konstruirati linearni regresor
• konstruirajte funkciju input_fn
• trenirati model
• testirati model

Za obuku modela koristite sve varijable u skupu podataka. Ukupno postoje kontinuirane varijable razine i jedna kategorička varijabla

## 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']

Značajke pretvarate u numerički stupac ili kategorički stupac

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'])]

Model stvarate s linearRegressorom. Model spremate u mapu train_Boston

model = tf.estimator.LinearRegressor(    
	model_dir="train_Boston",     
    feature_columns=categorical_features + continuous_features)

Izlaz

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}

Svaki stupac u nizu ili testnim podacima pretvara se u tenzor pomoću funkcije 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)

Model procjenjujete na podacima o vlaku.

model.train(input_fn=get_input_fn(df_train_scale, 
                                      num_epochs=None,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

Izlaz

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>

Na kraju procjenjujete performanse modela na ispitnom setu

model.evaluate(input_fn=get_input_fn(df_test_scale, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

Izlaz

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}

Gubitak modela je 1650. Ovo je metrika koju treba nadmašiti u sljedećem odjeljku

Poboljšati model: Pojam interakcije

Tijekom prvog dijela lekcije vidjeli ste zanimljiv odnos između varijabli. Različite tehnike vizualizacije otkrile su da su INDUS i NOS međusobno povezani i okreću se kako bi povećali učinak na cijenu. Ne samo da interakcija između INDUS-a i NOS-a utječe na cijenu, već je i taj učinak jači kada je u interakciji s DIS-om.

Vrijeme je da generaliziramo ovu ideju i vidimo možete li poboljšati model predviđeni model.

Morate dodati dva nova stupca svakom skupu podataka: treniranje + test. Za to stvarate jednu funkciju za izračunavanje člana interakcije i drugu za izračunavanje člana trostruke interakcije. Svaka funkcija proizvodi jedan stupac. Nakon što su nove varijable stvorene, možete ih spojiti u skup podataka za obuku i skup podataka za testiranje.

Prije svega, trebate stvoriti novu varijablu za interakciju između INDUS-a i NOX-a.

Funkcija u nastavku vraća dva podatkovna okvira, treniranje i testiranje, s interakcijom između var_1 i var_2, u vašem slučaju 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

Pohranjujete dva nova stupca

interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')
interation_ind_ns_train.shape
(325,)

Drugo, kreirate drugu funkciju za izračunavanje člana trostruke interakcije.

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

Sada kada imate sve potrebne stupce, možete ih dodati u skup podataka za obuku i testiranje. Ova dva nova podatkovna okvira imenujete:

• df_vlak_novi
• df_test_novo

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)

Izlaz

To je to; možete procijeniti novi model s uvjetima interakcije i vidjeti kakva je metrika izvedbe.

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)

Izlaz

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}

KODEKS

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)

Izlaz

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)

Izlaz

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}

Novi gubitak je 1515. Samo dodavanjem dvije nove varijable, mogli ste smanjiti gubitak. To znači da možete napraviti bolje predviđanje nego s referentnim modelom.