TensorFlow Lineáris Regresszió, Facet és Interaction Term

TensorFlow lineáris regresszió

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:

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.

Ugyanez a becslőcsalád működteti a lineáris osztályozó amikor a címke egy osztály, nem pedig egy ár. Ebben az oktatóanyagban megpróbáljuk megvizsgálni, hogy mely változók lehetnek jó jelöltek interakciós kifejezésekként. Teszteljük, hogy az ilyen jellegű információk hozzáadása jobb ár-előrejelzéshez vezet-e.

Összefoglaló statisztika

Van néhány lépés, amit követhetsz, mielőtt továbblépnél a modellhez. Ahogy korábban említettük, a modell az adatok általánosítása. A legjobb gyakorlat az, ha először megérted az adatokat, és csak utána teszel előrejelzést. Ha nem ismered az adataidat, csekély esélyed 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 matplotlib és a seaborn csomagokat. PythonTelepíthet egy 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 PythonA Seaborn egy statisztikai vizualizációs könyvtár, amely a matplotlib-re épül. A következőket biztosítja:tractív és gyönyörű telkek.

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.

Verzió megjegyzés: load_boston elavult volt a scikit-learn 1.0-ban és eltávolítva a scikit-learn 1.2-ben mivel az adathalmaz faji alapú besorolású jellemzőt kódol. Jelenlegi telepítés esetén használja a következőt: fetch_california_housing ehelyett, vagy töltse be saját maga a nyers fájlt. Az alább látható munkafolyamat változatlan; csak a betöltő változik.

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

A jellemzők nevei a feature_names objektumban tömbként tárolódnak.

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 mintavételi függvénnyel rendelkezik az adatkeret 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 kijavítja a keverést, így mindenki számára ugyanazok a sorok kerülnek visszaadásra.

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

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

Az Google A kutatócsoport kifejlesztett egy eszközt erre a feladatra, az ún. metszettel amely segít vizualizálni az adatokat és mindenféleképpen szeletelni azokat. Ez egy jó kiindulópont az adathalmaz elrendezésének megértéséhez.

A Facets segítségével megkeresheti, hogy az adatok hol nem egészen úgy néznek ki, ahogy Ön elvárná.

A webes alkalmazásukat kivéve, Google megkönnyíti az eszközkészlet beágyazását egy 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

1. a hiányzó megfigyelés százalékos aránya
2. min és max értékeket
3. statisztikákat, például az átlagot, a mediánt és a szórást.
4. 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.
5. 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 nagyszerű eszköz. Lehetővé teszi, hogy tisztább képet kapj az adathalmazodról, és teljesen ráközelíts, hogy egyetlen adatot is lásd. Ez azt jelenti, hogy az adatokat soronként és oszloponként is elemezheted az adathalmaz bármely jellemzője alapján.

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.

Mielőtt bármelyik eszköz használható lenne, a Facets-et telepíteni kell a notebook környezetbe.

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 telepítve a Git a gépeden, kérlek, menj ide URL Git a következőhöz: Windows letöltés oldal é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 a PAIR-kód/aspektusok tárháza és töltse le a tárolókat.

A fenti tárolóoldalon található a 2. opció által használt letöltés gomb. Ha az első opciót választja, a fájl a letöltési mappába kerül. Vagy engedélyezheti a fájl letöltését, vagy áthúzhatja egy másik elérési útra.

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 fenti terminállista megerősíti, hogy a facets az aktuális munkakönyvtárban található. A munkakönyvtárat a Facetre kell irányítani:

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:

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.

Futtatási szempontok áttekintése itt: Jupyter

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

Korrelációs gráf és páros rács

Miután ellenőrizte az adatokat és azok eloszlását, ábrázolhat 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é van korlátozva, ahol a pozitív érték pozitív, a negatív érték pedig negatív korrelációt jelöl.

Érdekelne, hogy mely változók lehetnek jó jelöltek az interakciós kifejezésekre.

Verzió megjegyzés: az alábbi maszk hívásokat np.bool, egy álnév, amely a NumPy 1.20-as verziójában elavulttá vált, és eltávolítva a NumPy 1.24-es verziójábanEgy újabb NumPy-n ugyanez a sor felveti a AttributeError: module 'numpy' has no attribute 'bool'; a beépített bool a beugró csere.

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

A fenti hőtérképen a sötétebb négyzetek az erősebb korrelációkat jelölik. A mátrixból látható:

• LSTAT
• RM

Erős korrelációban állnak az ÁRRAL. Egy másik izgalmas jellemző az NOX és az INDUS közötti erős pozitív korreláció, ami azt jelenti, hogy ez a két változó ugyanabba az irányba mozog. Mindkettő korrelációban áll az ÁRRAL. A DIS szintén szorosan korrelál az INDUS-szal és a NOX-szal.

Van egy első utalás arra, hogy az INDUS és a NOX jó jelöltek lehetnek interakciós tagként, és a DIS is érdekes lehet a kutatás szempontjából.

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áros rács a következőképpen épül fel:

• 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 koncentrálsz. A választásod az ÁRRAL szorosan korreláló változóknak felel meg.

