TensorFlow lineáris regresszió Facet & Interakció időtartama

Ebben az oktatóanyagban megtudhatja, hogyan ellenőrizheti az adatokat és hogyan készítheti elő őket egy egyszerű lineáris regressziós feladat létrehozására.

Ez az oktatóanyag két részre oszlik:

• Keresse az interakciót
• Tesztelje a modellt

Az előző oktatóanyagban a bostoni adatkészlettel becsülted meg a ház középárát. A bostoni adatkészlet kis méretű, mindössze 506 megfigyeléssel. Ezt az adatkészletet referenciaértéknek tekintik az új lineáris regressziós algoritmusok kipróbálására.

Az adatkészlet a következőkből áll:

Változó	Leírás
zn	A 25.000 négyzetméter feletti telkekre elosztott lakóterület aránya
indus	A nem kiskereskedelmi üzleti hektárok aránya városonként.
nox	nitrogén-oxid-koncentráció
rm	lakásonkénti átlagos szobák száma
kor	az 1940 előtt épített tulajdonosok által használt egységek aránya
dis	súlyozott távolságok öt bostoni munkaügyi központig
adó	teljes értékű ingatlanadó mértéke dollárenként 10 000
ptratio	a tanuló-tanár arány városonként
medv	A tulajdonosok által használt lakások mediánértéke ezer dollárban
krim	az egy főre eső bűnözés mértéke városonként
chas	Charles River dummy változó (1, ha a folyót korlátozza; különben 0)
B	a feketék aránya a város szerint

Ebben az oktatóanyagban egy lineáris regresszor segítségével megbecsüljük a medián árat, de a hangsúly a gépi tanulás egy bizonyos folyamatán van: az "adatok előkészítésén".

Egy modell általánosítja az adatok mintázatát. Egy ilyen minta rögzítéséhez először meg kell találnia. Jó gyakorlat az adatelemzés elvégzése a gépi tanulási algoritmus futtatása előtt.

A megfelelő funkciók kiválasztása minden különbséget jelent a modell sikerében. Képzelje el, hogy megpróbálja megbecsülni egy nép bérét, ha nem tartalmazza a nemet kovariátorként, akkor rossz becsléssel jár.

A modell továbbfejlesztésének másik módja a független változó közötti összefüggés vizsgálata. Visszatérve a példához, úgy gondolhatja az oktatást, mint kiváló jelöltet a bér, de a foglalkozás előrejelzésére is. Igaz mondani, hogy a foglalkozás az iskolázottság szintjétől függ, nevezetesen a felsőoktatás gyakran jobb foglalkozáshoz vezet. Ha ezt az elképzelést általánosítjuk, elmondhatjuk, hogy a függő változó és egy magyarázó változó közötti összefüggés felnagyítható egy újabb magyarázó változóval.

Az oktatás korlátozott hatásának megragadására használhatunk interakciós kifejezést.

Ha megnézzük a béregyenletet, akkor ez a következő lesz:

Ha pozitív, akkor ez azt jelenti, hogy egy további végzettség magasabb házi mediánérték-növekedést eredményez magas foglalkozási szint mellett. Más szavakkal, kölcsönhatás van az oktatás és a foglalkozás között.

Ebben az oktatóanyagban megpróbáljuk megtudni, hogy mely változók lehetnek jó jelöltek az interakciós kifejezésekre. Megvizsgáljuk, hogy az ilyen típusú információk hozzáadása jobb árjóslathoz vezet-e.

Ebben az oktatóanyagban megtanulja

• Összefoglaló statisztikák
• Áttekintés áttekintése
• Facets Deep Dive
• Telepítse a Facet alkalmazást
• Áttekintés
• Grafikon
• Facets Deep Dive
• TensorFlow
• Előkészítési adatok
• Alapvető regresszió: benchmark
• Javítsa a modellt: Interakciós kifejezés

Összefoglaló statisztikák

Néhány lépést követhet, mielőtt folytatja a modellt. Mint korábban említettük, a modell az adatok általánosítása. A legjobb illeszkedési gyakorlat az adatok megértése és az előrejelzés. Ha nem ismeri az adatait, akkor kicsi az esélye a modell fejlesztésére.

