Lineární regrese TensorFlow s Facet & Termín interakce

V tomto kurzu se naučíte, jak zkontrolovat data a připravit je na vytvoření jednoduché úlohy lineární regrese.

Tento kurz je rozdělen do dvou částí:

• Hledejte interakci
• Vyzkoušejte model

V předchozím kurzu jste použili bostonskou datovou sadu k odhadu střední ceny domu. Bostonská datová sada má malou velikost a má pouze 506 pozorování. Tato datová sada je považována za měřítko pro vyzkoušení nových algoritmů lineární regrese.

Datová sada se skládá z:

Variabilní	Popis
zn	Podíl obytných pozemků zónovaných na pozemcích přes 25 000 čtverečních stop.
průmysl	Podíl neprodejních obchodních akrů na město.
nox	koncentrace oxidů dusnatých
rm	průměrný počet pokojů na byt
stáří	podíl vlastnických jednotek postavených před rokem 1940
dis	vážené vzdálenosti do pěti bostonských center zaměstnanosti
daň	plnohodnotná sazba daně z nemovitosti na 10 000 dolarů
ptratio	poměr žáků a učitelů ve městě
medv	Střední hodnota domů obývaných vlastníky v tisících dolarů
krim	kriminalita na obyvatele podle měst
chas	Fiktivní proměnná Charles River (1, pokud ohraničuje řeku; jinak 0)
B	podíl černochů ve městě

V tomto kurzu odhadneme střední cenu pomocí lineárního regresoru, ale důraz je kladen na jeden konkrétní proces strojového učení: „příprava dat“.

Model zobecňuje vzor v datech. Chcete-li takový vzor zachytit, musíte jej nejprve najít. Dobrým postupem je provést analýzu dat před spuštěním jakéhokoli algoritmu strojového učení.

Při výběru správných funkcí je rozdíl v úspěchu vašeho modelu. Představte si, že se pokusíte odhadnout mzdu lidí, pokud nezahrnete pohlaví jako kovariát, skončíte špatným odhadem.

Dalším způsobem, jak vylepšit model, je podívat se na korelaci mezi nezávislou proměnnou. Zpět k příkladu, vzdělání si můžete představit jako vynikajícího kandidáta na předvídání mezd, ale také povolání. Je třeba říci, že povolání závisí na úrovni vzdělání, zejména vysokoškolské vzdělání často vede k lepšímu povolání. Pokud tuto myšlenku zobecníme, můžeme říci, že korelaci mezi závislou proměnnou a vysvětlující proměnnou lze zvětšit ještě o další vysvětlující proměnnou.

K zachycení omezeného účinku vzdělávání na povolání můžeme použít termín interakce.

Když se podíváte na mzdovou rovnici, stane se:

Pokud je kladné, znamená to, že další úroveň vzdělání přinese vyšší nárůst střední hodnoty domu pro vysokou úroveň zaměstnání. Jinými slovy, existuje efekt interakce mezi vzděláváním a povoláním.

V tomto kurzu se pokusíme zjistit, které proměnné mohou být dobrým kandidátem na podmínky interakce. Budeme testovat, zda přidání tohoto druhu informací povede k lepší predikci ceny.

V tomto výukovém programu se naučíte

• Souhrnné statistiky
• Přehled fazet
• Fazety Deep Dive
• Nainstalujte Facet
• Přehled
• Graf
• Fazety Deep Dive
• TensorFlow
• Údaje o přípravě
• Základní regrese: Benchmark
• Vylepšit model: Termín interakce

Souhrnné statistiky

Než přejdete k modelu, můžete postupovat podle několika kroků. Jak již bylo zmíněno dříve, model je zobecněním dat. Nejvhodnějším postupem je porozumět datům a vytvořit predikci. Pokud neznáte svá data, máte malou šanci vylepšit svůj model.

Jako první krok načtěte data jako datový rámec pandy a vytvořte tréninkovou sadu a testovací sadu.

Tipy: V tomto tutoriálu musíte mít v Pythonu nainstalované matplotlit a seaborn. Balíček Pythonu můžete nainstalovat za běhu pomocí Jupyteru. To byste neměli dělat

!conda install -- yes matplotlib

ale

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

Upozorňujeme, že tento krok není nutný, pokud máte nainstalován matplotlib a seaborn.