• 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.
• Enyhe nemlinearitás van 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álhatod a második által létrehozott eszközt. Google, A részletek részletes áttekintése. A felület négy fő részre oszlik. A középső terület az adatok nagyítható kijelzője. A panel tetején található a legördülő menü, ahol megváltoztathatja az adatok elrendezését, így vezérelheti a részleteket, a pozicionálást és a színt. A jobb oldalon egy adott adatsor részletes nézete látható. Ez azt jelenti, hogy a középső vizualizációban bármelyik adatpontra 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 egyik megoldási módja egy kategorikus változó létrehozása. Azaz létrehozhatunk egy 2D-s ábrát, és kiszínezhetjük a pontokat. A PRICE változót négy kategóriára oszthatjuk, ahol minden kategória egy kvartilis (azaz 0.25, 0.5, 0.75). Ezt az új változót Q_PRICE-nak nevezzük.

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

A Facets Deep Dive használata

A Deep Dive megnyitásához át kell alakítani az adatokat JSON formátumba. A Pandának van egy metódusa erre: hívja meg a to_json metódust a DataFrame-en.

A kód első sora a sprite méretét az adathalmaz sorainak száma alapján állítja be.

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 innen származik Google GitHub. A kód futtatása után ezt kell látnod:

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

# Create Facets template  
HTML_TEMPLATE = """<link rel="import" href="/nbextensions/facets-dist/facets-jupyter.html">
        <facets-dive sprite-image-width="{sprite_size}" sprite-image-height="{sprite_size}" id="elem" height="600"></facets-dive>
        <script>
          document.querySelector("#elem").data = {jsonstr};
        </script>"""

# Load the json dataset and the sprite_size into the template
html = HTML_TEMPLATE.format(jsonstr=jsonstr, sprite_size=sprite_size)

# Display the template
display(HTML(html))

É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 nagyobb a távolság az első munkahelyteremtő 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.

A kutatás két lehetséges interakciót eredményezett, így a következő lépés egy tényleges modellben történő tesztelésük.

Lineáris regresszió TensorFlow-val

Ebben a szakaszban a lineáris regressziós modellt fogjuk becsülni a következővel: TensorFlow Becslő API. A következőképpen kell eljárnia:

• Készítse elő az adatokat
• A benchmark modell becslése: Nincs interakció
• Becsülj meg egy interakciós modellt

Verzió megjegyzés: a tf-estimator a csomag a TensorFlow 2.15-ös verziójával érkezett meg véglegesen, és a TensorFlow 2.16-os verziójától kezdve hiányzik, így tf.estimator.LinearRegressor csak TensorFlow 1.x-en fut, kivéve, ha Keras lineáris modellre migrálod.

Ne feledd, a gépi tanulás célja a hiba minimalizálása. Ebben az esetben a legkisebb átlagos négyzetes hibával rendelkező modell nyer. A TensorFlow becslő automatikusan kiszámítja ezt a metrikát.

Előkészítési adatok

A legtöbb esetben transzformálni kell az adatokat. Ezért lenyűgöző a Facets Overview. Az összesítő statisztikából láthattuk, hogy vannak kiugró értékek. Ezek az értékek befolyásolják a becsléseket, mert nem hasonlítanak az elemzett populációra. A kiugró értékek általában torzítják az eredményeket. Például egy pozitív kiugró érték hajlamos túlbecsülni az együtthatót.

A probléma megoldására egy jó megoldás a változó standardizálása. A standardizálás egy szórást és nulla átlagot jelent. A standardizálás folyamata két lépésből áll. Először is, felosztjatracts a változó várható értékét. Másodszor, elosztja a szórással, így az eloszlás egységnyi szórást eredményez.

A könyvtár scikit elsajátítható hasznos a változók szabványosításához. Erre a célra használhatod a modul előfeldolgozását az objektumskálázással.

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 megegyezik a bemutatóban szereplővel. 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 adathalmaz összes változóját használod a modell betanításához. Összesen tizenkét folytonos változó és egy kategorikus változó van.

## 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 oszlopát a get_input_fn függvénnyel tenzorrá alakítjuk.

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.9785. 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 egy érdekes kapcsolatot láthattunk 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 NOX összefüggenek, és felerősítik egymás hatását az árra. Az INDUS és a NOX közötti kölcsönhatás nemcsak befolyásolja az árat, hanem ez a hatás erősebb, ha a DIS-szel kölcsönhatásba lép.

Ideje általánosítani ezt az elképzelést, és megnézni, hogy javítható-e a modell előrejelzése.

Két új oszlopot kell hozzáadnod minden adathalmazhoz: a train és a test oszlopot. Ehhez létre kell hoznod egy függvényt az interakciós tag kiszámításához, és egy másikat a tripla interakciós tag kiszámításához. Minden függvény egyetlen oszlopot hoz létre. Miután az új változók létrejöttek, összefűzheted őket a tanuló- és a teszt-adathalmazzal.

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

Ennyi: az interakciós tagok segítségével becsülheted meg az új modellt, és megnézheted, hogyan alakul 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 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}

Code

FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT','INDUS_NOS', 'INDUS_NOS_DIS','CHAS']
LABEL= 'PRICE'
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
    return tf.estimator.inputs.pandas_input_fn(
       x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
       y = pd.Series(data_set[LABEL].values),
       batch_size=n_batch,   
       num_epochs=num_epochs,
       shuffle=shuffle)

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

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.9863. 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.

Mindkét adat ugyanabból a 101 soros tesztrészből származik, így az átlagos veszteség nagyjából 8 százalékos csökkenése kizárólag a két interakciós oszlopnak tulajdonítható.

GYIK