TensorFlow Lineaarinen regressio fasetilla ja vuorovaikutustermillä

TensorFlow-lineaarinen regressio

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:

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.

Sama estimaattoriperhe käyttää myös lineaarinen luokittelija kun otsikko on luokka eikä hinta. Tässä opetusohjelmassa yritämme nähdä, mitkä muuttujat voivat olla hyviä ehdokkaita vuorovaikutustermeiksi. Testaamme, johtaako tällaisen tiedon lisääminen parempaan hintaennusteeseen.

Tiivistelmätilastot

Ennen mallinnukseen siirtymistä on muutamia vaiheita, joita voit seurata. Kuten aiemmin mainittiin, malli on datan yleistys. Paras käytäntö on ymmärtää data ensin ja tehdä ennuste vasta sitten. Jos et tunne dataasi, sinulla on vain vähän mahdollisuuksia parantaa malliasi.

Ensimmäisenä vaiheena lataa tiedot panda-tietokehyksenä ja luo harjoitussarja ja testaussarja.

Vinkkejä: Tätä tutoriaalia varten sinulla on oltava matplotlib ja seaborn asennettuna PythonVoit 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 PythonSeaborn on matplotlibin päälle rakennettu tilastollinen visualisointikirjasto. Se tarjoaatracvetäviä ja kauniita juonia.

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.

Versiohuomautus: load_boston oli vanhentunut scikit-learn 1.0:ssa ja poistettu scikit-learn 1.2:sta koska tietojoukko koodaa rodullisesti ladatun ominaisuuden. Käytä nykyisessä asennuksessa noutaa_kalifornian_asuntoja sen sijaan tai lataa raakatiedosto itse. Alla oleva työnkulku pysyy muuttumattomana; vain latausohjelma eroaa.

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

Ominaisuuksien nimet tallennetaan feature_names-objektiin taulukkona.

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 siinä on sisäänrakennettu näytteenottofunktio datakehyksen jakamiseksi.

Ensimmäinen parametri frac on arvo 0-1. Asetat sen arvoon 0.8 valitaksesi satunnaisesti 80 prosenttia tietokehyksestä.

random_state korjaa sekoituksen, joten samat rivit palautetaan 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

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

Google Tutkimusryhmä on kehittänyt tähän tehtävään työkalun nimeltä Facets joka auttaa sinua visualisoimaan dataa ja jakamaan sitä monin eri tavoin. Tämä on hyvä lähtökohta datajoukon asettelun ymmärtämiselle.

Fasettien avulla voit löytää kohdat, joissa data ei aivan näytä odottamaltasi.

Paitsi heidän verkkosovellustaan, Google helpottaa työkalupakin upottamista 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

1. puuttuvien havaintojen prosenttiosuus
2. min ja max arvot
3. tilastot, kuten keskiarvo, mediaani ja keskihajonta.
4. Se lisää myös sarakkeen, joka näyttää nollien prosenttiosuuden, mikä on hyödyllistä, kun suurin osa arvoista on nollia.
5. 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

Fasettien syväsukellus on hieno työkalu. Sen avulla voit selventää datajoukkoasi ja zoomata kokonaan nähdäksesi yksittäisen datan osan. Se tarkoittaa, että voit fasetoida dataa rivi- ja sarakekohtaisesti minkä tahansa datajoukon ominaisuuden osalta.

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.

Ennen kuin kumpaakaan työkalua voidaan käyttää, Facets on asennettava kannettavaan ympäristöön.

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 koneellasi ei ole Gitiä asennettuna, siirry tähän URL Git for Windows ladata sivu 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 PAIR-koodi/fasettivarasto ja lataa arkistot.

Yllä olevalla arkistosivulla on vaihtoehdon 2 käyttämä latauspainike. Jos valitset ensimmäisen vaihtoehdon, tiedosto päätyy latauskansioosi. Voit joko antaa tiedoston latautua 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.

Yllä oleva pääteikkuna vahvistaa, että fasetit sijaitsevat nykyisessä työhakemistossa. 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:

jupyter nbextension install facets-dist/

Muussa tapauksessa käytä:

jupyter nbextension install facets-dist/ --user

Selvä, olet valmis. Avataan Facet Overview.

Suorita fasettien yleiskatsaus Jupyter

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

Korrelaatiokaavio ja pariruudukko

Kun olet tarkistanut tiedot ja niiden jakauman, voit piirtää korrelaatiomatriisin. Korrelaatiomatriisi laskee Pearsonin kertoimen. Tämä kerroin on rajoitettu välille -1 ja 1, jossa positiivinen arvo osoittaa positiivista korrelaatiota ja negatiivinen arvo negatiivista korrelaatiota.

Olet kiinnostunut näkemään, mitkä muuttujat voivat olla hyviä vuorovaikutustermejä.

Versiohuomautus: alla oleva naamio kutsuu np.bool, alias, joka vanhentui NumPy 1.20:ssa ja poistettu NumPy 1.24:ssäViimeaikaisessa NumPy-komennossa sama rivi aiheuttaa AttributeError: module 'numpy' has no attribute 'bool'sisäänrakennettu bool on drop-in-korvaaja.

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

Yllä olevassa lämpökartassa tummemmat neliöt merkitsevät vahvempia korrelaatioita. Matriisista näet:

• LSTAT
• RM

Korreloivat voimakkaasti PRICE:n kanssa. Toinen mielenkiintoinen ominaisuus on NOX:n ja INDUS:n välinen vahva positiivinen korrelaatio, mikä tarkoittaa, että nämä kaksi muuttujaa liikkuvat samaan suuntaan. Molemmat korreloivat myös PRICE:n kanssa. DIS korreloi myös voimakkaasti INDUS:n ja NOX:n kanssa.

Sinulla on ensimmäinen vihje siitä, että INDUS ja NOX voivat olla hyviä ehdokkaita vuorovaikutustermiksi, ja myös DIS voisi olla kiinnostava tutkimuskohde.

Voit mennä hieman syvemmälle piirtämällä pariruudukon. Se havainnollistaa yksityiskohtaisemmin aiemmin piirtämääsi korrelaatiokarttaa.

Pariverkko muodostuu seuraavasti:

• Yläosa: Hajakuvaaja sovitetulla viivalla
• Diagonaali: Ytimen tiheyskäyrä
• Alaosa: Monimuuttuja ytimen tiheyskaavio

Keskityt neljään riippumattomaan muuttujaan. Valintasi 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 PRICE:n välillä on pieni epälineaarisuus
• 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 työkalua, jonka on luonut Google, Fasettien syvällinen analyysi. Käyttöliittymä on jaettu neljään pääosaan. Keskellä oleva keskialue on zoomattava datanäyttö. Paneelin yläosassa on avattava valikko, josta voit muuttaa datan järjestystä ja hallita fasetointia, sijaintia ja väriä. Oikealla puolella on yksityiskohtainen näkymä tietystä datarivistä. Tämä tarkoittaa, että voit napsauttaa mitä tahansa datapistettä keskimmäisessä visualisoinnissa nähdäksesi kyseisen datapisteen tiedot.

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. Toisin sanoen voimme luoda 2D-kuvaajan ja värittää pisteet. Voit jakaa PRICE-muuttujan neljään luokkaan, joista jokainen on kvartiili (eli 0.25, 0.5, 0.75). Kutsut tätä uutta muuttujaa Q_PRICE:ksi.

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

Fasettien käytön syvällinen tarkastelu

Syväsukelluksen avaamiseksi sinun on muunnettava data json-muotoon. Pandasilla on tähän metodi: kutsu to_json-metodia DataFramessa.

Ensimmäinen koodirivi asettaa spritin koon sen mukaan, kuinka monta riviä datasetissä 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')

Alla oleva koodi on peräisin Google GitHub. 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="/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övoimakeskukseen on suurempi.

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.