Első lépésként töltse be az adatokat pandás adatkeretként, és hozzon létre egy edzéskészletet és tesztkészletet.

Tippek: Ehhez az oktatóanyaghoz matplotlit és seaborn telepítve kell lennie a Pythonban. A Python csomagot menet közben is telepítheti a Jupyterrel. Nem szabad ezt megtenni

!conda install -- yes matplotlib

de

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

Ne feledje, hogy ez a lépés nem szükséges, ha a matplotlib és a seaborn telepítve van.

A Matplotlib az a könyvtár, amely grafikont hoz létre a Pythonban. A Seaborn egy statisztikai vizualizációs könyvtár, amely a matplotlib tetejére épül. Vonzó és szép telkeket kínál.

Az alábbi kód importálja a szükséges könyvtárakat.

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

A könyvtár sklearn tartalmazza a bostoni adatkészletet. Hívhatja az API-t az adatok importálásához.

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

A szolgáltatás nevét egy tömb objektum_nevei tárolják.

boston.feature_names

Kimenet

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='
Átnevezheti az oszlopokat.
df.columns = boston.feature_namesdf['PRICE'] = boston.targetdf.head(2)

A CHAS változót karakterlánc változóvá konvertálja, és ha igen, ha CHAS = 1, akkor nem, ha CHAS = 0, akkor nem
df['CHAS'] = df['CHAS'].map({1:'yes', 0:'no'})df['CHAS'].head(5)0 no1 no2 no3 no4 noName: CHAS, dtype: object
A pandák esetében egyértelmű az adatkészlet felosztása. Véletlenszerűen osztja fel az adatkészletet 80 százalékos edzéskészlettel és 20 százalékos tesztkészlettel. A pandák beépített költségfunkcióval rendelkeznek az adatkeret-minta felosztásához.


Az első paraméter frac 0 és 1 közötti érték. Ha 0,8-ra állítja, az adatkeret véletlenszerűen 80 százalékát választja ki.
A Random_state lehetővé teszi, hogy mindenkinek ugyanazt az adatkeretet adja vissza.
### Create train/test setdf_train=df.sample(frac=0.8,random_state=200)df_test=df.drop(df_train.index)
Megkaphatja az adatok alakját. Kellene lennie:

Vonatkészlet: 506 * 0,8 = 405
Tesztkészlet: 506 * 0,2 = 101

print(df_train.shape, df_test.shape)
Kimenet 
(405, 14) (101, 14) 
 
df_test.head(5)
Kimenet
 

 
 
 
 
BŰNÖZÉS 
 
ZN 
 
INDUS 
 
CHAS 
 
NOX 
 
RM 
 
KOR 
 
DIS 
 
RAD 
 
ADÓ 
 
PTRATIO 
 
B 
 
LSTAT 
 
ÁR 
 

 
 
0 
 
0,00632 
 
18.0 
 
2.31 
 
nem 
 
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 
 
nem 
 
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 
 
nem 
 
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 
 
nem 
 
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 
 
nem 
 
0,524 
 
6.172 
 
96.1 
 
5.9505 
 
5.0 
 
311.0 
 
15.2 
 
396.90 
 
19.15 
 
27.1 
 

 

 

Az adatok rendetlenek; gyakran kiegyensúlyozatlan, és olyan kiugró értékekkel van megszórva, amelyek eldobják az elemzést és a gépi tanulási képzést.
Az adatkészlet megtisztításának első lépése annak megértése, hogy hol kell tisztítani. Az adatkészlet megtisztítása bonyolult, különösen bármilyen általánosítható módon
A Google Research csapata kifejlesztett ehhez a munkához egy Facets nevű eszközt, amely segít az adatok vizualizálásában és mindenféle módon szeletelésében. Ez egy jó kiindulópont annak megértéséhez, hogy az adatkészlet hogyan kerül elrendezésre.
A szempontok lehetővé teszik, hogy megtalálja, ahol az adatok nem egészen úgy néznek ki, ahogy gondolkodik.
Webes alkalmazásuk kivételével a Google megkönnyíti az eszköztár Jupyter notebookba történő beágyazását.
A Facets két részből áll:

Áttekintés áttekintése


Facets Deep Dive


