TensorFlow lineaarne regressioon tahke ja interaktsiooni terminiga

TensorFlow lineaarne regressioon

Sellest õpetusest saate teada, kuidas andmeid kontrollida ja valmistada ette lihtsa lineaarse regressiooniülesande loomiseks.

See õpetus on jagatud kaheks osaks:

• Otsige suhtlust
• Testige mudelit

aasta eelmine juhendaja, kasutasite maja mediaanhinna hindamiseks Bostoni andmestikku. Bostoni andmekogum on väike, ainult 506 vaatlusega. Seda andmekogumit peetakse võrdlusaluseks uute lineaarse regressiooni algoritmide proovimisel.

Andmekogum koosneb:

Selles õpetuses hindame mediaanhinda lineaarse regresori abil, kuid keskendume ühele konkreetsele protsessile. masinõpe: "andmete ettevalmistamine."

Mudel üldistab andmete mustri. Sellise mustri jäädvustamiseks peate selle kõigepealt leidma. Hea tava on teha andmeanalüüs enne mis tahes masinõppealgoritmi käivitamist.

Õigete funktsioonide valimine muudab teie mudeli edukuse täielikult. Kujutage ette, et proovite hinnata inimeste palka, kui te ei lisa sugu muutujana, saate halva hinnangu.

Teine võimalus mudelit täiustada on vaadata sõltumatu muutuja vahelist korrelatsiooni. Tagasi näite juurde, võite mõelda haridusele kui suurepärasele kandidaadile, et ennustada palka, aga ka ametit. On aus öelda, et amet sõltub haridustasemest, nimelt annab kõrgharidus sageli parema ameti. Kui seda ideed üldistada, võime öelda, et sõltuva muutuja ja selgitava muutuja vahelist seost saab suurendada veel ühe selgitava muutuja võrra.

Et tabada hariduse piiratud mõju ametile, võime kasutada interaktsiooniterminit.

Kui vaadata palgavõrrandit, on see järgmine:

If on positiivne, siis tähendab see, et täiendav haridustase toob kaasa maja mediaanväärtuse suurema tõusu kõrge hõivatuse taseme korral. Teisisõnu, hariduse ja ameti vahel on koostoime.

Sama hinnangute perekond annab jõudu ka lineaarne klassifikaator kui silt on klass, mitte hind. Selles õpetuses püüame näha, millised muutujad sobivad hästi interaktsiooniterminiteks. Testime, kas sellise teabe lisamine viib parema hinnaennustuseni.

Kokkuvõtlik statistika

Enne mudeliga jätkamist on mõned sammud, mida saate järgida. Nagu varem mainitud, on mudel andmete üldistus. Parim tava on kõigepealt andmeid mõista ja seejärel ennustus teha. Kui te oma andmeid ei tunne, on teil mudeli täiustamiseks vähe võimalusi.

Esimese sammuna laadige andmed pandade andmeraamina ja looge treeningkomplekt ja testimiskomplekt.

Näpunäited: Selle õpetuse jaoks peavad teil olema installitud matplotlib ja seaborn. PythonSaate installida Python pakett lennult koos Jupyter. Sa Ei peaks tee seda

!conda install -- yes matplotlib

kuid

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

Pange tähele, et see samm pole vajalik, kui teil on installitud matplotlib ja seaborn.

Matplotlib on teek graafiku loomiseks PythonSeaborn on statistilise visualiseerimise teek, mis on loodud matplotlibi baasil. See pakub järgmist:tractive ja ilusaid süžeesid.

Allolev kood impordib vajalikud teegid.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
from sklearn.datasets import load_boston
import numpy as np

Raamatukogu sklearn sisaldab Bostoni andmestikku. Andmete importimiseks saate helistada selle API-le.

Versiooni märkus: load_boston oli scikit-learn 1.0-s aegunud ja eemaldatud scikit-learn 1.2-st kuna andmestik kodeerib rassiliselt laetud funktsiooni. Praeguse installi korral kasutage fetch_california_housing selle asemel või laadige toorfail ise. Allpool näidatud töövoog jääb samaks; erineb ainult laadur.

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

Funktsioonide nimed salvestatakse objektis feature_names massiivina.

boston.feature_names

