TensorFlow linearna regresija s izrazom aspekta i interakcije

Linearna regresija TensorFlowa

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:

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.

Ista obitelj procjenitelja također pokreće linearni klasifikator kada je oznaka klasa, a ne cijena. U ovom ćemo vodiču pokušati vidjeti koje varijable mogu biti dobri kandidati za interakcijske uvjete. Testirat ćemo dovodi li dodavanje ovakvih informacija do boljeg predviđanja cijene.

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 prvo razumjeti podatke, a zatim napraviti predviđanje. Ako ne poznajete svoje podatke, imate male šanse za poboljšanje svog modela.

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

Savjeti: Za ovaj tutorial potrebno je imati instalirane matplotlib i seaborn. PythonMož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 PythonSeaborn je biblioteka za statističku vizualizaciju izgrađena na matplotlibu. Pruža natractivne 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.

Napomena o verziji: load_boston je zastario u scikit-learn 1.0 i uklonjeno u scikit-learn 1.2 jer skup podataka kodira značajku s rasnim učinkom. Na trenutnoj instalaciji koristite dohvati_stambeni_u_Kaliforniji umjesto toga, ili sami učitajte RAW datoteku. Tijek rada prikazan u nastavku ostaje nepromijenjen; razlikuje se samo program za učitavanje.

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

Nazivi značajki pohranjeni su u objektu feature_names kao niz.

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 ima ugrađenu funkciju uzorkovanja za dijeljenje 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 ispravlja miješanje, tako da se isti retci vraćaju 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

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

The Google Istraživački tim je za ovaj posao razvio alat pod nazivom aspekti što vam pomaže vizualizirati podatke i analizirati ih na sve moguće načine. Ovo je dobra početna točka za razumijevanje načina na koji je skup podataka raspoređen.

Fasete vam omogućuju da pronađete mjesta gdje podaci ne izgledaju baš onako kako očekujete.

Osim njihove web aplikacije, Google olakšava ugradnju 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 odličan alat. Omogućuje vam da dobijete malo jasnoće u svom skupu podataka i da ga zumirate do kraja kako biste vidjeli pojedinačni dio podataka. To znači da možete analizirati podatke po retku i stupcu za bilo koju značajku 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.

Prije nego što se bilo koji alat može koristiti, Facets se mora instalirati u okruženje prijenosnog računala.

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 nemate Git instaliran na svom računalu, posjetite ovu stranicu URL Git za Windows preuzeti stranicu 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 repozitorij PAIR-koda/faseta i preuzmite spremišta.

Stranica repozitorija iznad sadrži gumb za preuzimanje koji koristi opcija 2. Ako odaberete prvu opciju, datoteka će završiti u vašoj mapi za preuzimanje. Možete pustiti datoteku da se preuzme ili je povući na drugu putanju.

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.

Gornji ispis terminala potvrđuje da se facets nalazi u trenutnom radnom direktoriju. 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:

jupyter nbextension install facets-dist/

U suprotnom koristite:

jupyter nbextension install facets-dist/ --user

U redu, spremni ste. Otvorimo Facet Overview.

Pregled aspekata u Jupyter

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="/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))

Graf korelacije i mreža parova

Nakon što provjerite podatke i njihovu distribuciju, možete nacrtati matricu korelacije. Matrica korelacije izračunava Pearsonov koeficijent. Ovaj koeficijent je ograničen između -1 i 1, gdje pozitivna vrijednost označava pozitivnu korelaciju, a negativna vrijednost negativnu korelaciju.

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

Napomena o verziji: maska ​​ispod poziva np.bool, alias koji je zastario u NumPy 1.20 i uklonjeno u NumPy 1.24Na nedavnom NumPy-u isti redak podiže AttributeError: module 'numpy' has no attribute 'bool'ugrađeni bool je zamjena za ulazak.

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

Na gornjoj toplinskoj karti, tamniji kvadrati označavaju jače korelacije. Iz matrice možete vidjeti:

• LSTAT
• RM

Snažno su korelirani s cijenom (CIJENOM). Još jedna uzbudljiva značajka je snažna pozitivna korelacija između NOX-a i INDUS-a, što znači da se te dvije varijable kreću u istom smjeru. Obje su također korelirane s cijenom (CIJENOM). DIS je također u visokoj korelaciji s INDUS-om i NOX-om.