Matplotlib je knihovna pro vytváření grafů v Pythonu. Seaborn je statistická vizualizační knihovna postavená na matplotlibu. Poskytuje atraktivní a krásné pozemky.

Níže uvedený kód importuje potřebné knihovny.

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

Knihovna sklearn obsahuje bostonskou datovou sadu. Chcete-li importovat data, můžete zavolat jeho API.

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

Název prvku je uložen v objektu feature_names v poli.

boston.feature_names

Výstup

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Sloupce můžete přejmenovat.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

Proměnnou CHAS převedete jako řetězcovou proměnnou a označíte ji ano, pokud CHAS = 1 a ne, pokud CHAS = 0
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
U pand je snadné datovou sadu rozdělit. Náhodně rozdělíte datovou sadu s 80% tréninkovou sadou a 20% testovací sadou. Pandy mají vestavěnou nákladovou funkci k rozdělení vzorku datového rámce.


První parametr frac je hodnota od 0 do 1. Nastavíte jej na 0,8, abyste náhodně vybrali 80 procent datového rámce.
Random_state umožňuje mít pro všechny stejný datový rámec.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Můžete získat tvar dat. To by mělo být:

Vlaková souprava: 506 * 0,8 = 405
Testovací sada: 506 * 0,2 = 101

print(df_train.shape, df_test.shape)
Výstup 
(405, 14) (101, 14) 
 
df_test.head(5)
Výstup
 

 
 
 
 
KRIM 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
STÁŘÍ 
 
DIS 
 
RAD 
 
DAŇ 
 
PTRATIO 
 
B 
 
LSTAT 
 
CENA 
 

 
 
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 
 

 

 

Data jsou chaotická; je to často špatně vyvážené a posypané odlehlými hodnotami, které zavrhují analýzu a školení strojového učení.
Prvním krokem k vyčištění datové sady je pochopení toho, kde je třeba ji vyčistit. Vyčištění datové sady může být obtížné, zvláště jakýmkoli zobecnitelným způsobem
Tým Google Research vyvinul pro tuto práci nástroj nazvaný Facets, který pomáhá vizualizovat data a rozdělit je na všechny možné způsoby. To je dobrý výchozí bod k pochopení toho, jak je datová sada rozložena.
Fazety vám umožňují zjistit, kde data nevypadají tak, jak si myslíte.
Kromě své webové aplikace Google usnadňuje vložení sady nástrojů do notebooku Jupyter.
Fazety mají dvě části:

Přehled fazet


Fazety Deep Dive


Přehled fazet
Facets Overview poskytuje přehled datové sady. Přehled fazet rozděluje sloupce dat do řádků zobrazujících hlavních informací

procento chybějícího pozorování
minimální a maximální hodnoty
statistiky jako průměr, medián a směrodatná odchylka.
Také přidá sloupec, který zobrazuje procento hodnot, které jsou nuly, což je užitečné, když je většina hodnot nulová.
Je možné vidět tyto distribuce na testovací datové sadě i na tréninkové sadě pro každou funkci. To znamená, že můžete znovu zkontrolovat, zda má test podobnou distribuci jako tréninková data.

To je alespoň minimum, co je třeba udělat před jakoukoli úlohou strojového učení. S tímto nástrojem vám tento zásadní krok neunikne a zdůrazňuje některé abnormality.

Fazety Deep Dive
Facets Deep Dive je skvělý nástroj. Umožňuje vám mít určitou jasnost ve vaší datové sadě a přiblížit ji úplně, abyste viděli jednotlivé údaje. To znamená, že můžete fazetovat data podle řádku a sloupce napříč kteroukoli z funkcí datové sady.
Tyto dva nástroje použijeme s datovou sadou v Bostonu.
Poznámka : Přehled Facets a Facets Deep Dive nelze používat současně. Chcete-li nástroj změnit, musíte nejprve notebook vymazat.