Väljund

array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')

Saate veerge ümber nimetada.

df.columns = boston.feature_names
df['PRICE'] = boston.target
df.head(2)

Teisendate muutuja CHAS stringmuutujaks ja märgite selle jah-ga, kui CHAS = 1 ja ei, kui 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

Pandade puhul on andmekogumit lihtne jagada. Jagate andmestiku juhuslikult 80-protsendilise treeningkomplekti ja 20-protsendilise testimiskomplektiga. Pandad on sisseehitatud valimfunktsioon andmeraami jagamiseks.

Esimene parameeter frac on väärtus vahemikus 0 kuni 1. Määrate selle väärtuseks 0.8, et valida juhuslikult 80 protsenti andmekaadrist.

random_state parandab segase järjestuse, nii et kõigile tagastatakse samad read.

### Create train/test set
df_train=df.sample(frac=0.8,random_state=200)
df_test=df.drop(df_train.index)

Saate määrata andmete kuju. See peaks olema:

• Rongikomplekt: 506*0.8 = 405
• Testikomplekt: 506*0.2 = 101

print(df_train.shape, df_test.shape)

Väljund

(405, 14) (101, 14)

df_test.head(5)

Väljund

Andmed on segased; see on sageli tasakaalust väljas ja üle puistatud kõrvalekallete väärtustega, mis viskavad analüüsi ja masinõppe koolituse kõrvale.

Esimene samm andmestiku puhastamiseks on mõista, kus see puhastamist vajab. Andmestiku puhastamine võib olla keeruline, eriti mis tahes üldistaval viisil

. Google Uurimisrühm on selle töö jaoks välja töötanud tööriista nimega Tahked mis aitab andmeid visualiseerida ja neid igasugustel viisidel tükeldada. See on hea alguspunkt andmestiku ülesehituse mõistmiseks.

Tahked elemendid võimaldavad teil leida kohti, kus andmed ei näe päris sellised välja, nagu ootate.

Välja arvatud nende veebirakendus, Google muudab tööriistakomplekti manustamise lihtsaks Jupyter märkmik.

Facetsil on kaks osa:

• Aspektide ülevaade
• Facets Deep Dive

Aspektide ülevaade

Facets Overview annab andmestikust ülevaate. Facets Overview jagab andmete veerud oluliste kuvatud teabe ridadeks

1. puuduvate vaatluste protsent
2. min ja max väärtused
3. statistika, nagu keskmine, mediaan ja standardhälve.
4. See lisab ka veeru, mis näitab nullidega väärtuste protsenti, mis on kasulik, kui enamik väärtusi on nullid.
5. Neid jaotusi on võimalik näha nii testandmestikul kui ka iga funktsiooni koolituskomplektis. See tähendab, et saate veel kord kontrollida, kas testil on treeningandmetega sarnane jaotus.

See on vähemalt miinimum, mis tuleb enne mis tahes masinõppetoimingut teha. Selle tööriistaga ei jäta te seda olulist sammu vahele ja see toob esile mõned kõrvalekalded.

Facets Deep Dive

Deep Dive on lahe tööriist. See võimaldab teil oma andmestikust selgust saada ja suumida, et näha üksikut andmestikku. See tähendab, et saate andmeid ridade ja veergude kaupa detailselt analüüsida, lähtudes andmestiku mis tahes funktsioonist.

Kasutame neid kahte tööriista Bostoni andmekogumiga.

märkused: Te ei saa samaaegselt kasutada funktsiooni Facets Overview ja Facets Deep Dive. Tööriista vahetamiseks peate esmalt sülearvuti tühjendama.

Enne kummagi tööriista kasutamist tuleb Facets installida sülearvuti keskkonda.

Installige Facet

Enamiku analüüside jaoks saate kasutada veebirakendust Facet. Selles õpetuses näete, kuidas seda kasutada a Jupyter Märkmik.

Kõigepealt peate installima nbextensions. Seda tehakse selle koodiga. Kopeerite ja kleepite järgmise koodi oma masina terminali.

pip install jupyter_contrib_nbextensions

Kohe pärast seda peate oma arvutis olevad hoidlad kloonima. Teil on kaks valikut:

Valik 1) Kopeerige ja kleepige see kood terminali (Soovitatav)

Kui teie arvutis pole Giti installitud, minge palun sellele lehele URL Git for Windows lae leht ja järgige juhiseid. Kui olete lõpetanud, saate kasutada Maci kasutaja terminalis käsku git või Anaconda viipa Windows kasutaja

git clone https://github.com/PAIR-code/facets

Valik 2) Minna PAIR-koodi/tahkude hoidla ja laadige hoidlad alla.

Ülaltoodud hoidla lehel on 2. valiku puhul kasutatav allalaadimisnupp. Esimese valiku korral jõuab fail teie allalaadimiskausta. Saate faili kas alla laadida lasta või lohistada selle teisele teele.

Selle käsurealt saate kontrollida, kus tahke on salvestatud:

echo `pwd`/`ls facets`

Nüüd, kui olete Facetsi leidnud, peate selle installima Jupyter Märkmik. Peate määrama töökataloogi teele, kus tahud asuvad.

Teie praegune töökataloog ja Facetsi ZIP-i asukoht peaksid olema samad.

Ülaltoodud terminali loend kinnitab, et facets asub praeguses töökataloogis. Töökataloogiks tuleb suunata Facet:

cd facets

Facetsi installimiseks Jupyter, on teil kaks võimalust. Kui olete installinud Jupyter Condaga kõigi kasutajate jaoks kopeerige see kood:

jupyter nbextension install facets-dist/

Vastasel juhul kasutage:

jupyter nbextension install facets-dist/ --user

Olgu, kõik on valmis. Avame aspektide ülevaate.

Käivita aspektide ülevaade Jupyter

Ülevaade kasutab a Python skript statistika arvutamiseks. Peate importima skripti nimega generic_feature_statistics_generator Jupyter. Ärge muretsege; skript asub tahkude failides.

Peate leidma selle tee. Seda tehakse lihtsalt. Avate tahud, avate faili facets_overview ja seejärel python. Kopeeri tee

Pärast seda minge tagasi juurde Jupyterja kirjutage järgmine kood. Muutke tee '/Users/Thomas/facets/facets_overview/python' oma teeks.

# Add the facets overview python code to the python path# Add t 
import sys
sys.path.append('/Users/Thomas/facets/facets_overview/python')

Saate skripti importida alloleva koodiga.

from generic_feature_statistics_generator import 
GenericFeatureStatisticsGenerator

Windowsis muutub sama kood

import sys
sys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python")

from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator

Funktsioonide statistika arvutamiseks peate kasutama funktsiooni GenericFeatureStatisticsGenerator() ja kasutate objekti ProtoFromDataFrames. Andmeraami saate edastada sõnastikus. Näiteks kui tahame koostada rongikogumi kohta kokkuvõtvat statistikat, saame salvestada teabe sõnastikku ja kasutada seda objektis "ProtoFromDataFrames"

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

Nimi on kuvatava tabeli nimi ja te kasutate kokkuvõtte arvutamiseks selle tabeli nime. Teie näites on andmeid sisaldav tabel 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")

Lõpuks kopeerige ja kleepige allolev kood. Kood pärineb otse GitHubist. Peaksite nägema seda:

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

Korrelatsioonigraaf ja paarisvõrk

Pärast andmete ja nende jaotuse kontrollimist saate joonistada korrelatsioonimaatriksi. Korrelatsioonimaatriks arvutab Pearsoni koefitsiendi. See koefitsient on piiratud vahemikuga -1 ja 1, kus positiivne väärtus näitab positiivset korrelatsiooni ja negatiivne väärtus negatiivset korrelatsiooni.

Teid huvitab, millised muutujad võivad olla interaktsiooniterminite jaoks head kandidaadid.

Versiooni märkus: allolev mask kutsub np.bool, alias, mis oli NumPy 1.20-s aegunud ja eemaldatud NumPy 1.24-sHiljutisel NumPy-l tekitab sama rida AttributeError: module 'numpy' has no attribute 'bool'sisseehitatud bool on sisse lülitatav asendus.

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

Väljund

<matplotlib.axes._subplots.AxesSubplot at 0x1a184d6518>

