TensorFlow Lineáris Regresszió, Facet és Interaction Term
Evelyn Clarke
Ebből az oktatóanyagból megtudhatja, hogyan ellenőrizheti az adatokat, és hogyan készítheti elő azokat egy egyszerű lineáris regressziós feladat létrehozásához.
Ez az oktatóanyag két részre oszlik:
- Keresse az interakciót
- Tesztelje a modellt
A előző bemutató, a bostoni adatkészletet használta egy ház medián árának becsléséhez. A bostoni adatkészlet kicsi, mindössze 506 megfigyelést tartalmaz. Ezt az adatkészletet viszonyítási alapnak tekintik az új lineáris regressziós algoritmusok kipróbálásához.
Az adatkészlet a következőkből áll:
| Változó | Leírás |
|---|---|
| zn | A 25,000 XNUMX négyzetméter feletti telkekre beövezett lakóterület aránya. |
| indus | A nem kiskereskedelmi üzleti hektárok településenkénti aránya. |
| nox | nitrogén-oxidok koncentrációja |
| rm | átlagos szobaszám lakásonként |
| kor | az 1940 előtt épült, saját tulajdonú egységek aránya |
| dis | súlyozott távolságok öt bostoni munkaügyi központtól |
| adó | teljes értékű ingatlanadó kulcsa dolláronként 10,000 XNUMX |
| ptratio | a tanuló-tanár arány városonként |
| medv | A tulajdonos által használt házak medián értéke ezer dollárban |
| krimi | az egy főre jutó bűnözési ráta városonként |
| Chas | Charles River álváltozó (1, ha a folyót korlátozza; 0 egyébként) |
| B | a feketék aránya városonként |
Ebben az oktatóanyagban a medián árat lineáris regresszor segítségével becsüljük meg, de a hangsúly egy bizonyos folyamaton van gépi tanulás: „adat-előkészítés”.
A modell általánosítja az adatok mintáját. Egy ilyen minta rögzítéséhez először meg kell találnia. Jó gyakorlat az adatelemzés elvégzése, mielőtt bármilyen gépi tanulási algoritmust futtatna.
A megfelelő funkciók kiválasztása nagyban befolyásolja modellje sikerét. Képzeld el, hogy megpróbálod megbecsülni egy nép bérét, ha nem veszed figyelembe a nemet kovariánsként, akkor rossz becslést kapsz.
A modell fejlesztésének másik módja a független változó közötti korreláció vizsgálata. Visszatérve a példához, az oktatásra úgy gondolhat, mint egy kiváló jelöltre a bér, de a foglalkozás előrejelzésére is. Igaz, hogy a foglalkozás az iskolai végzettségtől függ, ugyanis a felsőfokú végzettség gyakran jobb foglalkozáshoz vezet. Ha ezt az elképzelést általánosítjuk, akkor azt mondhatjuk, hogy a függő változó és egy magyarázó változó közötti összefüggés még egy magyarázó változóval felnagyítható.
Az iskolai végzettség foglalkozásra gyakorolt korlátozott hatásának megragadásához interakciós kifejezést használhatunk.
Ha megnézzük a béregyenletet, akkor ez lesz:
If 
pozitív, akkor ez azt jelenti, hogy egy további iskolai végzettség nagyobb mértékben növeli a ház medián értékét egy magas elfoglaltsági szint mellett. Más szóval, interakciós hatás van az iskolai végzettség és a foglalkozás között.
Ebben az oktatóanyagban megpróbáljuk megnézni, hogy mely változók lehetnek jó jelöltek az interakciós kifejezésekre. Megvizsgáljuk, hogy az ilyen jellegű információk hozzáadása jobb ár-előrejelzést eredményez-e.
Összefoglaló statisztika
Néhány lépést meg kell követnie, mielőtt továbblépne a modellre. 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ések elkészítése. Ha nem ismeri adatait, csekély esélye van a modell fejlesztésére.
Első lépésként töltse be az adatokat panda adatkeretként, és hozzon létre egy képzési készletet és egy tesztkészletet.
Tippek: Ehhez az oktatóanyaghoz telepíteni kell a matplotlit és a seaborn rendszert Python. Telepítheti Python csomag menet közben Jupyter. Ön Nem kellene csináld ezt
!conda install -- yes matplotlib
de
import sys
!{sys.executable} -m pip install matplotlib # Already installed
!{sys.executable} -m pip install seaborn
Vegye figyelembe, hogy ez a lépés nem szükséges, ha telepítve van a matplotlib és a seaborn.
A Matplotlib az a könyvtár, amelyben gráfot lehet létrehozni Python. A Seaborn egy statisztikai vizualizációs könyvtár, amely a matplotlibre épül. Vonzó és szép telkeket biztosít.
Az alábbi kód importálja a szükséges könyvtárakat.
import pandas as pd from sklearn import datasets import tensorflow as tf from sklearn.datasets import load_boston import numpy as np
A sklearn könyvtár tartalmazza a bostoni adatkészletet. Meghívhatja az API-ját az adatok importálásához.
boston = load_boston() df = pd.DataFrame(boston.data)
A jellemző neve a jellemző_nevek objektumban van tárolva egy tömbben.
boston.feature_names
teljesítmény
array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')
Átnevezheti az oszlopokat.
df.columns = boston.feature_names df['PRICE'] = boston.target df.head(2)
A CHAS változót karakterláncváltozóvá alakítod, és igennel jelölöd, ha CHAS = 1, és nemmel, ha 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
A pandák esetében egyszerű az adatkészlet felosztása. Véletlenszerűen felosztja az adatkészletet 80 százalékos képzési készlettel és 20 százalékos tesztelési készlettel. pandák beépített költségfüggvénnyel rendelkeznek az adatkeret-minta felosztásához.
Az első frac paraméter egy 0 és 1 közötti érték. 0.8-ra állítva véletlenszerűen kiválaszthatja az adatkeret 80 százalékát.
A Random_state lehetővé teszi, hogy mindenki számára ugyanazt az adatkeretet adja vissza.
### Create train/test set df_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)
teljesítmény
(405, 14) (101, 14)
df_test.head(5)
teljesítmény
| CRIM | ZN | INDUS | CHAS | NOX | RM | KOR | DIS | RAD | TAX | 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 teleszórva, amelyek megzavarják az elemzést és a gépi tanulási képzést.
Az adatkészlet tisztításának első lépése annak megértése, hogy hol van szükség tisztításra. Egy adatkészlet tisztítása bonyolult lehet, különösen bármilyen általánosítható módon
A Google Kutatócsapata ehhez a feladathoz kifejlesztett egy eszközt metszettel amelyek segítenek az adatok megjelenítésében és mindenféle módon szeletelésében. Ez jó kiindulópont az adatkészlet felépítésének megértéséhez.
A szempontok lehetővé teszik, hogy megtalálja, ahol az adatok nem egészen úgy néznek ki, ahogy Ön gondolja.
A webalkalmazásuk kivételével a Google megkönnyíti az eszköztár beágyazását a Jupyter jegyzetfüzet.
A Facets két részből áll:
- A szempontok áttekintése
- Facets Deep Dive
A szempontok áttekintése
A Facets Overview áttekintést nyújt az adatkészletről. A Facets Overview felosztja az adatok oszlopait a legfontosabb információkat megjelenítő sorokra
- a hiányzó megfigyelés százalékos aránya
- min és max értékeket
- statisztikákat, például az átlagot, a mediánt és a szórást.
- Ezenkívül hozzáad egy oszlopot, amely a nullák százalékos arányát mutatja, ami akkor hasznos, ha az értékek többsége nulla.
- Ezek a disztribúciók megtekinthetők a tesztadatkészleten, valamint az egyes jellemzők betanítási halmazán. Ez azt jelenti, hogy kétszer is ellenőrizheti, hogy a teszt hasonló eloszlású-e, mint a képzési adatok.
Ez a minimum, amit minden gépi tanulási feladat előtt meg kell tenni. Ezzel az eszközzel nem hagyja ki ezt a döntő lépést, és rávilágít néhány rendellenességre.
Facets Deep Dive
A Facets Deep Dive egy klassz eszköz. Lehetővé teszi az adatkészlet tisztázását, és a teljes nagyítást az egyes adatok megtekintéséhez. Ez azt jelenti, hogy soronként és oszloponként dimenzionálhatja az adatokat az adatkészlet bármely funkciójában.
Ezt a két eszközt fogjuk használni a bostoni adatkészlettel.
Megjegyzések: A Facets Overview és a Facets Deep Dive nem használható egyszerre. Az eszköz cseréjéhez először törölnie kell a notebookot.
Telepítse a Facet
A legtöbb elemzéshez használhatja a Facet webalkalmazást. Ebben az oktatóanyagban látni fogja, hogyan kell használni a Jupyter Jegyzetfüzet.
Először is telepítenie kell az nbextensions-t. Ezzel a kóddal történik. Másolja és illessze be a következő kódot a gép termináljába.
pip install jupyter_contrib_nbextensions
Közvetlenül ezt követően klónoznia kell a tárolókat a számítógépén. Két választása van:
1.opció) Másolja ki és illessze be ezt a kódot a terminálba (Ajánlott)
Ha nincs Git telepítve a gépére, kérjük, lépjen erre az URL-re https://git-scm.com/download/win és kövesse az utasítást. Ha végzett, használhatja a git parancsot a terminálban a Mac User számára vagy az Anaconda promptot Windows használó
git clone https://github.com/PAIR-code/facets
2.opció) Tovább https://github.com/PAIR-code/facets és töltse le a tárolókat.
Ha az első lehetőséget választja, a fájl a letöltött fájlba kerül. Engedélyezheti a fájl letöltését, vagy áthúzhatja egy másik útvonalra.
Ezzel a parancssorral ellenőrizheti, hogy hol vannak a Facets tárolva:
echo `pwd`/`ls facets`
Most, hogy megtalálta a Facets elemet, telepítenie kell azt Jupyter Jegyzetfüzet. A munkakönyvtárat arra az elérési útra kell beállítani, ahol a facets található.
A jelenlegi munkakönyvtárnak és a Facets zip helyének meg kell egyeznie.
A munkakönyvtárat a Facetre kell mutatnia:
cd facets
A Facets telepítéséhez Jupyter, két lehetőség közül választhat. Ha telepítette Jupyter a Conda minden felhasználó számára másolja ki ezt a kódot:
használhatja a jupyter nbextension install facets-dist/ parancsot
jupyter nbextension install facets-dist/
Ellenkező esetben használja:
jupyter nbextension install facets-dist/ --user
Rendben, minden készen áll. Nyissuk meg a Facet Áttekintést.
Áttekintés
Áttekintés használja a Python szkript a statisztikák kiszámításához. Importálnia kell a generic_feature_statistics_generator nevű szkriptet ide Jupyter. Ne aggódj; a szkript a facets fájlokban található.
Meg kell találnia az útját. Könnyen elkészíthető. Megnyitja a faceteket, megnyitja a facets_overview fájlt, majd a pythont. Másolja az elérési utat
Ezt követően térjen vissza a Jupyter, és írja be a következő kódot. Módosítsa a „/Users/Thomas/facets/facets_overview/python” elérési utat az elérési útjára.
# Add the facets overview python code to the python path# Add t
import sys
sys.path.append('/Users/Thomas/facets/facets_overview/python')
Az alábbi kóddal importálhatja a szkriptet.
from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
A Windowsban ugyanaz a kód lesz
import sys sys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python") from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
A jellemzőstatisztikák kiszámításához a GenericFeatureStatistics függvényt kell használniGenerator(), és a ProtoFromDataFrames objektumot használja. Az adatkeretet átadhatja egy szótárban. Például, ha összefoglaló statisztikát akarunk készíteni a vonatkészlethez, akkor az információt egy szótárban tárolhatjuk, és a „ProtoFromDataFrames” objektumban használhatjuk.
-
'name': 'train', 'table': df_train
A Name a megjelenített táblázat neve, és annak a táblának a nevét használja, amelyhez az összegzést ki szeretné szá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 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")
Végül csak másolja és illessze be az alábbi kódot. A kód közvetlenül a GitHubból származik. Ezt látnia kell:
# Display the facets overview visualization for this data# Displ
from IPython.core.display import display, HTML
HTML_TEMPLATE = """<link rel="import" href="/hu/nbextensions/facets-dist/facets-jupyter.html" >
<facets-overview id="elem"></facets-overview>
<script>
document.querySelector("#elem").protoInput = "{protostr}";
</script>"""
html = HTML_TEMPLATE.format(protostr=protostr)
display(HTML(html))
Grafikon
Az adatok és eloszlásuk ellenőrzése után korrelációs mátrixot készíthet. A korrelációs mátrix kiszámítja a Pearson-együtthatót. Ez az együttható -1 és 1 közé van kötve, a pozitív érték pozitív, a negatív érték pedig a negatív korrelációt jelzi.
Érdekelne, hogy mely változók lehetnek jó jelöltek az interakciós kifejezésekre.
## 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})
teljesítmény
<matplotlib.axes._subplots.AxesSubplot at 0x1a184d6518>
png
A mátrixból láthatja:
- LSTAT
- RM
Erősen korrelálnak a PRICE-val. Egy másik izgalmas tulajdonság a NOX és az INDUS közötti erős pozitív korreláció, ami azt jelenti, hogy a két változó ugyanabba az irányba mozog. Emellett az ÁRral is összefüggenek. A DIS erősen korrelál az IND-szel és a NOX-szal is.
Van néhány első tippje, hogy az IND és a NOX jó jelöltek lehetnek az elfogó kifejezésre, és a DIS-re is érdemes lehet összpontosítani.
Kicsit mélyebbre mehet egy párrács ábrázolásával. Részletesebben szemlélteti a korábban elkészített korrelációs térképet.
A párrácsot a következőképpen állítjuk össze:
- Felső rész: Szórványdiagram illesztett vonallal
- Átló: Kernel sűrűség diagramja
- Alsó rész: Többváltozós magsűrűség diagram
Négy független változóra fókuszálhat. A választás azoknak a változóknak felel meg, amelyek erős korrelációt mutatnak a PRICE-val
- INDUS
- NOX
- RM
- LSTAT
ráadásul az ÁR.
Megjegyzések hogy a standard hiba alapértelmezés szerint hozzáadódik a szóró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)
teljesítmény
Kezdjük a felső résszel:
- Az ár negatívan korrelál az INDUS-szal, a NOX-szal és az LSTAT-tal; pozitívan korrelált az RM-mel.
- Kissé nemlinearitás tapasztalható az LSTAT és a PRICE között
- Olyan, mint egy egyenes, amikor az ár egyenlő 50-nel. Az adatkészlet leírásából a PRICE 50-es értékre lett csonkolva.
Átlós
- Úgy tűnik, hogy a NOX-nak két klasztere van, egy 0.5 és egy 0.85 körüli.
Ha többet szeretne tudni róla, nézze meg az alsó részt. A Multivariate Kernel Density érdekes abban az értelemben, hogy ott színezi ki, ahol a legtöbb pont található. A szórásdiagram különbsége valószínűségi sűrűséget rajzol, még akkor is, ha az adatkészletben nincs pont egy adott koordinátához. Ha a szín erősebb, az azt jelzi, hogy a terület körül magas a pontkoncentráció.
Ha ellenőrzi az INDUS és a NOX többváltozós sűrűségét, láthatja a pozitív korrelációt és a két klasztert. Ha az ipar részesedése 18 felett van, akkor a nitrogén-oxidok koncentrációja 0.6 felett van.
Elgondolkodhat az INDUS és a NOX közötti kölcsönhatás hozzáadásán a lineáris összefüggésben.
Végül használhatja a Google által létrehozott második eszközt, a Facets Deep Dive-et. Az interfész négy fő részre oszlik. A középső rész az adatok nagyítható megjelenítése. A panel tetején található a legördülő menü, ahol módosíthatja az adatok elrendezését a fazettás, pozicionálás és 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ő vizualizáció bármely adatpontjára kattintva megtekintheti az adott adatpont részleteit.
Az adatvizualizációs lépés során a ház árának független változója közötti páronkénti korrelációt keresi. Ez azonban legalább három változót foglal magában, és a 3D-s diagramokkal bonyolult dolgozni.
A probléma megoldásának egyik módja egy kategorikus változó létrehozása. Ez azt jelenti, hogy létrehozhatunk egy 2D-s ábrázolást a pont színével. A PRICE változót négy kategóriára oszthatja, ahol minden kategória egy kvartilis (azaz 0.25, 0.5, 0.75). Ezt az új változót Q_PRICE hívja.
## Check non linearity with important features df['Q_PRICE'] = pd.qcut(df['PRICE'], 4, labels=["Lowest", "Low", "Upper", "upper_plus"]) ## Show non linearity between RM and LSTAT ax = sns.lmplot(x="DIS", y="INDUS", hue="Q_PRICE", data=df, fit_reg = False,palette="Set3")
Facets Deep Dive
A Deep Dive megnyitásához át kell alakítania az adatokat JSON formátumba. A pandák tárgyként ahhoz. A to_json használható a Pandas adatkészlet után.
A kód első sora kezeli az adatkészlet méretét.
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')
Az alábbi kód a Google GitHubtól származik. A kód futtatása után a következőket kell látnia:
# Display thde Dive visualization for this data
from IPython.core.display import display, HTML
# Create Facets template
HTML_TEMPLATE = """<link rel="import" href="/hu/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))
Érdekelne, hogy van-e összefüggés az iparági díj, az oxidkoncentráció, a munkaügyi központ távolsága és a ház ára között.
Ehhez először fel kell osztani az adatokat iparági tartomány és szín szerint az árkvartilis segítségével:
- Válassza ki az X fazettást, és válassza az INDUS lehetőséget.
- Válassza a Kijelző, majd a DIS lehetőséget. A pontokat a ház árának kvartilisével fogja színezni
itt a sötétebb színek azt jelentik, hogy messze van az első munkaügyi központtól.
Eddig megint azt mutatja, amit tudsz, alacsonyabb iparági árfolyam, magasabb ár. Most megtekintheti az INDUX és a NOX szerinti bontást.
- Válassza az Y fazettát, és válassza a NOX lehetőséget.
Most láthatja, hogy az első munkaügyi központtól távoli házban a legalacsonyabb az iparági részesedés, és ezért a legalacsonyabb az oxidkoncentráció. Ha úgy dönt, hogy Q_PRICE-vel jeleníti meg a típust, és nagyítja a bal alsó sarkot, akkor láthatja, hogy milyen típusú árról van szó.
Van még egy tippje, hogy az IND, NOX és DIS közötti interakció jó jelölt lehet a modell javítására.
TensorFlow
Ebben a szakaszban meg fogja becsülni a lineáris osztályozót a TensorFlow estimatators API-val. A következőképpen jár el:
- Készítse elő az adatokat
- A benchmark modell becslése: Nincs interakció
- Becsülj meg egy interakciós modellt
Ne feledje, a gépi tanulás célja a hiba minimalizálása. Ebben az esetben a legalacsonyabb átlagos négyzetes hibával rendelkező modell nyer. A TensorFlow becslő automatikusan kiszámítja ezt a mérőszámot.
Előkészítési adatok
A legtöbb esetben át kell alakítania az adatokat. Ezért lenyűgöző a Facets Overview. Az összefoglaló statisztikából látható, hogy vannak kiugró értékek. Ezek az értékek befolyásolják a becsléseket, mert nem hasonlítanak az Ön által elemzett sokaságra. A kiugró értékek általában elfogulták az eredményeket. Például egy pozitív kiugró érték túlbecsüli az együtthatót.
A probléma megoldására jó megoldás a változó szabványosítása. A szabványosítás egy szórását és a nulla átlagát jelenti. A szabványosítási folyamat két lépésből áll. Először is levonja a változó átlagértékét. Másodszor, elosztja a szórással, így az eloszlás egységnyi szórással rendelkezik.
A sklearn könyvtár hasznos a változók szabványosításában. Erre a célra használhatja a modul-előfeldolgozást az objektumskálával.
Az alábbi függvény segítségével méretezhet egy adatkészletet. Vegye figyelembe, hogy nem méretezi a címkeoszlopot és a kategorikus változókat.
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
A funkció segítségével összeállíthatja a méretezett vonat/tesztkészletet.
df_train_scale = standardize_data(df_train) df_test_scale = standardize_data(df_test)
Alapvető regresszió: Benchmark
Először is interakció nélkül betanít és tesztel egy modellt. A cél a modell teljesítménymutatójának megtekintése.
A modell betanításának módja pontosan az oktatóanyag szerint történik Magas szintű API. A TensorFlow LinearRegressor becslőt fogja használni.
Emlékeztetőül a következőket kell választania:
- a modellbe helyezendő funkciók
- átalakítja a funkciókat
- megszerkeszteni a lineáris regresszort
- konstruálja meg az input_fn függvényt
- képezze a modellt
- tesztelje a modellt
Az adatkészlet összes változóját használja a modell betanításához. Összességében vannak elevel folytonos változók és egy kategorikus változó
## 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']
A jellemzőket numerikus oszlopokká vagy kategorikus oszlopokká alakítja
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)
teljesítmény
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}
A vonat- vagy tesztadatok minden oszlopa Tenzorrá alakul 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)
Megbecsüli a modellt a vonatadatokon.
model.train(input_fn=get_input_fn(df_train_scale,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
teljesítmény
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>
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)
teljesítmény
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}
A modell vesztesége 1650. Ez az a mutató, amelyet meg kell verni a következő részben
A modell tökéletesítése: Interakciós kifejezés
Az oktatóanyag első részében érdekes kapcsolatot láttál a változók között. A különböző vizualizációs technikák feltárták, hogy az INDUS és a NOS összekapcsolódnak, és elfordulnak, hogy felerősí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ítható-e a modell által előre jelzett modell.
Minden adatkészlethez két új oszlopot kell hozzáadnia: vonat + teszt. Ehhez létre kell hoznia egy függvényt az interakciós tag kiszámításához, egy másikat pedig a hármas interakciós tag 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 a betanítási adatkészlethez és a tesztadatkészlethez.
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 betanítást és a tesztet, a var_1 és a var_2, az Ön esetében az INDUS és a NOX interakciójá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
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ós tag 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, test
interation_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, hozzáadhatja őket a betanítási és tesztelési adatkészlethez. Ezt a két új adatkeretet nevezed el:
- 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)
teljesítmény
Ez az; megbecsülheti az új modellt az interakciós feltételekkel, és megnézheti a teljesítménymutatót.
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)
teljesítmény
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}
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)
teljesítmény
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)
teljesítmény
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}
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 készíthet, mint a benchmark modellel.