Áttekintés áttekintése
A Facets Overview áttekintést nyújt az adatkészletről. A Facets Overview felosztja az adatok oszlopait kiemelt információk soraira

a hiányzó megfigyelés százalékos aránya
min és max értékek
statisztikák, mint az átlag, a medián és a szórás.
Ezenkívül hozzáad egy oszlopot, amely megmutatja az értékek százalékos értékét, ami nulla, ami akkor hasznos, ha az értékek nagy része nulla.
Látható ezek az eloszlások a tesztadatkészleten, valamint az egyes jellemzők képzési halmaza. Ez azt jelenti, hogy kétszer ellenőrizheti, hogy a teszt hasonló eloszlású-e, mint az edzés adatai.

Ez legalább a gépi tanulási feladatok előtt elvégzendő minimum. Ezzel az eszközzel nem hagyja ki ezt a döntő lépést, és kiemel néhány rendellenességet.

Facets Deep Dive
A Facets Deep Dive klassz eszköz. Lehetővé teszi, hogy tisztázza az adatkészletet, és végig nagyíthatja az egyes adatok megtekintését. Ez azt jelenti, hogy sorba és oszlopba sorolhatja az adatokat az adatkészlet bármely jellemzőjén keresztül.
Ezt a két eszközt fogjuk használni a bostoni adatkészlettel.
Megjegyzés : A Facets Overview és a Facets Deep Dive egyszerre nem használható. Először ki kell törölnie a jegyzetfüzetet az eszköz megváltoztatásához.

Telepítse a Facet alkalmazást
Az elemzés nagy részében használhatja a Facet webalkalmazást. Ebben az oktatóanyagban megismerheti a Jupyter Notebook használatát.
Először telepítenie kell az nbextensions programot. Ezzel a kóddal történik. Másolja és beilleszti a következő kódot a gép termináljába.
pip install jupyter_contrib_nbextensions 
Rögtön ezután klónoznia kell a tárolókat a számítógépén. Két lehetőséged van:
1. lehetőség: Másolja és illessze be ezt a kódot a terminálba (ajánlott)
Ha még nincs telepítve a Git a számítógépére, kérjük, látogasson el erre az URL-re: https://git-scm.com/download/win, és kövesse az utasításokat. Ha elkészült, használhatja a terminál git parancsát a Mac Felhasználóhoz vagy az Anaconda parancsot a Windows felhasználóhoz
git clone https://github.com/PAIR-code/facets 
2. lehetőség: Nyissa meg a https://github.com/PAIR-code/facets webhelyet, és töltse le a tárakat.

Ha az első lehetőséget választja, a fájl a letöltési fájlba kerül. Vagy engedélyezheti a fájl letöltését, vagy áthúzhatja egy másik útvonalra.
Ezzel a parancssorral ellenőrizheti, hogy a Facets hol van tárolva:
echo `pwd`/`ls facets` 
Most, hogy megtalálta a Facets alkalmazást, telepítenie kell a Jupyter Notebookba. Be kell állítania a munkakönyvtárat arra az útvonalra, ahol a aspektusok találhatók.
Jelenlegi munkakönyvtárának és a Facets zip helyének meg kell egyeznie.

A munkakönyvtárat a Facet pontra kell mutatnia:
cd facets
A Facets Jupyter programba történő telepítéséhez két lehetőség áll rendelkezésre. Ha az összes felhasználó számára telepítette a Jupyter-t a Condával, másolja ezt a kódot:
használhatja a jupyter nbextension telepítését facets-dist /
jupyter nbextension install facets-dist/
Ellenkező esetben használja:
jupyter nbextension install facets-dist/ --user
Rendben, minden rendben van. Nyissuk meg a Facet Overview alkalmazást.

Áttekintés
Az Áttekintés Python szkriptet használ a statisztikák kiszámításához. Importálni kell a generic_feature_statistics_generator nevű szkriptet a Jupyterbe. Ne aggódj; a szkript a facets fájlokban található.
Meg kell találnia az útját. Ez könnyen elvégezhető. Megnyitja a aspektusokat, megnyitja a facets_overview fájlt, majd python. Másolja az utat