Nainstalujte Facet
Pro většinu analýz můžete použít webovou aplikaci Facet. V tomto tutoriálu uvidíte, jak jej používat v notebooku Jupyter.
Nejprve musíte nainstalovat nbextensions. S tímto kódem se to děje. Zkopírujete a vložíte následující kód do terminálu vašeho zařízení.
pip install jupyter_contrib_nbextensions 
Hned poté musíte klonovat úložiště ve vašem počítači. Máte dvě možnosti:
Možnost 1) Zkopírujte a vložte tento kód do terminálu (doporučeno)
Pokud ve svém počítači nemáte nainstalovaný Git, přejděte na tuto adresu URL https://git-scm.com/download/win a postupujte podle pokynů. Jakmile budete hotovi, můžete použít příkaz git v terminálu pro uživatele systému Mac User nebo Anaconda pro uživatele systému Windows
git clone https://github.com/PAIR-code/facets 
Možnost 2) Přejděte na https://github.com/PAIR-code/facets a stáhněte si úložiště.

Pokud zvolíte první možnost, soubor skončí ve vašem souboru ke stažení. Můžete buď nechat soubor stáhnout, nebo ho přetáhnout na jinou cestu.
Pomocí tohoto příkazového řádku můžete zkontrolovat, kde jsou fazety uloženy:
echo `pwd`/`ls facets` 
Nyní, když jste našli Facety, musíte si je nainstalovat do Jupyter Notebooku. Musíte nastavit pracovní adresář na cestu, kde se nacházejí fazety.
Váš současný pracovní adresář a umístění Facets zip by měly být stejné.

Musíte nasměrovat pracovní adresář na Facet:
cd facets
Chcete-li nainstalovat Facety v Jupyteru, máte dvě možnosti. Pokud jste nainstalovali Jupyter s Conda pro všechny uživatele, zkopírujte tento kód:
můžete použít jupyter nbextension nainstalovat fazety-dist /
jupyter nbextension install facets-dist/
Jinak použijte:
jupyter nbextension install facets-dist/ --user
Dobře, jste připraveni. Otevřeme Facet Overview.

Přehled
Přehled používá k výpočtu statistik skript v Pythonu. Musíte importovat skript s názvem generic_feature_statistics_generator do Jupyteru. Nebojte se; skript je umístěn v souborech fazet.
Musíte najít jeho cestu. Dá se to snadno udělat. Otevřete fazety, otevřete soubor facets_overview a pak python. Zkopírujte cestu

Poté přejděte zpět k Jupyterovi a napište následující kód. Změňte cestu '/ Users / Thomas / facets / facets_overview / python' na vaši cestu.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Skript můžete importovat pomocí níže uvedeného kódu.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
Ve Windows se stane stejný kód
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Chcete-li vypočítat statistiku funkcí, musíte použít funkci GenericFeatureStatisticsGenerator () a použít objekt ProtoFromDataFrames. Datový rámec můžete předat ve slovníku. Například pokud chceme vytvořit souhrnnou statistiku vlakové soupravy, můžeme informace uložit do slovníku a použít je v objektu `` ProtoFromDataFrames``


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

Název je název zobrazení tabulky a pro výpočet souhrnu použijete název tabulky, kterou chcete. Ve vašem příkladu je tabulka obsahující data 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")
Nakonec zkopírujte a vložte níže uvedený kód. Kód pochází přímo z GitHubu. Měli byste vidět toto:

# 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))
 
Graf
Poté, co zkontrolujete data a jejich distribuci, můžete vykreslit korelační matici. Korelační matice počítá Pearsonův koeficient. Tento koeficient je vázán mezi -1 a 1, přičemž kladná hodnota označuje pozitivní korelaci a záporná hodnota negativní korelaci.
Zajímá vás, které proměnné mohou být dobrým kandidátem na podmínky interakce.
## 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})
Výstup 

png

Z matice můžete vidět:

LSTAT
RM

Silně souvisí s PRICE. Další vzrušující vlastností je silná pozitivní korelace mezi NOX a INDUS, což znamená, že tyto dvě proměnné se pohybují stejným směrem. Kromě toho existují také korelace s CENOU. DIS také vysoce koreluje s IND a NOX.
Máte první náznak, že IND a NOX mohou být dobrými kandidáty na odposlechový termín a na DIS by také mohlo být zajímavé se zaměřit.
Můžete jít trochu hlouběji vynesením párové mřížky. Podrobněji ilustruje korelační mapu, kterou jste předtím vykreslili.
Dvojici mřížek jsme složili následovně:

Horní část: Bodový graf s osazenou čarou
Úhlopříčka: graf hustoty jádra
Spodní část: Vícerozměrný graf hustoty jádra

Vyberete zaměření na čtyři nezávislé proměnné. Volba odpovídá proměnným se silnou korelací s PRICE