Ülaltoodud soojuskaardil tähistavad tumedamad ruudud tugevamaid korrelatsioone. Maatriksilt näete:

• LSTAT
• RM

On tugevalt korrelatsioonis PRICE'iga. Teine põnev omadus on tugev positiivne korrelatsioon NOX-i ja INDUS-i vahel, mis tähendab, et need kaks muutujat liiguvad samas suunas. Mõlemad on samuti korrelatsioonis PRICE'iga. DIS on samuti tugevalt korrelatsioonis INDUS-i ja NOX-iga.

Teil on esimene vihje, et INDUS ja NOX võivad olla head kandidaadid interaktsiooniterminiks ning ka DIS-ile keskendumine võib olla huvitav.

Võite minna veidi sügavamale, joonistades paarisruudustiku. See illustreerib üksikasjalikumalt varem joonistatud korrelatsioonikaarti.

Paarivõrk on koostatud järgmiselt:

• Ülemine osa: sobitatud joonega hajuvusdiagramm
• Diagonaal: tuuma tiheduse graafik
• Alumine osa: mitme muutujaga tuuma tiheduse graafik

Sa keskendud neljale sõltumatule muutujale. Valik vastab muutujatele, millel on tugev korrelatsioon PRICE'iga.

• INDUS
• NOX
• RM
• LSTAT

pealegi HIND.

märkused et standardviga lisatakse vaikimisi hajuvusgraafikule.

attributes = ["PRICE", "INDUS", "NOX", "RM", "LSTAT"]

g = sns.PairGrid(df[attributes])
g = g.map_upper(sns.regplot, color="g")
g = g.map_lower(sns.kdeplot,cmap="Reds", shade=True, shade_lowest=False)
g = g.map_diag(sns.kdeplot)

Väljund

Alustame ülemisest osast:

• Hind on negatiivses korrelatsioonis INDUSe, NOXi ja LSTATiga; positiivses korrelatsioonis RM-iga.
• LSTATi ja PRICE'i vahel on kerge mittelineaarsus.
• Kui hind on 50, on nagu sirgjoon. Andmestiku kirjeldusest on PRICE kärbitud väärtusega 50

Diagonaal: NOXil näib olevat kaks klastrit, üks umbes 0.5 ja teine ​​umbes 0.85.

Selle kohta lisateabe saamiseks võite vaadata alumist osa. Multivariate Kernel Density on selles mõttes huvitav, et see värvib seal, kus asub enamik punkte. Erinevus hajuvusdiagrammiga joonistab tõenäosustiheduse, kuigi antud koordinaadi jaoks pole andmekogumil mingit mõtet. Kui värv on tugevam, näitab see punkti suurt kontsentratsiooni selle piirkonna ümber.

Kui kontrollite INDUS-i ja NOX-i mitme muutujaga tihedust, näete positiivset korrelatsiooni ja kahte klastrit. Kui tööstuse osakaal on üle 18, on lämmastikoksiidide kontsentratsioon üle 0.6.

Võite mõelda INDUSe ja NOX-i vahelise interaktsiooni lisamisele lineaarses seoses.

Lõpuks saate kasutada teist loodud tööriista Google, Tahkude süvaanalüüs. Liides on jagatud neljaks põhiosaks. Keskel asuv keskosa on suumitav andmete kuva. Paneeli ülaosas on rippmenüü, kus saate muuta andmete paigutust, et juhtida tahkumist, positsioneerimist ja värvi. Paremal on konkreetse andmerea detailne vaade. See tähendab, et saate klõpsata mis tahes andmepunktil keskmises visualiseeringus, et näha selle konkreetse andmepunkti üksikasju.

Andmete visualiseerimise etapis olete huvitatud maja hinna sõltumatu muutuja paaripõhise korrelatsiooni otsimisest. See hõlmab aga vähemalt kolme muutujat ja 3D-graafikutega on keeruline töötada.

Üks viis selle probleemi lahendamiseks on luua kategooriline muutuja. See tähendab, et saame luua 2D-graafiku ja värvida punktid. Muutuja PRICE saab jagada nelja kategooriasse, kus iga kategooria on kvartiil (nt 0.25, 0.5, 0.75). Seda uut muutujat nimetatakse Q_PRICE-iks.

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

