TensorFlow Lineaarinen regressio fasetilla ja vuorovaikutustermillä
Evelyn Clarke
Tässä opetusohjelmassa opit tarkistamaan tiedot ja valmistelemaan ne yksinkertaisen lineaarisen regressiotehtävän luomiseksi.
Tämä opetusohjelma on jaettu kahteen osaan:
- Etsi vuorovaikutusta
- Testaa malli
In edellinen opetusohjelma, käytit Bostonin tietojoukkoa talon mediaanihinnan arvioimiseen. Bostonin tietojoukon koko on pieni, ja siinä on vain 506 havaintoa. Tätä tietojoukkoa pidetään vertailukohtana uusien lineaarisen regressioalgoritmien kokeilussa.
Tietojoukko koostuu:
| Muuttuja | Tuotetiedot |
|---|---|
| zn | Asuinmaan osuus on kaavoitettu yli 25,000 XNUMX neliömetrin tontille. |
| Indus | Muiden kuin vähittäiskaupan hehtaarien osuus kaupunkia kohden. |
| nox | typen oksidien pitoisuus |
| rm | keskimääräinen huonemäärä asuntoa kohden |
| ikä | ennen vuotta 1940 rakennettujen omistusasuntojen osuus |
| DIS | painotetut etäisyydet viiteen Bostonin työvoimakeskukseen |
| vero | täysiarvoinen kiinteistöveroprosentti 10,000 XNUMX dollaria kohden |
| ptratio | oppilaiden ja opettajien suhde kaupungin mukaan |
| medv | Omistusasuntojen mediaaniarvo tuhansissa dollareissa |
| rikos | rikollisuus asukasta kohden kaupungeittain |
| chas | Charles Riverin valemuuttuja (1 jos rajoittaa riveriä; 0 muuten) |
| B | mustien osuus kaupungissa |
Tässä opetusohjelmassa arvioimme mediaanihinnan lineaarisen regressorin avulla, mutta keskitymme yhteen tiettyyn prosessiin koneoppiminen: "tietojen valmistelu."
Malli yleistää datassa olevan kuvion. Sellaisen kuvion vangitsemiseksi sinun on ensin löydettävä se. Hyvä käytäntö on suorittaa data-analyysi ennen koneoppimisalgoritmin suorittamista.
Oikeiden ominaisuuksien valitseminen ratkaisee mallisi menestyksen. Kuvittele, että yrität arvioida kansan palkkaa, jos et sisällytä sukupuolta kovariaattina, päädyt huonoon arvioon.
Toinen tapa parantaa mallia on tarkastella riippumattoman muuttujan välistä korrelaatiota. Takaisin esimerkkiin, voit ajatella koulutusta erinomaisena ehdokkaana palkan mutta myös ammatin ennustamisessa. On reilua sanoa, että ammatti riippuu koulutustasosta, nimittäin korkeakoulutus johtaa usein parempaan ammattiin. Jos tämä ajatus yleistetään, voidaan sanoa, että riippuvaisen muuttujan ja selittävän muuttujan välinen korrelaatio voidaan suurentaa vielä toisella selittävällä muuttujalla.
Voimme käyttää vuorovaikutustermiä kuvaamaan koulutuksen rajallista vaikutusta ammattiin.
Jos tarkastellaan palkkayhtälöä, siitä tulee:
If 
Jos on positiivinen, se tarkoittaa, että ylimääräinen koulutustaso nostaa talon mediaaniarvoa korkeammalle asumisasteelle. Toisin sanoen koulutuksen ja ammatin välillä on vuorovaikutusvaikutus.
Tässä opetusohjelmassa yritämme nähdä, mitkä muuttujat voivat olla hyviä vuorovaikutustermejä. Testaamme, johtaako tällaisen tiedon lisääminen parempaan hintaennusteeseen.
Tiivistelmätilastot
Voit suorittaa muutamia vaiheita ennen malliin siirtymistä. Kuten aiemmin mainittiin, malli on tietojen yleistys. Paras käytäntö on ymmärtää tiedot ja tehdä ennuste. Jos et tiedä tietojasi, sinulla on pienet mahdollisuudet parantaa malliasi.
Ensimmäisenä vaiheena lataa tiedot panda-tietokehyksenä ja luo harjoitussarja ja testaussarja.
Vinkkejä: Tätä opetusohjelmaa varten sinulla on oltava matplotlit ja seaborn asennettuna Python. Voit asentaa Python paketti lennossa Jupyter. Sinua Ei pitäisi tehdä tämän
!conda install -- yes matplotlib
mutta
import sys
!{sys.executable} -m pip install matplotlib # Already installed
!{sys.executable} -m pip install seaborn
Huomaa, että tämä vaihe ei ole välttämätön, jos sinulla on asennettuna matplotlib ja seaborn.
Matplotlib on kirjasto, johon voit luoda graafin Python. Seaborn on tilastollinen visualisointikirjasto, joka on rakennettu matplotlibin päälle. Se tarjoaa houkuttelevia ja kauniita tontteja.
Alla oleva koodi tuo tarvittavat kirjastot.
import pandas as pd from sklearn import datasets import tensorflow as tf from sklearn.datasets import load_boston import numpy as np
Kirjaston sklearn sisältää Bostonin tietojoukon. Voit tuoda tiedot soittamalla sen API:lle.
boston = load_boston() df = pd.DataFrame(boston.data)
Kohteen nimi tallennetaan taulukon objektiin ominaisuuden_nimet.
boston.feature_names
ulostulo
array(['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT'], dtype='<U7')
Voit nimetä sarakkeet uudelleen.
df.columns = boston.feature_names df['PRICE'] = boston.target df.head(2)
Muunnat muuttujan CHAS merkkijonomuuttujaksi ja merkitset sen kyllä, jos CHAS = 1 ja ei, jos 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
Pandoilla tietojoukon jakaminen on yksinkertaista. Jaat tietojoukon satunnaisesti 80 prosentin harjoitusjoukolla ja 20 prosentin testausjoukolla. Panda on sisäänrakennettu kustannustoiminto datakehysnäytteen jakamiseksi.
Ensimmäinen parametri frac on arvo 0-1. Asetat sen arvoon 0.8 valitaksesi satunnaisesti 80 prosenttia tietokehyksestä.
Random_state sallii saman datakehyksen palauttamisen kaikille.
### Create train/test set df_train=df.sample(frac=0.8,random_state=200) df_test=df.drop(df_train.index)
Voit saada tiedon muodon. Sen pitäisi olla:
- Junasarja: 506*0.8 = 405
- Testisarja: 506*0.2 = 101
print(df_train.shape, df_test.shape)
ulostulo
(405, 14) (101, 14)
df_test.head(5)
ulostulo
| CRIM | ZN | INDUS | CHAS | NOX | RM | IKÄ | DIS | RAD | TAX | PTRATIO | B | LSTAT | HINTA | |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0.00632 | 18.0 | 2.31 | Nro | 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 | Nro | 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 | Nro | 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 | Nro | 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 | Nro | 0.524 | 6.172 | 96.1 | 5.9505 | 5.0 | 311.0 | 15.2 | 396.90 | 19.15 | 27.1 |
Tiedot ovat sotkuisia; se on usein epätasapainossa ja siihen on siroteltu poikkeavia arvoja, jotka heikentävät analyysi- ja koneoppimiskoulutusta.
Ensimmäinen askel tietojoukon puhdistamisessa on ymmärtää, missä se tarvitsee puhdistusta. Tietojoukon puhdistaminen voi olla hankalaa, varsinkin millä tahansa yleistettävällä tavalla
Googlen tutkimustiimi on kehittänyt tätä työtä varten työkalun nimeltä Facets jotka auttavat visualisoimaan dataa ja viipaloimaan sen kaikenlaisilla tavoilla. Tämä on hyvä lähtökohta tietojoukon asettelun ymmärtämiselle.
Fasettien avulla voit löytää kohdat, joissa tiedot eivät näytä aivan siltä, miltä ajattelet.
Verkkosovellusta lukuun ottamatta Google tekee työkalupakin upottamisesta helppoa Jupyter muistikirja.
Facetsissä on kaksi osaa:
- Fasettien yleiskatsaus
- Facets Deep Dive
Fasettien yleiskatsaus
Facets Overview antaa yleiskuvan tietojoukosta. Facets Overview jakaa tietojen sarakkeet tärkeimpien tietojen riveihin
- puuttuvien havaintojen prosenttiosuus
- min ja max arvot
- tilastot, kuten keskiarvo, mediaani ja keskihajonta.
- Se lisää myös sarakkeen, joka näyttää nollien prosenttiosuuden, mikä on hyödyllistä, kun suurin osa arvoista on nollia.
- On mahdollista nähdä nämä jakaumat testitietojoukossa sekä kunkin ominaisuuden harjoitusjoukossa. Se tarkoittaa, että voit vielä kerran tarkistaa, että testillä on samanlainen jakautuminen harjoitustietojen kanssa.
Tämä on vähintään vähimmäistehtävä ennen koneoppimista. Tämän työkalun avulla et missaa tätä ratkaisevaa vaihetta, ja se korostaa joitakin poikkeavuuksia.
Facets Deep Dive
Facets Deep Dive on siisti työkalu. Sen avulla voit saada jonkin verran selkeyttä tietojoukostasi ja zoomata kokonaan, jotta näet yksittäisen datan. Se tarkoittaa, että voit jakaa tiedot riveittäin ja sarakkeittain kaikissa tietojoukon ominaisuuksissa.
Käytämme näitä kahta työkalua Bostonin tietojoukon kanssa.
Huomautuksia: Et voi käyttää Facets Overview- ja Facets Deep Dive -toimintoa samanaikaisesti. Sinun on ensin tyhjennettävä muistikirja, jotta voit vaihtaa työkalun.
Asenna Facet
Voit käyttää Facet-verkkosovellusta suurimman osan analyysistä. Tässä opetusohjelmassa näet, kuinka sitä käytetään a Jupyter Notebook.
Ensinnäkin sinun on asennettava nbextensions. Se tehdään tällä koodilla. Kopioit ja liität seuraavan koodin koneesi päätelaitteeseen.
pip install jupyter_contrib_nbextensions
Heti sen jälkeen sinun on kloonattava tietokoneesi arkistot. Sinulla on kaksi vaihtoehtoa:
Vaihtoehto 1) Kopioi ja liitä tämä koodi terminaaliin (Suositus)
Jos koneellesi ei ole asennettu Gitiä, siirry tähän URL-osoitteeseen https://git-scm.com/download/win ja noudata ohjeita. Kun olet valmis, voit käyttää git-komentoa päätteessä Mac-käyttäjälle tai Anaconda-kehotetta Windows lähettämä
git clone https://github.com/PAIR-code/facets
Vaihtoehto 2) Mene https://github.com/PAIR-code/facets ja lataa arkistot.
Jos valitset ensimmäisen vaihtoehdon, tiedosto päätyy lataustiedostoosi. Voit joko antaa tiedoston ladata tai vetää sen toiseen polkuun.
Voit tarkistaa, mihin puoliskot on tallennettu tällä komentorivillä:
echo `pwd`/`ls facets`
Nyt kun olet löytänyt Facetsin, sinun on asennettava se sisään Jupyter Muistikirja. Sinun on asetettava työhakemisto polulle, jossa fasetit sijaitsevat.
Nykyisen työhakemistosi ja Facets-zip-tiedoston sijainnin tulee olla samat.
Sinun on osoitettava työhakemisto Facetiin:
cd facets
Facetsin asentaminen sisään Jupyter, sinulla on kaksi vaihtoehtoa. Jos olet asentanut Jupyter Condalla kaikille käyttäjille, kopioi tämä koodi:
voi käyttää jupyter nbextension install facets-dist/
jupyter nbextension install facets-dist/
Muussa tapauksessa käytä:
jupyter nbextension install facets-dist/ --user
Selvä, olet valmis. Avataan Facet Overview.
Yleiskatsaus
Yleiskatsaus käyttää a Python komentosarja tilastojen laskemiseen. Sinun on tuotava komentosarja nimeltä generic_feature_statistics_generator kohteeseen Jupyter. Älä huoli; skripti sijaitsee facets-tiedostoissa.
Sinun on löydettävä sen polku. Se on helppo tehdä. Avaat fasetit, avaat tiedoston facets_overview ja sitten python. Kopioi polku
Tämän jälkeen palaa kohtaan Jupyter, ja kirjoita seuraava koodi. Muuta polku '/Users/Thomas/facets/facets_overview/python' polullesi.
# Add the facets overview python code to the python path# Add t
import sys
sys.path.append('/Users/Thomas/facets/facets_overview/python')
Voit tuoda skriptin alla olevalla koodilla.
from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Windowsissa sama koodi tulee
import sys sys.path.append(r"C:\Users\Admin\Anaconda3\facets-master\facets_overview\python") from generic_feature_statistics_generator import GenericFeatureStatisticsGenerator
Ominaisuustilastojen laskemiseksi sinun on käytettävä funktiota GenericFeatureStatisticsGenerator(), ja käytät objektia ProtoFromDataFrames. Voit välittää tietokehyksen sanakirjassa. Jos esimerkiksi haluamme luoda yhteenvetotilaston junajoukolle, voimme tallentaa tiedot sanakirjaan ja käyttää niitä objektissa "ProtoFromDataFrames"
-
'name': 'train', 'table': df_train
Nimi on näytettävän taulukon nimi, ja käytät sen taulukon nimeä, josta haluat laskea yhteenvedon. Esimerkissäsi tiedot sisältävä taulukko on 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")
Lopuksi kopioi ja liitä alla oleva koodi. Koodi tulee suoraan GitHubista. Sinun pitäisi pystyä näkemään tämä:
# Display the facets overview visualization for this data# Displ
from IPython.core.display import display, HTML
HTML_TEMPLATE = """<link rel="import" href="/fi/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))
Kaavio
Kun olet tarkistanut tiedot ja niiden jakautumisen, voit piirtää korrelaatiomatriisin. Korrelaatiomatriisi laskee Pearson-kertoimen. Tämä kerroin on sidottu -1:n ja 1:n välille, ja positiivinen arvo osoittaa positiivista korrelaatiota ja negatiivinen arvo negatiivista korrelaatiota.
Olet kiinnostunut näkemään, mitkä muuttujat voivat olla hyviä vuorovaikutustermejä.
## 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})
ulostulo
<matplotlib.axes._subplots.AxesSubplot at 0x1a184d6518>
png
Matriisista näet:
- LSTAT
- RM
Korreloivat vahvasti PRICE:n kanssa. Toinen jännittävä piirre on vahva positiivinen korrelaatio NOX:n ja INDUS:n välillä, mikä tarkoittaa, että nämä kaksi muuttujaa liikkuvat samaan suuntaan. Lisäksi ne korreloivat myös HINTAAN. DIS korreloi myös voimakkaasti IND:n ja NOX:n kanssa.
Sinulla on ensimmäinen vihje siitä, että IND ja NOX voivat olla hyviä ehdokkaita sieppaustermille, ja DIS saattaa myös olla mielenkiintoista keskittyä.
Voit mennä hieman syvemmälle piirtämällä pariruudukon. Se havainnollistaa yksityiskohtaisemmin aiemmin piirtämääsi korrelaatiokarttaa.
Pariruudukko, jonka muodostamme seuraavasti:
- Yläosa: Hajakuvaaja sovitetulla viivalla
- Diagonaali: Ytimen tiheyskäyrä
- Alaosa: Monimuuttuja ytimen tiheyskaavio
Voit valita painopisteen neljään riippumattomaan muuttujaan. Valinta vastaa muuttujia, joilla on vahva korrelaatio PRICE:n kanssa
- INDUS
- NOX
- RM
- LSTAT
lisäksi HINTA.
Huomautuksia että vakiovirhe lisätään oletuksena sirontakaavioon.
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)
ulostulo
Aloitetaan yläosasta:
- Hinta korreloi negatiivisesti INDUS:n, NOX:n ja LSTATin kanssa; korreloi positiivisesti RM:n kanssa.
- LSTAT:n ja PRICEn välillä on hieman epälineaarisuutta
- On kuin suora, kun hinta on 50. Tietojoukon kuvauksesta PRICE on katkaistu arvoon 50
Lävistäjä
- NOX:lla näyttää olevan kaksi klusteria, yksi noin 0.5 ja toinen noin 0.85.
Voit tarkistaa siitä lisää katsomalla alaosaa. Monimuuttujaydintiheys on mielenkiintoinen siinä mielessä, että se värittää siellä, missä suurin osa pisteistä on. Ero sirontakuvaajaan piirtää todennäköisyystiheyden, vaikka tiedossa ei ole mitään järkeä tietylle koordinaatille. Kun väri on voimakkaampi, se osoittaa korkean pisteen pitoisuuden tämän alueen ympärillä.
Jos tarkistat INDUS:n ja NOX:n monimuuttujatiheyden, näet positiivisen korrelaation ja kaksi klusteria. Kun teollisuuden osuus on yli 18, typpioksidipitoisuus on yli 0.6.
Voit harkita vuorovaikutuksen lisäämistä INDUS:n ja NOX:n välille lineaarisessa suhteessa.
Lopuksi voit käyttää toista Googlen luomaa työkalua, Facets Deep Dive. Käyttöliittymä on jaettu neljään pääosaan. Keskellä keskellä oleva alue on zoomattava tietojen näyttö. Paneelin yläreunassa on pudotusvalikko, jossa voit muuttaa tietojen järjestelyä fasetoinnin, paikantamisen ja värin ohjaamiseksi. Oikealla on yksityiskohtainen näkymä tietystä tietorivistä. Se tarkoittaa, että voit napsauttaa mitä tahansa tietopistettä keskimmäisessä visualisoinnissa nähdäksesi tiedot kyseisestä datapisteestä.
Tietojen visualisointivaiheessa olet kiinnostunut etsimään parittaista korrelaatiota talon hinnan riippumattoman muuttujan välillä. Se sisältää kuitenkin vähintään kolme muuttujaa, ja 3D-kaavioiden käsittely on monimutkaista.
Yksi tapa ratkaista tämä ongelma on luoda kategorinen muuttuja. Eli voimme luoda 2D-kuvan pisteen väristä. Voit jakaa muuttujan PRICE neljään luokkaan, joista jokainen on kvartiili (eli 0.25, 0.5, 0.75). Kutsut tätä uutta muuttujaa Q_PRICE.
## 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
Deep Diven avaamiseksi sinun on muutettava tiedot json-muotoon. Pandat esineenä sitä varten. Voit käyttää to_json-komentoa Pandas-tietojoukon jälkeen.
Ensimmäinen koodirivi käsittelee tietojoukon kokoa.
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')
Alla oleva koodi tulee Google GitHubista. Kun olet suorittanut koodin, sinun pitäisi nähdä tämä:
# Display thde Dive visualization for this data
from IPython.core.display import display, HTML
# Create Facets template
HTML_TEMPLATE = """<link rel="import" href="/fi/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))
Olet kiinnostunut näkemään, onko toimialahinnalla, oksidipitoisuudella, työvoimakeskuksen etäisyydellä ja talon hinnalla yhteyttä.
Tätä varten jaat ensin tiedot toimialan ja värin mukaan hintakvartiilin avulla:
- Valitse fasetointi X ja valitse INDUS.
- Valitse Näyttö ja valitse DIS. Se värittää pisteet asunnon hinnan neljänneksellä
tässä tummemmat värit tarkoittavat, että etäisyys ensimmäiseen työpisteeseen on kaukana.
Toistaiseksi se näyttää jälleen mitä tiedät: alhaisempi teollisuuden hinta, korkeampi hinta. Nyt voit tarkastella erittelyä INDUXin ja NOX:n mukaan.
- Valitse fasetti Y ja valitse NOX.
Nyt voit nähdä, että talon kaukana ensimmäisestä työvoimakeskuksesta on alhaisin teollisuuden osuus ja siten alhaisin oksidipitoisuus. Jos päätät näyttää tyypin Q_PRICE-hinnalla ja zoomaamalla vasenta alakulmaa, näet, minkä tyyppinen hinta on kyseessä.
Sinulla on toinen vihje, että IND:n, NOX:n ja DIS:n välinen vuorovaikutus voi olla hyviä ehdokkaita mallin parantamiseen.
TensorFlow
Tässä osiossa arvioit lineaarista luokittelijaa TensorFlow estimators API:lla. Toimit seuraavasti:
- Valmistele tiedot
- Arvioi vertailumalli: Ei vuorovaikutusta
- Arvioi malli, jossa on vuorovaikutusta
Muista, että koneoppimisen tavoitteena on minimoida virhe. Tässä tapauksessa malli, jolla on pienin keskineliövirhe, voittaa. TensorFlow-estimaattori laskee tämän mittarin automaattisesti.
Valmistelutiedot
Useimmissa tapauksissa sinun on muutettava tietosi. Siksi Facets Overview on kiehtova. Yhteenvetotilastoista näet, että poikkeavuuksia on. Nämä arvot vaikuttavat arvioihin, koska ne eivät näytä analysoimalta populaatiolta. Outliers yleensä puolueellinen tuloksia. Esimerkiksi positiivisella poikkeavalla arvolla on taipumus yliarvioida kerrointa.
Hyvä ratkaisu tähän ongelmaan on standardoida muuttuja. Standardointi tarkoittaa yhden ja nollan keskihajontaa. Standardointiprosessi sisältää kaksi vaihetta. Ensinnäkin se vähentää muuttujan keskiarvon. Toiseksi, se jakaa keskihajonnalla niin, että jakaumalla on yksikkökeskihajonta.
Kirjasto sklearn on hyödyllinen muuttujien standardoinnissa. Voit käyttää moduulien esikäsittelyä objektiasteikon kanssa tähän tarkoitukseen.
Voit käyttää alla olevaa toimintoa skaalataksesi tietojoukon. Huomaa, että et skaalaa tarrasaraketta ja kategorisisia muuttujia.
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
Voit käyttää toimintoa skaalatun junan/testisarjan muodostamiseen.
df_train_scale = standardize_data(df_train) df_test_scale = standardize_data(df_test)
Perusregressio: Benchmark
Ensinnäkin harjoittelet ja testaat mallia ilman vuorovaikutusta. Tarkoituksena on nähdä mallin suorituskykymittari.
Tapa kouluttaa malli on täsmälleen sama kuin opetusohjelmassa Korkean tason API. Käytät TensorFlow-estimaattoria LinearRegressor.
Muistutuksena sinun on valittava:
- malliin lisättävät ominaisuudet
- muuttaa ominaisuuksia
- rakentaa lineaarinen regressori
- rakentaa input_fn-funktio
- kouluttaa mallia
- testaa mallia
Käytät kaikkia tietojoukon muuttujia mallin kouluttamiseen. Yhteensä on tason jatkuvia muuttujia ja yksi kategorinen muuttuja
## 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']
Voit muuntaa ominaisuudet numeeriseksi sarakkeeksi tai kategoriseksi sarakkeeksi
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'])]
Luot mallin linearRegressorilla. Tallennat mallin kansioon train_Boston
model = tf.estimator.LinearRegressor(
model_dir="train_Boston",
feature_columns=categorical_features + continuous_features)
ulostulo
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}
Jokainen juna- tai testidatan sarake muunnetaan tensoriksi funktiolla get_input_fn
FEATURES = ['CRIM', 'ZN', 'INDUS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD','TAX', 'PTRATIO', 'B', 'LSTAT', 'CHAS']
LABEL= 'PRICE'
def get_input_fn(data_set, num_epochs=None, n_batch = 128, shuffle=True):
return tf.estimator.inputs.pandas_input_fn(
x=pd.DataFrame({k: data_set[k].values for k in FEATURES}),
y = pd.Series(data_set[LABEL].values),
batch_size=n_batch,
num_epochs=num_epochs,
shuffle=shuffle)
Arvioit mallin junatiedoista.
model.train(input_fn=get_input_fn(df_train_scale,
num_epochs=None,
n_batch = 128,
shuffle=False),
steps=1000)
ulostulo
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>
Lopuksi arvioit mallin suorituskykyä testisarjassa
model.evaluate(input_fn=get_input_fn(df_test_scale,
num_epochs=1,
n_batch = 128,
shuffle=False),
steps=1000)
ulostulo
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}
Mallin menetys on 1650. Tämä on mittari, joka voitetaan seuraavassa osiossa
Paranna mallia: Vuorovaikutustermi
Opetusohjelman ensimmäisessä osassa näit mielenkiintoisen suhteen muuttujien välillä. Erilaiset visualisointitekniikat paljastivat, että INDUS ja NOS liittyvät toisiinsa ja käännökset suurentavat vaikutusta hintaan. Ei vain INDUS:n ja NOS:n välinen vuorovaikutus vaikuta hintaan, vaan myös tämä vaikutus on vahvempi, kun se on vuorovaikutuksessa DIS:n kanssa.
On aika yleistää tämä ajatus ja katsoa, voitko parantaa mallin ennustettua mallia.
Sinun on lisättävä jokaiseen tietojoukkoon kaksi uutta saraketta: juna + testi. Tätä varten luot yhden funktion vuorovaikutustermin laskemiseksi ja toisen kolminkertaisen vuorovaikutustermin laskemiseksi. Jokainen funktio tuottaa yhden sarakkeen. Kun uudet muuttujat on luotu, voit ketjuttaa ne harjoitustietojoukkoon ja testitietojoukkoon.
Ensinnäkin sinun on luotava uusi muuttuja INDUS:n ja NOX:n välistä vuorovaikutusta varten.
Alla oleva funktio palauttaa kaksi datakehystä, train ja test, vuorovaikutuksen var_1 ja var_2 välillä, sinun tapauksessasi 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
Tallennat kaksi uutta saraketta
interation_ind_ns_train, interation_ind_ns_test= interaction_term('INDUS', 'NOX', 'INDUS_NOS')
interation_ind_ns_train.shape
(325,)
Toiseksi luot toisen funktion kolminkertaisen vuorovaikutustermin laskemiseksi.
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')
Nyt kun sinulla on kaikki tarvittavat sarakkeet, voit lisätä ne koulutus- ja testaustietojoukkoon. Nimeät nämä kaksi uutta datakehystä:
- 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)
ulostulo
Se on siinä; Voit arvioida uuden mallin vuorovaikutustermeillä ja nähdä, kuinka suorituskykymittari on.
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)
ulostulo
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)
ulostulo
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)
ulostulo
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}
Uusi tappio on 1515. Pelkästään lisäämällä kaksi uutta muuttujaa pystyit pienentämään tappiota. Se tarkoittaa, että voit tehdä paremman ennusteen kuin vertailumallilla.