INDUS
NOX
RM
LSTAT

navíc CENA.
Všimněte si , že standardní chyba je ve výchozím nastavení přidána k bodovému grafu.
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)
Výstup 

Začněme horní částí:

Cena negativně koreluje s INDUS, NOX a LSTAT; pozitivně korelováno s RM.
U LSTAT a PRICE je mírně nelinearita
Cena se rovná 50 jako přímka. Z popisu datové sady byla PRICE zkrácena na hodnotu 50

Úhlopříčka

Zdá se, že NOX má dva klastry, jeden kolem 0,5 a jeden kolem 0,85.

Chcete-li se o tom dozvědět více, můžete se podívat na spodní část. Hustota vícerozměrného jádra je zajímavá v tom smyslu, že barvy, kde je většina bodů. Rozdíl v rozptylovém grafu čerpá hustotu pravděpodobnosti, i když pro danou souřadnici nemá v datové sadě žádný smysl. Když je barva silnější, znamená to vysokou koncentraci bodu kolem této oblasti.
Pokud zkontrolujete vícerozměrnou hustotu pro INDUS a NOX, uvidíte pozitivní korelaci a dva klastry. Je-li podíl průmyslu nad 18, je koncentrace oxidů dusnatých nad 0,6.
Můžete uvažovat o přidání interakce mezi INDUS a NOX v lineárním vztahu.
Nakonec můžete použít druhé nástroje vytvořené společností Google, Facets Deep Dive. Rozhraní je rozděleno do čtyř hlavních částí. Centrální oblast ve středu je zvětšitelné zobrazení dat. V horní části panelu je rozevírací nabídka, ve které můžete změnit uspořádání dat na ovládací prvky fazetování, umístění a barvu. Vpravo je podrobný pohled na konkrétní řádek dat. To znamená, že kliknutím na libovolnou tečku dat ve vizualizaci centra zobrazíte podrobnosti o daném datovém bodě.
Během kroku vizualizace dat vás zajímá hledání párové korelace mezi nezávislou proměnnou ceny domu. Zahrnuje však alespoň tři proměnné a s 3D grafy se pracuje komplikovaně.
Jedním ze způsobů řešení tohoto problému je vytvoření kategorické proměnné. To znamená, že můžeme vytvořit 2D graf a zabarvit tečku. Proměnnou CENA můžete rozdělit do čtyř kategorií, přičemž každá kategorie je kvartil (tj. 0,25, 0,5, 0,75). Tuto novou proměnnou říkáte 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")


Fazety Deep Dive
Chcete-li otevřít Deep Dive, musíte data transformovat do formátu JSON. Pandy jako objekt pro to. Po datové sadě Pandas můžete použít to_json.
První řádek kódu zpracovává velikost datové sady.
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')
Níže uvedený kód pochází z Google GitHub. Po spuštění kódu byste měli vidět toto:

# 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))
Zajímalo by vás, zda existuje souvislost mezi rychlostí průmyslu, koncentrací oxidů, vzdáleností od centra práce a cenou domu.
Za tímto účelem nejprve rozdělíte data podle odvětví a barev pomocí cenového kvartilu:

Vyberte fazetování X a zvolte INDUS.
Vyberte Zobrazit a zvolte DIS. Vybarví tečky kvartilem ceny domu

tmavší barvy zde znamenají, že vzdálenost k prvnímu centru práce je daleko.
Zatím to opět ukazuje, co víte, nižší průmyslová sazba, vyšší cena. Nyní se můžete podívat na rozdělení podle INDUX, podle NOX.

Vyberte fazetování Y a zvolte NOX.

Nyní můžete vidět, že dům daleko od prvního úřadu práce má nejnižší podíl v průmyslu, a tedy nejnižší koncentraci oxidů. Pokud se rozhodnete zobrazit typ s Q_PRICE a přiblížit levý dolní roh, uvidíte, o jaký typ ceny jde.
Máte další náznak, že interakce mezi IND, NOX a DIS může být dobrým kandidátem na vylepšení modelu.

TensorFlow
V této části budete odhadovat lineární klasifikátor pomocí TensorFlow odhadů API. Budete postupovat následovně:

Připravte data
Odhadněte referenční model: Žádná interakce
Odhadněte model s interakcí