Ezt követően térjen vissza a Jupyterhez, és írja be a következő kódot. Módosítsa a "/ Users / Thomas / facets / facets_overview / python" elérési utat az Ön elérési útjához.
# Add the facets overview python code to the python path# Add timport syssys.path.append('/Users/Thomas/facets/facets_overview/python')
Az alábbi kóddal importálhatja a szkriptet.
from generic_feature_statistics_generator importGenericFeatureStatisticsGenerator
A Windows rendszerben ugyanaz a kód lesz
import syssys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
A szolgáltatás statisztikájának kiszámításához használja a GenericFeatureStatisticsGenerator () függvényt, és a ProtoFromDataFrames objektumot. Az adatkeretet átadhatja egy szótárban. Például, ha összefoglaló statisztikát akarunk létrehozni a vonatkészletről, akkor tárolhatjuk az információkat egy szótárban, és felhasználhatjuk a "ProtoFromDataFrames" objektumban.


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

A név a megjelenített tábla neve, és Ön annak a táblának a nevét használja, amelyre az összefoglalót szeretné kiszámítani. A példádban az adatokat tartalmazó tábla 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")
Végül csak másolja és illessze be az alábbi kódot. A kód közvetlenül a GitHub-ból származik. Ezt látnia kell:

# 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))
 
Grafikon
Miután ellenőrizte az adatokat és azok eloszlását, megrajzolhat egy korrelációs mátrixot. A korrelációs mátrix kiszámítja a Pearson-együtthatót. Ez az együttható -1 és 1 között van összekötve, pozitív érték pozitív, negatív érték pedig negatív korrelációt jelez.
Érdekel, hogy mely változók lehetnek jó jelöltek az interakciós kifejezésekre.
## 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})
Kimenet 

png

A mátrixból láthatja:

LSTAT
RM

Erősen korrelálnak a PRICE-val. Egy másik izgalmas jellemző az erős pozitív korreláció a NOX és az INDUS között, ami azt jelenti, hogy ez a két változó ugyanabba az irányba mozog. Emellett vannak összefüggésben az ÁR-val is. A DIS szintén szorosan korrelál az IND és NOX értékekkel.
Van néhány első utalásod arra, hogy az IND és a NOX jó jelölt lehet az elfogási ciklusra, és a DIS-re is érdekes lehet összpontosítani.
Kicsit elmélyülhet, ha megrajzol egy pár rácsot. Ez részletesebben szemlélteti a korábban ábrázolt korrelációs térképet.
Az általunk összeállított párrács a következőképpen alakul:

Felső rész: Szóródeszka illesztett vonallal
Átló: Kernel sűrűség ábrája
Alsó rész: Többváltozós kernelsűrűség-diagram

Négy független változóra fókuszál. A választás megfelel a PRICE-val szorosan összefüggő változóknak

INDUS
NOX
RM
LSTAT

ráadásul az ÁR.
Ne feledje, hogy a standard hiba alapértelmezés szerint hozzáadódik a szórási diagramhoz.
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)
Kimenet 

Kezdjük a felsővel:

Az ár negatívan korrelál az INDUS, a NOX és az LSTAT értékkel; pozitívan korrelál az RM-vel.
Kicsit nemlineáris az LSTAT és az PRICE
Van olyan, mint egy egyenes, amikor az ár egyenlő 50-vel. Az adatkészlet leírásából a PRICE-t 50-es értéken csonkították.

Átlós

Úgy tűnik, hogy a NOX-nak két klasztere van, az egyik 0,5 körül, a másik pedig 0,85 körül.