Imate prvu naznaku da INDUS i NOX mogu biti dobri kandidati za interakcijski termin, a DIS bi također mogao biti zanimljiv za usredotočenje.

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

Parna mreža 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

Fokusirate se na četiri neovisne 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 između 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 kreirao Google, Fasete - Detaljan pregled. Sučelje je podijeljeno u četiri glavna dijela. Središnje područje u sredini je zumirajući prikaz podataka. Na vrhu ploče nalazi se padajući izbornik u kojem možete promijeniti raspored podataka kako biste kontrolirali fasetiranje, pozicioniranje i boju. S desne strane nalazi se detaljan prikaz određenog retka podataka. To znači da možete kliknuti na bilo koju točku podataka u središnjoj vizualizaciji da biste vidjeli detalje 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. To jest, možemo stvoriti 2D grafikon i obojiti točkice. Varijablu PRICE 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")

Korištenje Facetsa - Detaljna analiza

Za otvaranje Deep Dive-a, potrebno je transformirati podatke u json format. Pandas ima metodu za to: poziv to_json na DataFrameu.

Prvi redak koda postavlja veličinu spritea prema broju redaka koje skup podataka sadrži.

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

Donji kod dolazi iz Google GitHub. 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="/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 veća.

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.

Istraživanje je rezultiralo s dvije potencijalne interakcije, pa je sljedeći korak njihovo testiranje u stvarnom modelu.

Linearna regresija uz TensorFlow

U ovom odjeljku procijenit ćete model linearne regresije s TensorFlow API za procjenu. Postupit ćete na sljedeći način:

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

Napomena o verziji: o tf-estimator Paket je isporučen u svom konačnom izdanju s TensorFlowom 2.15 i odsutan je od TensorFlowa 2.16 nadalje, tako da tf.estimator.LinearRegressor radi samo na TensorFlowu 1.x osim ako ga ne migrirate na Keras linearni model.

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

Podaci o pripremi

U većini slučajeva, potrebno je transformirati podatke. Zato je Facets Overview fascinantan. Iz sažetka statistike vidjeli ste da postoje outlieri. Te vrijednosti utječu na procjene jer ne izgledaju kao populacija koju analizirate. Outlieri obično pristrasno utječu na rezultate. Na primjer, pozitivni outlier obično precjenjuje koeficijent.

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

Knjižnica scikit učiti korisno je za standardizaciju varijabli. U tu svrhu možete koristiti predobradu modula s mjernim brojem 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 točno isti kao u tutorijalu na 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 treniranje modela koristite sve varijable u skupu podataka. Ukupno postoji dvanaest kontinuiranih varijabli 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 funkcijom 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.9785. Ovo je metrika koju treba nadmašiti u sljedećem odjeljku

Poboljšati model: Pojam interakcije

Tijekom prvog dijela tutorijala vidjeli ste zanimljiv odnos između varijabli. Različite tehnike vizualizacije otkrile su da su INDUS i NOX povezani i da povećavaju međusobni utjecaj na cijenu. Ne samo da interakcija između INDUS-a i NOX-a utječe na cijenu, već je taj učinak jači kada se u interakciji nalazi i DIS.

Vrijeme je da se generalizira ova ideja i vidi može li se poboljšati predviđanje modela.

Svakom skupu podataka morate dodati dva nova stupca: train i test. Za to stvarate jednu funkciju za izračunavanje članka interakcije i drugu za izračunavanje članka trostruke interakcije. Svaka funkcija proizvodi jedan stupac. Nakon što su nove varijable stvorene, možete ih povezati sa skupom podataka za učenje i skupom 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 performansi.

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}

Code

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.9863. Samo dodavanjem dvije nove varijable, mogli ste smanjiti gubitak. To znači da možete napraviti bolje predviđanje nego s referentnim modelom.

Obje brojke potječu iz iste testne podjele od 101 retka, tako da je pad prosječnog gubitka od otprilike 8 posto pripisiv samo dvama stupcima interakcije.

Pitanja i odgovori