Pamatujte, že cílem strojového učení je minimalizovat chybu. V takovém případě zvítězí model s nejnižší střední kvadratickou chybou. Odhadovač TensorFlow tuto metriku automaticky vypočítá.
Údaje o přípravě
Ve většině případů musíte data transformovat. Proto je Facets Overview fascinující. Ze souhrnné statistiky jste viděli, že existují odlehlé hodnoty. Tyto hodnoty ovlivňují odhady, protože nevypadají jako populace, kterou analyzujete. Odlehlé hodnoty obvykle ovlivnily výsledky. Například pozitivní odlehlá hodnota má tendenci nadhodnocovat koeficient.
Dobrým řešením tohoto problému je standardizace proměnné. Standardizace znamená směrodatnou odchylku jedna a nula. Proces standardizace zahrnuje dva kroky. Nejprve odečte střední hodnotu proměnné. Za druhé, vydělí se rozptylem, takže distribuce má rozptyl jednotek
Knihovna sklearn je užitečná pro standardizaci proměnných. K tomuto účelu můžete použít předzpracování modulu s měřítkem objektu.
Pomocí níže uvedené funkce můžete škálovat datovou sadu. Všimněte si, že neměníte měřítko sloupce štítku a kategorických proměnných.
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
Tuto funkci můžete použít ke konstrukci škálované sady vlaků / testů.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Základní regrese: Benchmark
Nejprve trénujete a testujete model bez interakce. Účelem je zobrazit metriku výkonu modelu.
Způsob, jak trénovat model, je přesně jako tutoriál o rozhraní API na vysoké úrovni . Budete používat odhadovač TensorFlow LinearRegressor.
Připomínáme, že je třeba zvolit:

funkce, které mají být vloženy do modelu
transformovat funkce
sestrojte lineární regresor
vytvořte funkci input_fn
trénovat model
otestujte model

K trénování modelu použijete všechny proměnné v datové sadě. Celkově existují jednostranné spojité proměnné a jedna kategorická proměnná
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
Funkce převedete na číselný sloupec nebo kategorický sloupec
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 vytvoříte pomocí linearRegressor. Model uložíte do složky train_Boston
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Výstup 
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}
Každý sloupec ve vlaku nebo testovacích datech je převeden na Tensor pomocí funkce 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 odhadujete na datech vlaku.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Výstup 
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.
Nakonec odhadnete výkony modelu na testovací sadě
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Výstup 
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}
Ztráta modelu je 1650. Toto je metrika, kterou je třeba porazit v další části

Vylepšit model: Termín interakce
Během první části tutoriálu jste viděli zajímavý vztah mezi proměnnými. Různé vizualizační techniky odhalily, že INDUS a NOS jsou vzájemně propojeny a mění se, aby se zvětšil účinek na cenu. Nejen interakce mezi INDUS a NOS ovlivňuje cenu, ale také tento účinek je silnější, když interaguje s DIS.
Je na čase tuto myšlenku zobecnit a zjistit, zda můžete vylepšit predikovaný model modelu.
Do každé sady datových sad musíte přidat dva nové sloupce: vlak + test. Za tímto účelem vytvoříte jednu funkci pro výpočet termínu interakce a další pro výpočet termínu trojité interakce. Každá funkce vytváří jeden sloupec. Po vytvoření nových proměnných je můžete zřetězit do tréninkové datové sady a testovací datové sady.
Nejprve musíte vytvořit novou proměnnou pro interakci mezi INDUS a NOX.
Níže uvedená funkce vrací dva datové rámce, trénovat a testovat, s interakcí mezi var_1 a var_2, ve vašem případě INDUS a 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
Uložíte dva nové sloupce
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
Zadruhé vytvoříte druhou funkci pro výpočet termínu trojité interakce.
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')
Nyní, když máte všechny potřebné sloupce, můžete je přidat k trénování a testování datové sady. Pojmenujete tyto dva nové datové rámce:

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)
Výstup 

To je ono; můžete odhadnout nový model s podmínkami interakce a zjistit, jaká je metrika výkonu.
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)
Výstup 
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}
KÓD
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)
Výstup 
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)
Výstup 
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}
Nová ztráta je 1515. Pouhým přidáním dvou nových proměnných jste byli schopni snížit ztrátu. To znamená, že můžete udělat lepší předpověď než u srovnávacího modelu.