Fasettide kasutamise süvaanalüüs

Deep Dive'i avamiseks peate andmed teisendama JSON-vormingusse. Pandasil on selleks meetod: kutsuge DataFrame'is välja to_json.

Esimene koodirida määrab спрайdi suuruse vastavalt sellele, mitu rida andmestikus on.

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

Allolev kood pärineb Google GitHub. Pärast koodi käivitamist peaksite nägema järgmist:

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

Teid huvitab, kas tööstuse määra, oksiidikontsentratsiooni, töökeskuse kauguse ja maja hinna vahel on seos.

Selleks jagage esmalt andmed hinnakvartiiliga tööstusharu ja värvi järgi:

• Valige lihvimine X ja valige INDUS.
• Valige Kuva ja valige DIS. See värvib täpid majahinna kvartiiliga

Siin tähendavad tumedamad värvid suuremat kaugust esimesest töökeskusest.

Siiani näitab see jälle seda, mida sa tead, madalamat tööstuse intressimäära, kõrgemat hinda. Nüüd saate vaadata jaotust INDUXi ja NOXi järgi.

Valige tahk Y ja valige NOX.

Nüüd näete, et esimesest töökeskusest kaugel asuval majal on madalaim tööstusharu osakaal ja seega ka madalaim oksiidikontsentratsioon. Kui valite tüübi kuvamise Q_PRICE-ga ja suumite alumist vasakut nurka, näete, mis tüüpi hind see on.

Teil on veel üks vihje, et IND, NOX ja DIS vaheline interaktsioon võib olla mudeli täiustamiseks head kandidaadid.

Uuringu käigus on leitud kaks potentsiaalset interaktsiooni, seega on järgmine samm nende testimine tegelikus mudelis.

Lineaarne regressioon TensorFlow'ga

Selles osas hindate lineaarse regressioonimudelit, mille abil TensorFlow Hinnangu API. Jätkake järgmiselt:

• Valmistage andmed ette
• Võrdlusmudeli hindamine: interaktsioon puudub
• Hinnake interaktsiooniga mudelit

Versiooni märkus: the,en tf-estimator pakett tarniti oma lõpliku versiooniga TensorFlow 2.15 ja puudub TensorFlow 2.16-st ja hilisematest versioonidest, seega tf.estimator.LinearRegressor töötab ainult TensorFlow 1.x peal, välja arvatud juhul, kui migreerite selle Kerase lineaarsele mudelile.

Pea meeles, et masinõppe eesmärk on vea minimeerimine. Sellisel juhul võidab mudel, millel on väikseim keskmine ruutviga. TensorFlow hindaja arvutab selle mõõdiku automaatselt.

Ettevalmistuse andmed

Enamasti on vaja andmeid teisendada. Seetõttu ongi tahkude ülevaade põnev. Kokkuvõtlikust statistikast nägite, et esineb kõrvalekaldeid. Need väärtused mõjutavad hinnanguid, kuna need ei sarnane analüüsitava populatsiooniga. Kõrvalväärtused tavaliselt kallutavad tulemusi. Näiteks positiivne kõrvalekalle kipub koefitsienti üle hindama.

Hea lahendus selle probleemi lahendamiseks on muutuja standardiseerimine. Standardiseerimine tähendab standardhälvet ühe ja keskmist nulli. Standardiseerimisprotsess hõlmab kahte etappi. Esiteks, see hõlmabtract on muutuja keskmine väärtus. Teiseks jagab see standardhälbega nii, et jaotuse standardhälve on ühik.

Raamatukogu skikit õppima on kasulik muutujate standardiseerimiseks. Selleks saate kasutada mooduli eeltöötlust objekti skaleerimisega.

Andmestiku skaleerimiseks saate kasutada allolevat funktsiooni. Pange tähele, et te ei skaleeri sildi veergu ja kategooria muutujaid.

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

Funktsiooni saate kasutada skaleeritud rongi/katsekomplekti koostamiseks.

df_train_scale = standardize_data(df_train)
df_test_scale = standardize_data(df_test)

Põhiline regressioon: etalon

Esiteks treenite ja testite mudelit ilma suhtlemiseta. Eesmärk on näha mudeli jõudlusmõõdikut.