Ha többet szeretne megtudni róla, megnézheti az alsó részt. A többváltozós kernelsűrűség bizonyos értelemben érdekes, ahol a legtöbb pont színeződik. A szórási ábrával való különbség valószínűségi sűrűséget rajzol, annak ellenére, hogy az adatkészletben nincs pont egy adott koordinátára. Ha a szín erősebb, ez a pont körüli magas koncentrációra utal.
Ha ellenőrzi az INDUS és NOX többváltozósűrűségét, láthatja a pozitív korrelációt és a két klasztert. Amikor az ipar részaránya meghaladja a 18-at, a nitrogén-oxid-koncentráció meghaladja a 0,6-ot.
Elgondolkodhat az INDUS és a NOX közötti kölcsönhatás felvételén a lineáris összefüggésen.
Végül használhatja a Google által létrehozott második eszközöket, a Facets Deep Dive-t. Az interfész négy fő részre oszlik. A központ középső része az adatok nagyítható megjelenítése. A panel tetején található egy legördülő menü, ahol megváltoztathatja az adatok elrendezését a fasírozás, a pozicionálás és a szín vezérlésére. A jobb oldalon egy adott adatsor részletes nézete látható. Ez azt jelenti, hogy a középső megjelenítés bármely adatpontjára kattintva megtekintheti az adott adat részleteit.
Az adatmegjelenítés során érdeklődni kíván a páros összefüggésről a független változó és a ház ára között. Ez azonban legalább három változót tartalmaz, és a 3D-s ábrák használata bonyolult.
A probléma kezelésének egyik módja egy kategorikus változó létrehozása. Vagyis létrehozhatunk egy 2D-s ábrát a pont színével. A PRICE változót négy kategóriára oszthatja, mindegyik kategória egy kvartilis (azaz 0,25, 0,5, 0,75). Ezt az új változót hívja: 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")


Facets Deep Dive
A Deep Dive megnyitásához át kell alakítania az adatokat json formátumba. A pandák mint tárgy erre. Használhatja a to_json fájlt a Pandas adatkészlet után.
Az első kódsor az adatkészlet méretét kezeli.
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')
Az alábbi kód a Google GitHub-tól származik. A kód futtatása után látnia kell ezt:

# 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))
Érdekel, hogy van-e összefüggés az ipari ráta, az oxidkoncentráció, az állásközponttól való távolság és a ház ára között.
Ehhez először fel kell osztani az adatokat az ipari tartomány és szín szerint az árnegyedre:

Válassza ki a faceting X elemet, majd válassza az INDUS lehetőséget.
Válassza a Megjelenítés lehetőséget, és válassza a DIS lehetőséget. A pontokat a ház árának kvartilisával fogja színezni

itt a sötétebb színek azt jelentik, hogy az első munkaközpont távolsága messze van.
Eddig ismét megmutatja, amit tud, alacsonyabb ipari ráta, magasabb ár. Most megnézheti az INDUX, NOX szerinti bontást.

Válassza ki az Y csíkozást és válassza a NOX lehetőséget.

Most már láthatja, hogy az első munkaközponttól távol eső házban a legkisebb az ipari részesedés, ezért a legalacsonyabb az oxidkoncentráció. Ha úgy dönt, hogy a típust a Q_PRICE értékkel jeleníti meg, és nagyítja a bal alsó sarkot, láthatja, hogy milyen típusú árról van szó.
Van még egy tipped arra, hogy az IND, NOX és DIS közötti kölcsönhatás jó jelölt lehet a modell fejlesztésére.

TensorFlow
Ebben a szakaszban a lineáris osztályozót a TensorFlow becslők API-val becsüli meg. Az alábbiak szerint jár el:

Készítse elő az adatokat
Becsüljön meg egy benchmark modellt: Nincs interakció
Becsüljön meg egy modellt interakcióval

Ne feledje, hogy a gépi tanulás célja a hiba minimalizálása. Ebben az esetben az a modell nyer, amelynek a legalacsonyabb az átlagos négyzetes hibája. A TensorFlow becslő automatikusan kiszámítja ezt a mutatót.
Előkészítési adatok
Az esetek többségében átalakítania kell adatait. Ezért a Facets Overview lenyűgöző. Az összefoglaló statisztikából láthattad, hogy vannak kiugró értékek. Ezek az értékek befolyásolják a becsléseket, mert nem hasonlítanak az általad elemzett népességre. A kiugró emberek általában elfogulták az eredményeket. Például egy pozitív kiugró érték túlértékeli az együtthatót.
A probléma megoldására jó megoldás a változó szabványosítása. A standardizálás egy és szórás szórását jelenti. A szabványosítás folyamata két lépést foglal magában. Mindenekelőtt kivonja a változó átlagértékét. Másodszor, elosztja a varianciával, így az eloszlás egységnyi varianciával rendelkezik
A sklearn könyvtár segít a változók szabványosításában. Erre a célra használhatja a modul előfeldolgozását az objektum skálával.
Az alábbi függvény segítségével méretezhet egy adatsort. Ne feledje, hogy nem méretezi a címke oszlopot és a kategorikus változókat.
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
A függvény segítségével elkészítheti a méretezett vonatot / tesztkészletet.
df_train_scale = standardize_data(df_train)df_test_scale = standardize_data(df_test) 
Alapvető regresszió: benchmark
Mindenekelőtt interakció nélkül edz és tesztel egy modellt. A cél a modell teljesítménymutatójának megtekintése.
A modell kiképzésének módja pontosan olyan, mint a magas szintű API oktatóanyaga . A TensorFlow LinearRegressor becslőt fogja használni.
Emlékeztetőül: a következőket kell választania:

a modellbe beillesztendő jellemzők
alakítsa át a jellemzőket
konstruálja a lineáris regresszort
konstruálja az input_fn függvényt
képezze ki a modellt
tesztelje a modellt

A modell kiképzéséhez az adatkészlet összes változóját használja. Összesen vannak folyamatos szintű változók és egy kategorikus változó
## Add features to the bucket:### Define continuous listCONTI_FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT']CATE_FEATURES = ['CHAS']
A szolgáltatásokat numerikus oszlopokká vagy kategorikus oszlopokká konvertálja
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'])]
A modellt a linearRegressor segítségével hozza létre. A modellt a train_Boston mappában tárolja
model = tf.estimator.LinearRegressor(model_dir="train_Boston",feature_columns=categorical_features + continuous_features)
Kimenet 
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}
A vonat vagy a tesztadatok minden oszlopát Tensorrá konvertáljuk a get_input_fn függvénnyel
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)
A modellt a vonat adatai alapján becsüli meg.
model.train(input_fn=get_input_fn(df_train_scale,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Kimenet 
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.
Végül megbecsüli a modell teljesítményét a tesztkészleten
model.evaluate(input_fn=get_input_fn(df_test_scale,num_epochs=1,n_batch = 128,shuffle=False),steps=1000)
Kimenet 
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}
A modell vesztesége 1650. Ezt a mutatót kell legyőzni a következő szakaszban

Javítsa a modellt: Interakciós kifejezés
Az oktatóanyag első részében érdekes összefüggést látott a változók között. A különböző megjelenítési technikák feltárták, hogy az INDUS és a NOS összekapcsolódnak, és megfordulnak, hogy felnagyítsák az árra gyakorolt ​​hatást. Nemcsak az INDUS és a NOS közötti kölcsönhatás befolyásolja az árat, hanem ez a hatás is erősebb, ha kölcsönhatásba lép a DIS-szel.
Ideje általánosítani ezt az elképzelést, és megnézni, hogy javíthatja-e a modell előre jelzett modelljét.
Minden egyes adatkészlethez két új oszlopot kell hozzáadnia: vonat + teszt. Ehhez egy függvényt hoz létre az interakció kifejezés kiszámításához, egy másik pedig a tripla interakció kifejezés kiszámításához. Minden függvény egyetlen oszlopot hoz létre. Az új változók létrehozása után összefűzheti őket az oktatási és a tesztelési adatkészlettel.
Először is létre kell hoznia egy új változót az INDUS és a NOX közötti interakcióhoz.
Az alábbi függvény két adatkeretet ad vissza, a vonatot és a tesztet, a var_1 és a var_2, az Ön esetében az INDUS és a NOX kölcsönhatásával.
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
Ön tárolja a két új oszlopot
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')interation_ind_ns_train.shape(325,)
Másodszor létrehoz egy második függvényt a hármas interakció kifejezés kiszámításához.
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')
Most, hogy minden szükséges oszlop megvan, felveheti őket az edzéshez és az adatkészlet teszteléséhez. Ezt a két új adatkeretet nevezi meg:

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

Ez az; megbecsülheti az új modellt az interakciós kifejezésekkel, és megnézheti, hogyan áll a teljesítménymutató.
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)
Kimenet 
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)
Kimenet 
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)
Kimenet 
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}
Az új veszteség 1515. Csak két új változó hozzáadásával csökkenteni tudta a veszteséget. Ez azt jelenti, hogy jobb előrejelzést tehet, mint a benchmark modellel.