Tutkimus on tuottanut kaksi mahdollista vuorovaikutusta, joten seuraava vaihe on testata niitä todellisessa mallissa.

Lineaarinen regressio TensorFlow'n kanssa

Tässä osiossa arvioit lineaarista regressiomallia, jossa TensorFlow Estimaattori-API. Jatka seuraavasti:

• Valmistele tiedot
• Arvioi vertailumalli: Ei vuorovaikutusta
• Arvioi malli, jossa on vuorovaikutusta

Versiohuomautus: Ishayoiden opettaman tf-estimator paketti toimitettiin lopullisessa versiossaan TensorFlow 2.15:n mukana ja puuttuu TensorFlow 2.16:sta ja uudemmista versioista, joten tf.estimator.LinearRegressor toimii vain TensorFlow 1.x:ssä, ellet siirrä sitä Keras-lineaarimalliin.

Muista, että koneoppimisen tavoitteena on minimoida virhe. Tässä tapauksessa malli, jolla on pienin keskimääräinen neliövirhe, voittaa. TensorFlow-estimaattori laskee tämän mittarin automaattisesti.

Valmistelutiedot

Useimmissa tapauksissa dataa on muunnettava. Siksi Fasettien yleiskatsaus on kiehtova. Yhteenvetotilastosta näit, että siinä on poikkeamia. Nämä arvot vaikuttavat arvioihin, koska ne eivät näytä analysoitavalta populaatiolta. Poikkeavat arvot yleensä vääristävät tuloksia. Esimerkiksi positiivinen poikkeava arvo pyrkii yliarvioimaan kerrointa.

Hyvä ratkaisu tähän ongelmaan on muuttujan standardointi. Standardointi tarkoittaa yhden keskihajontaa ja nollan keskiarvoa. Standardointiprosessiin kuuluu kaksi vaihetta. Ensinnäkin setracts on muuttujan keskiarvo. Toiseksi se jakaa keskihajonnalla siten, että jakauman keskihajonta on yksi.

Kirjasto scikit opittava on hyödyllinen muuttujien standardoinnissa. Voit käyttää tähän tarkoitukseen moduulin esikäsittelyä objektin skaalauksella.

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.

Mallin kouluttaminen tapahtuu täsmälleen samalla tavalla 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 kaksitoista jatkuvaa muuttujaa 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.9785. Tämä on mittari, joka voitetaan seuraavassa osiossa

Paranna mallia: Vuorovaikutustermi

Tutoriaalin ensimmäisessä osassa näit mielenkiintoisen suhteen muuttujien välillä. Eri visualisointitekniikat paljastivat, että INDUS ja NOX ovat yhteydessä toisiinsa ja voimistavat toistensa vaikutusta hintaan. INDUSin ja NOXin välinen vuorovaikutus ei ainoastaan ​​vaikuta hintaan, vaan tämä vaikutus on myös voimakkaampi, kun se on vuorovaikutuksessa DISin kanssa.

On aika yleistää tämä ajatus ja katsoa, ​​voidaanko mallin ennustusta parantaa.

Sinun on lisättävä jokaiseen tietojoukkoon kaksi uutta saraketta: train ja test. Tätä varten luot yhden funktion vuorovaikutustermin laskemiseksi ja toisen kolmoisvuorovaikutustermin laskemiseksi. Jokainen funktio tuottaa yhden sarakkeen. Kun uudet muuttujat on luotu, voit yhdistää 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

Siinä kaikki: voit arvioida uuden mallin vuorovaikutustermien avulla ja nähdä, miten 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.9863. Pelkästään lisäämällä kaksi uutta muuttujaa pystyit pienentämään tappiota. Se tarkoittaa, että voit tehdä paremman ennusteen kuin vertailumallilla.

Molemmat luvut ovat peräisin samasta 101-rivisestä testijaosta, joten noin 8 prosentin lasku keskimääräisessä tappiossa johtuu pelkästään kahdesta vuorovaikutussarakkeesta.

UKK