Mudeli treenimise viis on täpselt sama, mis õpetuses. kõrgetasemeline API. Kasutate TensorFlow hindajat LinearRegressor.

Meeldetuletuseks peate valima:

• mudelisse lisatavad omadused
• funktsioone muuta
• konstrueerida lineaarne regressor
• konstrueerida funktsioon input_fn
• koolitada modelli
• testi mudelit

Mudeli treenimiseks kasutate kõiki andmestikus olevaid muutujaid. Kokku on kaksteist pidevat muutujat ja üks kategooriline muutuja.

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

Funktsioonid teisendate numbriveeruks või kategooriliseks veerguks

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

Mudeli loote lineaarregressori abil. Mudeli salvestate kausta train_Boston

model = tf.estimator.LinearRegressor(    
	model_dir="train_Boston",     
    feature_columns=categorical_features + continuous_features)

Väljund

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}

Iga rongi- või testandmete veerg teisendatakse funktsiooniga get_input_fn tensoriks.

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)

Hindate mudelit rongi andmete põhjal.

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

Väljund

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>

Lõpuks hindate testikomplekti mudeli jõudlust

model.evaluate(input_fn=get_input_fn(df_test_scale, 
                                      num_epochs=1,
                                      n_batch = 128,
                                      shuffle=False),
                                      steps=1000)

Väljund

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}

Mudeli kaotus on 1650.9785. See on mõõdik, mida järgmises jaotises ületada

Täiustage mudelit: interaktsiooni termin

Õpetuse esimeses osas nägite huvitavat seost muutujate vahel. Erinevad visualiseerimistehnikad näitasid, et INDUS ja NOX on omavahel seotud ning võimendavad teineteise mõju hinnale. Lisaks INDUSe ja NOXi vastastikmõjule mõjutab hinda ka see mõju, mis on tugevam koos DISiga.

On aeg seda ideed üldistada ja vaadata, kas saate mudeli ennustust parandada.

Igale andmestikule tuleb lisada kaks uut veergu: train ja test. Selleks tuleb luua üks funktsioon interaktsioonitermini arvutamiseks ja teine ​​kolmiktermini arvutamiseks. Iga funktsioon loob ühe veeru. Pärast uute muutujate loomist saab need treening- ja testandmestikuga ühendada.

Kõigepealt peate looma uue muutuja INDUSe ja NOX-i interaktsiooni jaoks.

Allolev funktsioon tagastab kaks andmekaadrit, koolitus ja test, interaktsiooniga var_1 ja var_2, teie puhul INDUS ja NOX.

def interaction_term(var_1, var_2, name):
    t_train = df_train_scale[var_1]*df_train_scale[var_2]
    train = t_train.rename(name)
    t_test = df_test_scale[var_1]*df_test_scale[var_2]
    test = t_test.rename(name)
    return train, test

Salvestate kaks uut veergu

interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')
interation_ind_ns_train.shape
(325,)

Teiseks loote kolmekordse interaktsiooniliikme arvutamiseks teise funktsiooni.

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

Nüüd, kui teil on kõik vajalikud veerud, saate need lisada koolitus- ja testimisandmekomplekti. Nimetate need kaks uut andmeraami:

• df_train_new
• df_test_new

df_train_new = pd.concat([df_train_scale,
                          interation_ind_ns_train,
                          interation_ind_ns_dis_train],
                         axis=1, join='inner')
df_test_new = pd.concat([df_test_scale,
                         interation_ind_ns_test,
                         interation_ind_ns_dis_test],
                         axis=1, join='inner')
df_train_new.head(5)

Väljund

See on kõik: saate uut mudelit interaktsiooniterminite abil hinnata ja vaadata, kuidas on toimivusmõõdik.

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)

Väljund

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)

Väljund

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)

Väljund

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}

Uus kahjum on 1515.9863. Kahe uue muutuja lisamisega oli võimalik kahjumit vähendada. See tähendab, et saate teha paremaid ennustusi kui võrdlusmudeli puhul.

Mõlemad arvud pärinevad samast 101-realisest testjaotusest, seega on keskmise kaotuse umbes 8-protsendiline langus omistatav ainult kahele interaktsiooniveerule.

KKK