Lineaarisen regression opetusohjelma TensorFlow'lla [esimerkkejä]
Evelyn Clarke
Mikä on lineaarinen regressio?
Lineaarinen regressio on tilastollinen lähestymistapa kahden muuttujan välisten suhteiden mallintamiseen. Tämä mallinnus tehdään skalaarivasteen ja yhden tai useamman selittävän muuttujan välillä. Suhdetta yhteen selittävään muuttujaan kutsutaan yksinkertaiseksi lineaariseksi regressioksi ja useamman kuin yhden selittävän muuttujan kohdalla sitä kutsutaan moninkertaiseksi lineaariseksi regressioksi.
TensorFlow tarjoaa työkalut laskelmien täydelliseen hallintaan. Tämä tehdään matalan tason API:lla. Tämän lisäksi TensorFlow on varustettu laajalla valikoimalla API-liittymiä, jotka suorittavat monia koneoppiminen algoritmeja. Tämä on korkean tason API. TensorFlow kutsuu niitä arvioijiksi
- Matalan tason API: Rakenna arkkitehtuuri, mallin optimointi tyhjästä. Se on monimutkaista aloittelijalle
- Korkean tason API: Määritä algoritmi. Se on helppokäyttöinen. TensorFlow tarjoaa työkalupakin nimeltä estimaattori rakentaa, kouluttaa, arvioida ja ennustaa.
Tässä opetusohjelmassa käytät vain arvioijat. Laskelmat ovat nopeampia ja helpompia toteuttaa. Opetusohjelman ensimmäisessä osassa selitetään, kuinka gradientin laskeutumisoptimoijaa käytetään lineaarisen regression harjoittamiseen TensorFlow'ssa. Toisessa osassa käytät Bostonin tietojoukkoa talon hinnan ennustamiseen TensorFlow-estimaattorilla.
Kuinka kouluttaa lineaarista regressiomallia
Ennen kuin alamme harjoitella mallia, katsotaanpa, mikä on lineaarinen regressio.
Kuvittele, että sinulla on kaksi muuttujaa, x ja y, ja sinun tehtäväsi on ennustaa arvon tuntemisen arvo. Jos piirrät tiedot, voit nähdä positiivisen suhteen riippumattoman muuttujan x ja riippuvan muuttujan y välillä.
Voit huomata, että jos x=1,y on suunnilleen yhtä suuri kuin 6 ja jos x=2,y on noin 8.5.
Tämä ei ole kovin tarkka menetelmä ja altis virheille, varsinkin satojatuhansia pisteitä sisältävän tietojoukon kanssa.
Lineaarinen regressio arvioidaan yhtälön avulla. Muuttuja y selitetään yhdellä tai usealla yhteismuuttujalla. Esimerkissäsi on vain yksi riippuvainen muuttuja. Jos sinun on kirjoitettava tämä yhtälö, se on:
Kanssa:
on puolueellisuus. eli jos x=0, y=
on x:ään liittyvä paino
on mallin jäännös tai virhe. Se sisältää sen, mitä malli ei voi oppia tiedoista
Kuvittele, että sovit malliin ja löydät seuraavan ratkaisun:
- = 3.8
- = 2.78
Voit korvata nämä luvut yhtälössä ja siitä tulee:
y = 3.8 + 2.78x
Sinulla on nyt parempi tapa löytää y:n arvot. Eli voit korvata x:n millä tahansa arvolla, jonka haluat ennustaa y:n. Alla olevassa kuvassa olemme korvanneet yhtälön x kaikilla tietojoukon arvoilla ja piirtäneet tuloksen.
Punainen viiva edustaa sovitettua arvoa, eli y:n arvoja jokaiselle x:n arvolle. Sinun ei tarvitse nähdä x:n arvoa ennustaaksesi y:tä, jokaiselle x:lle on mikä tahansa, joka kuuluu punaiseen viivaan. Voit myös ennustaa arvoja x suurempi kuin 2!
Jos haluat laajentaa lineaarista regressiota useammille kovariaateille, voit lisätä malliin enemmän muuttujia. Ero perinteisen analyysin ja lineaarisen regression välillä on se, että lineaarinen regressio tarkastelee, kuinka y reagoi kullekin muuttujalle x itsenäisesti.
Katsotaanpa esimerkkiä. Kuvittele, että haluat ennustaa jäätelökaupan myyntiä. Aineisto sisältää erilaisia tietoja, kuten sää (esim. sateinen, aurinkoinen, pilvinen), asiakastiedot (esim. palkka, sukupuoli, siviilisääty).
Perinteinen analyysi yrittää ennustaa myyntiä esimerkiksi laskemalla kunkin muuttujan keskiarvon ja yrittämällä arvioida myyntiä eri skenaarioissa. Se johtaa huonoihin ennusteisiin ja rajoittaa analyysin valittuun skenaarioon.
Jos käytät lineaarista regressiota, voit kirjoittaa tämän yhtälön:
Algoritmi löytää parhaan ratkaisun painoille; se tarkoittaa, että se yrittää minimoida kustannukset (eron sovitetun viivan ja datapisteiden välillä).
Kuinka algoritmi toimii
Algoritmi valitsee kullekin satunnaisluvun 
ja 
ja korvaa x:n arvo saadaksesi y:n ennustetun arvon. Jos tietojoukossa on 100 havaintoa, algoritmi laskee 100 ennustettua arvoa.
Voimme laskea virheen, huomautti 
mallista, joka on ennustetun arvon ja todellisen arvon välinen ero. Positiivinen virhe tarkoittaa, että malli aliarvioi y:n ennusteen ja negatiivinen virhe tarkoittaa, että malli yliarvioi y:n ennusteen.
Tavoitteesi on minimoida virheen neliö. Algoritmi laskee neliövirheen keskiarvon. Tätä vaihetta kutsutaan virheen minimoimiseksi. Lineaariselle regressiolle on Keskimääräinen neliövirhe, jota kutsutaan myös MSE:ksi. Matemaattisesti se on:
Missä:
onko painot niin 
viittaa ennustettuun arvoon- y on todelliset arvot
- m on havaintojen lukumäärä
viittaa ennustettuun arvoonHuomaa, että 
tarkoittaa, että se käyttää matriisien transponointia. The 
on keskiarvon matemaattinen merkintä.
Tavoitteena on löytää paras 
jotka minimoivat MSE:n
Jos keskimääräinen virhe on suuri, se tarkoittaa, että malli toimii huonosti ja painoja ei ole valittu oikein. Painot korjataksesi sinun on käytettävä optimoijaa. Perinteinen optimoija on ns Kaltevuuslasku.
Gradienttilasku ottaa derivaatan ja vähentää tai lisää painoa. Jos derivaatta on positiivinen, painoa pienennetään. Jos derivaatta on negatiivinen, paino kasvaa. Malli päivittää painot ja laskee virheen uudelleen. Tätä prosessia toistetaan, kunnes virhe ei enää muutu. Jokaista prosessia kutsutaan an iteraatio. Lisäksi gradientit kerrotaan oppimisnopeudella. Se osoittaa oppimisen nopeuden.
Jos oppimisnopeus on liian pieni, kestää hyvin kauan algoritmin konvergoiminen (eli vaatii paljon iteraatioita). Jos oppimisnopeus on liian korkea, algoritmi ei ehkä koskaan lähentyisi.
Yllä olevasta kuvasta näet, että malli toistaa prosessin noin 20 kertaa ennen kuin löytää painoille vakaan arvon, saavuttaen siten alimman virheen.
Huomaa, että, virhe ei ole yhtä suuri kuin nolla, vaan stabiloituu 5:n ympärille. Se tarkoittaa, että malli tekee tyypillisen virheen 5. Jos haluat pienentää virhettä, sinun on lisättävä malliin lisätietoja, kuten enemmän muuttujia tai käytettävä erilaisia estimaattoreita .
Muistat ensimmäisen yhtälön
Lopulliset painot ovat 3.8 ja 2.78. Alla oleva video näyttää, kuinka kaltevuuslasku optimoi häviöfunktion näiden painojen löytämiseksi
Lineaarisen regression harjoittaminen TensorFlow'lla
Nyt kun ymmärrät paremmin, mitä konepellin takana tapahtuu, olet valmis käyttämään TensorFlow'n tarjoamaa estimaattorisovellusliittymää ensimmäisen lineaarisen regression harjoittamiseen TensorFlow'n avulla.
Käytät Bostonin tietojoukkoa, joka sisältää seuraavat muuttujat
| rikos | rikollisuus asukasta kohden kaupungeittain |
|---|---|
| zn | yli 25,000 XNUMX neliömetrin suuruisille tonteille kaavoitetun asuinmaan osuus. |
| Indus | osuus vähittäiskaupan ulkopuolisista eekkeristä 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 välinen suhde kaupungeittain |
| medv | Omistusasuntojen mediaaniarvo tuhansissa dollareissa |
Luot kolme erilaista tietojoukkoa:
| aineisto | tavoite | muoto |
|---|---|---|
| koulutus | Harjoittele mallia ja hanki painot | 400, 10 |
| Arviointi | Arvioi mallin suorituskykyä näkymättömillä tiedoilla | 100, 10 |
| Ennustaa | Käytä mallia talon arvon ennustamiseen uusien tietojen perusteella | 6, 10 |
Tavoitteena on käyttää tietojoukon ominaisuuksia talon arvon ennustamiseen.
Opetusohjelman toisessa osassa opit käyttämään TensorFlow'ta kolmella eri tavalla tietojen tuomiseen:
- Pandan kanssa
- Kanssa Nöpö
- Vain TF
Huomaa, että kaikki vaihtoehdot tarjota samat tulokset.
Opit käyttämään korkean tason API:ta TensorFlow-lineaarisen regressiomallin rakentamiseen ja arvioimiseen. Jos käytit matalan tason APIa, sinun oli määritettävä käsin:
- Tappio-toiminto
- Optimoi: kaltevuuslasku
- Matriisien kertolasku
- Graafi ja tensori
Tämä on työlästä ja monimutkaisempaa aloittelijalle.
Panda
Sinun on tuotava tarvittavat kirjastot mallin kouluttamiseksi.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Vaihe 1) Tuo tiedot sovelluksella panda.
Määrität sarakkeiden nimet ja tallennat ne COLUMNS-kansioon. Voit tuoda tiedot komennolla pd.read_csv().
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]
training_set = pd.read_csv("E:/boston_train.csv", skipinitialspace=True,skiprows=1, names=COLUMNS)
test_set = pd.read_csv("E:/boston_test.csv", skipinitialspace=True,skiprows=1, names=COLUMNS)
ennustusjoukko = pd.read_csv("E:/boston_predict.csv", skipinitialspace=True,skiprows=1, names=COLUMNS)
Voit tulostaa tietojen muodon.
print(training_set.shape, test_set.shape, prediction_set.shape)
ulostulo
(400, 10) (100, 10) (6, 10)
Huomaa, että tunniste eli y-kirjaimesi sisältyy tietojoukkoon. Joten sinun on määritettävä kaksi muuta luetteloa. Yksi sisältää vain ominaisuudet ja toinen vain tunnisteen nimen. Nämä kaksi luetteloa kertovat arvioijallesi, mitkä ovat tietojoukon ominaisuudet ja mikä sarakkeen nimi on tunniste
Se tehdään alla olevalla koodilla.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Vaihe 2) Muunna tiedot
Sinun on muunnettava numeeriset muuttujat oikeaan muotoon. Tensorflow tarjoaa menetelmän jatkuvan muuttujan muuntamiseksi: tf.feature_column.numeric_column().
Edellisessä vaiheessa määrität luettelon ominaisuuksista, jotka haluat sisällyttää malliin. Nyt voit käyttää tätä luetteloa muuntaaksesi ne numeerisiksi tiedoiksi. Jos haluat sulkea pois ominaisuuksia mallistasi, pudota vapaasti yksi tai useampi muuttuja luettelosta OMINAISUUDET, ennen kuin muodostat ominaisuuden_cols.
Huomaa, että käytät Python luettelon ymmärtäminen luettelon OMINAISUUDET avulla luodaksesi uuden luettelon nimeltä feature_cols. Se auttaa välttämään kirjoittamista yhdeksän kertaa tf.feature_column.numeric_column(). Listan ymmärtäminen on nopeampi ja selkeämpi tapa luoda uusia luetteloita
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Vaihe 3) Määrittele estimaattori
Tässä vaiheessa sinun on määritettävä estimaattori. Tensorflow tarjoaa tällä hetkellä kuusi valmiiksi rakennettua estimaattoria, joista 6 luokitustehtävää varten ja 3 TensorFlow-regressiotehtävää varten:
- Regressori
- DNNRegressor
- Lineaarinen regressori
- DNNLineaCombinedRegressor
- luokittelija
- DNNC-luokitus
- Lineaarinen luokitin
- DNNLineaCombinedClassifier
Tässä opetusohjelmassa käytät lineaarista regressoria. Voit käyttää tätä toimintoa käyttämällä tf.estimator-ohjelmaa.
Funktio tarvitsee kaksi argumenttia:
- feature_columns: Sisältää malliin sisällytettävät muuttujat
- model_dir: polku kaavion tallentamiseen, mallin parametrien tallentamiseen jne
Tensorflow luo automaattisesti tiedoston nimeltä train työhakemistoosi. Sinun on käytettävä tätä polkua päästäksesi Tensorboardiin alla olevan TensorFlow-regressioesimerkin mukaisesti.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_cols,
model_dir="train")
ulostulo
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train', '_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 0x1a215dc550>, '_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}
TensorFlow'n hankala osa on tapa ruokkia mallia. Tensorflow on suunniteltu toimimaan rinnakkaislaskennan ja erittäin suuren tietojoukon kanssa. Koneen resurssien rajallisuuden vuoksi on mahdotonta syöttää malliin kaikkia tietoja kerralla. Tätä varten sinun on syötettävä joukko tietoja joka kerta. Huomaa, että puhumme valtavasta tietojoukosta, jossa on miljoonia tai enemmän tietueita. Jos et lisää erää, päädyt muistivirheeseen.
Jos tietosi sisältävät esimerkiksi 100 havaintoa ja määrität eräkoon 10, se tarkoittaa, että malli näkee 10 havaintoa jokaisessa iteraatiossa (10*10).
Kun malli on nähnyt kaikki tiedot, se viimeistelee yhden aikakausi. Epookki määrittää, kuinka monta kertaa haluat mallin näkevän tiedot. On parempi asettaa tämän vaiheen arvoksi ei mitään ja antaa mallin suorittaa iteraatioiden lukumäärän.
Toinen lisättävä tieto on, jos haluat sekoittaa tiedot ennen jokaista iteraatiota. Harjoittelun aikana on tärkeää sekoittaa dataa, jotta malli ei opi tietojoukon tiettyä mallia. Jos malli oppii datan taustalla olevan mallin yksityiskohdat, sillä on vaikeuksia yleistää näkymätön datan ennustetta. Tätä kutsutaan liikaa. Malli toimii hyvin harjoitusdatalla, mutta ei voi ennustaa oikein näkymättömille tiedoille.
TensorFlow tekee näistä kahdesta vaiheesta helppoa. Kun data menee liukuhihnaan, se tietää kuinka monta havaintoa se tarvitsee (erä) ja jos sen täytyy sekoittaa dataa.
Voit opastaa Tensorflowa mallin syöttämisessä käyttämällä pandas_input_fn. Tämä objekti tarvitsee 5 parametria:
- x: ominaisuustiedot
- y: etikettitiedot
- eräkoko: erä. Oletuksena 128
- num_epoch: Epookkien lukumäärä, oletuksena 1
- shuffle: Sekoita tai älä sekoita tietoja. Oletuksena Ei mitään
Sinun on syötettävä mallia useita kertoja, jotta voit määrittää funktion tämän prosessin toistamiseksi. kaikki tämä funktio get_input_fn.
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)
Tavallinen menetelmä mallin suorituskyvyn arvioimiseksi on:
- Harjoittele mallia
- Arvioi malli eri tietojoukossa
- Tee ennustus
Tensorflow-estimaattori tarjoaa kolme erilaista toimintoa näiden kolmen vaiheen suorittamiseksi helposti.
Vaihe 4): Kouluta mallia
Voit käyttää estimaattorijunaa mallin arvioimiseen. Junaestimaattori tarvitsee input_fn ja useita vaiheita. Voit käyttää yllä luomaasi toimintoa mallin syöttämiseen. Sitten ohjeistat mallia iteroimaan 1000 kertaa. Huomaa, että et määritä aikakausien määrää, annat mallin iteroitua 1000 kertaa. Jos asetat epookkien lukumääräksi 1, malli toistuu 4 kertaa: Harjoitussarjassa on 400 tietuetta ja eräkoko on 128
- 128-rivit
- 128-rivit
- 128-rivit
- 16-rivit
Siksi on helpompi asettaa epookkien lukumääräksi ei mitään ja määrittää iteraatioiden lukumäärä alla olevan TensorFlow-luokitusesimerkin mukaisesti.
estimator.train(input_fn=get_input_fn(training_set,
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/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 238.616 INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec) INFO:tensorflow:global_step/sec: 314.293 INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec) INFO:tensorflow:global_step/sec: 303.863 INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec) INFO:tensorflow:global_step/sec: 308.782 INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec) INFO:tensorflow:global_step/sec: 244.969 INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec) INFO:tensorflow:global_step/sec: 155.966 INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec) INFO:tensorflow:global_step/sec: 263.256 INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec) INFO:tensorflow:global_step/sec: 254.112 INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec) INFO:tensorflow:global_step/sec: 292.405 INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec) INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873.
Voit tarkistaa Tensorboardin seuraavan komennon:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Vaihe 5) Arvioi mallisi
Voit arvioida mallisi sopivuuden testisarjaan alla olevalla koodilla:
ev = estimator.evaluate(
input_fn=get_input_fn(test_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
ulostulo
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
Voit tulostaa tappion alla olevalla koodilla:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
ulostulo
Loss: 3215.895996
Mallin häviö on 3215. Yhteenvetotilastosta saat käsityksen virheen suuruudesta.
training_set['medv'].describe()
ulostulo
count 400.000000 mean 22.625500 std 9.572593 min 5.000000 25% 16.600000 50% 21.400000 75% 25.025000 max 50.000000 Name: medv, dtype: float64
Yllä olevasta yhteenvetotilastosta tiedät, että asunnon keskihinta on 22 tuhatta, minimihinta 9 tuhatta ja maksimi 50 tuhatta. Malli tekee tyypillisen 3k dollarin virheen.
Vaihe 6) Tee ennustus
Lopuksi voit käyttää estimaattoria TensorFlow ennustaa arvioidaksesi 6 Bostonin talon arvon.
y = estimator.predict(
input_fn=get_input_fn(prediction_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Voit tulostaa arvioidut arvot käyttämällä tätä koodia:
predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))
ulostulo
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]
Malli ennustaa seuraavat arvot:
| Talo | Ennustus | |
|---|---|---|
| 1 | 32.29 | |
| 2 | 18.96 | |
| 3 | 27.27 | |
| 4 | 29.29 | |
| 5 | 16.43 | |
| 7 | 21.46 |
Huomaa, että emme tiedä todellista arvoa. Syväoppimisen opetusohjelmassa yrität voittaa lineaarisen mallin
Numpy ratkaisu
Tässä osiossa kerrotaan, kuinka mallia koulutetaan käyttämällä numpy-estimaattoria tietojen syöttämiseen. Menetelmä on sama, paitsi että käytät numpy_input_fn estimaattoria.
training_set_n = pd.read_csv("E:/boston_train.csv").arvot
test_set_n = pd.read_csv("E:/boston_test.csv").arvot
ennustus_set_n = pd.read_csv("E:/boston_predict.csv").arvot
Vaihe 1) Tuo tiedot
Ensinnäkin sinun on erotettava ominaisuusmuuttujat etiketistä. Sinun on tehtävä tämä harjoitustietoja ja arviointia varten. On nopeampaa määrittää funktio datan jakamiseksi.
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
Voit käyttää toimintoa jakaaksesi tarran juna/arvioi tietojoukon ominaisuuksista
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Sinun on suljettava pois ennustetietojoukon viimeinen sarake, koska se sisältää vain NaN
x_predict = prediction_set_n[:, :-2]
Vahvista taulukon muoto. Huomaa, että tarralla ei saa olla mittaa, se tarkoittaa (400,).
print(X_train.shape, y_train.shape, x_predict.shape)
ulostulo
(400, 9) (400,) (6, 9)
Voit rakentaa ominaisuussarakkeet seuraavasti:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Estimaattori on määritelty kuten ennenkin, ohjeistat ominaisuussarakkeet ja mihin kuvaaja tallennetaan.
estimator = tf.estimator.LinearRegressor(
feature_columns=feature_columns,
model_dir="train1")
ulostulo
INFO:tensorflow:Using default config.
INFO:tensorflow:Using config: {'_model_dir': 'train1', '_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 0x1a218d8f28>, '_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}
Voit käyttää numpy estimaporia syöttämään tiedot mallille ja kouluttamaan mallia. Huomaa, että määritämme input_fn-funktion ennen luettavuuden helpottamiseksi.
# Train the estimatortrain_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_train},
y=y_train,
batch_size=128,
shuffle=False,
num_epochs=None)
estimator.train(input_fn = train_input,steps=5000)
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 train1/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 490.057 INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec) INFO:tensorflow:global_step/sec: 788.986 INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec) INFO:tensorflow:global_step/sec: 736.339 INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec) INFO:tensorflow:global_step/sec: 383.305 INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec) INFO:tensorflow:global_step/sec: 859.832 INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec) INFO:tensorflow:global_step/sec: 804.394 INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec) INFO:tensorflow:global_step/sec: 753.059 INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec) INFO:tensorflow:global_step/sec: 402.165 INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec) INFO:tensorflow:global_step/sec: 344.022 INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec) INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt. INFO:tensorflow:Loss for final step: 5925.985. Out[23]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>
Toistat saman vaiheen eri estimaattorilla mallin arvioimiseksi
eval_input = tf.estimator.inputs.numpy_input_fn(
x={"x": X_test},
y=y_test,
shuffle=False,
batch_size=128,
num_epochs=1)
estimator.evaluate(eval_input,steps=None)
ulostulo
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}
Lopuksi voit laskea ennusteen. Sen pitäisi olla samanlainen kuin pandat.
test_input = tf.estimator.inputs.numpy_input_fn(
x={"x": x_predict},
batch_size=128,
num_epochs=1,
shuffle=False)
y = estimator.predict(test_input)
predictions = list(p["predictions"] for p in itertools.islice(y, 6))
print("Predictions: {}".format(str(predictions)))
ulostulo
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]
Tensorflow ratkaisu
Viimeinen osa on omistettu TensorFlow-ratkaisulle. Tämä menetelmä on hieman monimutkaisempi kuin toinen.
Huomaa, että jos käytät Jupyter muistikirja, sinun täytyy käynnistää uudelleen ja puhdistaa ydin suorittaaksesi tämän istunnon.
TensorFlow on rakentanut loistavan työkalun tietojen siirtämiseen putkistoon. Tässä osiossa rakennat input_fn-funktion itse.
Vaihe 1) Määritä tietojen polku ja muoto
Ensinnäkin määrität kaksi muuttujaa csv-tiedoston polulla. Huomaa, että sinulla on kaksi tiedostoa, yksi harjoitussarjaa ja toinen testaussarjaa varten.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Sitten sinun on määritettävä sarakkeet, joita haluat käyttää csv-tiedostosta. Käytämme kaikki. Tämän jälkeen sinun on ilmoitettava muuttujan tyyppi.
Float-muuttuja määritellään [0.]
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age",
"dis", "tax", "ptratio", "medv"]RECORDS_ALL = [[0.0], [0.0], [0.0], [0.0],[0.0],[0.0],[0.0],[0.0],[0.0],[0.0]]
Vaihe 2) Määritä input_fn-funktio
Funktio voidaan jakaa kolmeen osaan:
- Tuo tiedot
- Luo iteraattori
- Käytä dataa
Alla on yleiskoodi funktion määrittelemiseksi. Koodi selitetään myöhemmin
def input_fn(data_file, batch_size, num_epoch = None):
# Step 1
def parse_csv(value):
columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)
features = dict(zip(COLUMNS, columns))
#labels = features.pop('median_house_value')
labels = features.pop('medv')
return features, labels
# Extract lines from input files using the
Dataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file
.skip(1) # Skip header row
.map(parse_csv))
dataset = dataset.repeat(num_epoch)
dataset = dataset.batch(batch_size)
# Step 3
iterator = dataset.make_one_shot_iterator()
features, labels = iterator.get_next()
return features, labels
** Tuo tiedot**
Csv-tiedostossa tietojoukkomenetelmä lukee yhden rivin kerrallaan. Tietojoukon rakentamiseksi sinun on käytettävä objektia TextLineTietojoukko. Tietojoukossasi on otsikko, joten sinun on käytettävä skip(1)-komentoa ohittaaksesi ensimmäinen rivi. Tässä vaiheessa luet vain tiedot ja suljet pois liukuhihnan otsikon. Syöttääksesi mallin, sinun on erotettava ominaisuudet tarrasta. Menetelmä, jota käytetään minkä tahansa muunnoksen soveltamiseen dataan, on kartta.
Tämä menetelmä kutsuu funktiota, jonka luot ohjeiden muuntamista varten. Lyhyesti sanottuna sinun on välitettävä tiedot TextLineTietojoukkoobjekti, jätä pois otsikko ja käytä muunnos, jota funktio ohjaa.Koodin selitys
- tf.data.TextLineDataset(data_file): Tämä rivi lukee csv-tiedoston
- .skip(1) : ohittaa otsikon
- .map(parse_csv)): jäsentää tietueet tensoreihinSinun on määritettävä funktio, joka ohjaa karttaobjektia. Voit kutsua tätä funktiota parse_csv.
Tämä funktio jäsentää csv-tiedoston menetelmällä tf.decode_csv ja ilmoittaa ominaisuudet ja tunnisteen. Ominaisuudet voidaan ilmoittaa sanakirjana tai monikkona. Käytät sanakirjamenetelmää, koska se on kätevämpää.Koodin selitys
- tf.decode_csv(arvo, record_defaults= RECORDS_ALL): menetelmä decode_csv käyttää TextLineTietojoukko csv-tiedoston lukemiseen. record_defaults opastaa TensorFlow'ta sarakkeiden tyypistä.
- dict(zip(_CSV_COLUMNS, columns)): täytä sanakirja kaikilla tämän tietojenkäsittelyn aikana puretuilla sarakkeilla
- features.pop('median_house_value'): Sulje kohdemuuttuja pois ominaisuusmuuttujasta ja luo tunnistemuuttuja
Tietojoukko tarvitsee lisäelementtejä syöttääkseen tensorit iteratiivisesti. Itse asiassa sinun on lisättävä menetelmän toisto, jotta tietojoukko voi jatkaa mallin syöttämistä loputtomiin. Jos et lisää menetelmää, malli toistuu vain kerran ja antaa sitten virheilmoituksen, koska prosessissa ei syötetä enempää dataa.
Sen jälkeen voit hallita eräkokoa erämenetelmällä. Se tarkoittaa, että kerrot tietojoukolle, kuinka monta dataa haluat siirtää liukuhihnassa kullekin iteraatiolle. Jos asetat suuren eräkoon, malli on hidas.
Vaihe 3) Luo iteraattori
Nyt olet valmis toiseen vaiheeseen: luo iteraattori palauttamaan tietojoukon elementit.
Yksinkertaisin tapa luoda operaattori on menetelmä make_one_shot_iterator.
Tämän jälkeen voit luoda ominaisuuksia ja tunnisteita iteraattorista.
Vaihe 4) Käytä tiedot
Voit tarkistaa, mitä tapahtuu input_fn-funktiolla. Sinun on kutsuttava toiminto istunnon aikana kuluttaaksesi dataa. Kokeile niin, että erän koko on 1.
Huomaa, että se tulostaa sanakirjan ominaisuudet ja tarran taulukkona.
Se näyttää csv-tiedoston ensimmäisen rivin. Voit yrittää suorittaa tämän koodin useita kertoja eri koolla.
next_batch = input_fn(df_train, batch_size = 1, num_epoch = None)
with tf.Session() as sess:
first_batch = sess.run(next_batch)
print(first_batch)
ulostulo
({'crim': array([2.3004], dtype=float32), 'zn': array([0.], dtype=float32), 'indus': array([19.58], dtype=float32), 'nox': array([0.605], dtype=float32), 'rm': array([6.319], dtype=float32), 'age': array([96.1], dtype=float32), 'dis': array([2.1], dtype=float32), 'tax': array([403.], dtype=float32), 'ptratio': array([14.7], dtype=float32)}, array([23.8], dtype=float32))
Vaihe 4) Määritä ominaisuussarake
Sinun on määritettävä numeeriset sarakkeet seuraavasti:
X1= tf.feature_column.numeric_column('crim')
X2= tf.feature_column.numeric_column('zn')
X3= tf.feature_column.numeric_column('indus')
X4= tf.feature_column.numeric_column('nox')
X5= tf.feature_column.numeric_column('rm')
X6= tf.feature_column.numeric_column('age')
X7= tf.feature_column.numeric_column('dis')
X8= tf.feature_column.numeric_column('tax')
X9= tf.feature_column.numeric_column('ptratio')
Huomaa, että sinun on yhdistettävä kaikki muuttujat ämpäriin
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Vaihe 5) Rakenna malli
Voit harjoitella mallia estimaattorilla LinearRegressor.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
ulostulo
INFO:tensorflow:Using default config. INFO:tensorflow:Using config: {'_model_dir': 'train3', '_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 0x1820a010f0>, '_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}
Sinun on käytettävä lambda-funktiota, jotta voit kirjoittaa argumentin funktioon inpu_fn. Jos et käytä a lambda -toiminto, et voi kouluttaa mallia.
# Train the estimatormodel.train(steps =1000,
input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
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 train3/model.ckpt. INFO:tensorflow:loss = 83729.64, step = 1 INFO:tensorflow:global_step/sec: 72.5646 INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec) INFO:tensorflow:global_step/sec: 101.355 INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec) INFO:tensorflow:global_step/sec: 109.293 INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec) INFO:tensorflow:global_step/sec: 102.235 INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec) INFO:tensorflow:global_step/sec: 104.656 INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec) INFO:tensorflow:global_step/sec: 106.697 INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec) INFO:tensorflow:global_step/sec: 118.454 INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec) INFO:tensorflow:global_step/sec: 114.947 INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec) INFO:tensorflow:global_step/sec: 111.484 INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec) INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873. Out[8]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>
Voit arvioida mallisi sopivuuden testisarjaan alla olevalla koodilla:
results = model.evaluate(steps =None,input_fn=lambda: input_fn(df_eval, batch_size =128, num_epoch = 1))
for key in results:
print(" {}, was: {}".format(key, results[key]))
ulostulo
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896 average_loss, was: 32.158958435058594 loss, was: 3215.89599609375 global_step, was: 1000
Viimeinen vaihe on arvon ennustaminen ominaisuuden matriisien arvon perusteella. Voit kirjoittaa sanakirjan arvoilla, jotka haluat ennustaa. Mallissasi on 9 ominaisuutta, joten sinun on annettava arvo jokaiselle. Malli tarjoaa ennusteen jokaiselle niistä.
Alla olevaan koodiin kirjoitit kunkin df_predict csv-tiedoston sisältämien ominaisuuksien arvot.
Sinun on kirjoitettava uusi input_fn-funktio, koska tietojoukossa ei ole tunnistetta. Voit käyttää API from_tensor tietojoukosta.
prediction_input = {
'crim': [0.03359,5.09017,0.12650,0.05515,8.15174,0.24522],
'zn': [75.0,0.0,25.0,33.0,0.0,0.0],
'indus': [2.95,18.10,5.13,2.18,18.10,9.90],
'nox': [0.428,0.713,0.453,0.472,0.700,0.544],
'rm': [7.024,6.297,6.762,7.236,5.390,5.782],
'age': [15.8,91.8,43.4,41.1,98.9,71.7],
'dis': [5.4011,2.3682,7.9809,4.0220,1.7281,4.0317],
'tax': [252,666,284,222,666,304],
'ptratio': [18.3,20.2,19.7,18.4,20.2,18.4]
}
def test_input_fn():
dataset = tf.data.Dataset.from_tensors(prediction_input)
return dataset
# Predict all our prediction_inputpred_results = model.predict(input_fn=test_input_fn)
Lopuksi tulostat ennusteet.
for pred in enumerate(pred_results): print(pred)
ulostulo
INFO:tensorflow:Calling model_fn.
INFO:tensorflow:Done calling model_fn.
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})
Yhteenveto
Mallin kouluttamiseksi sinun on:
- Määrittele ominaisuudet: Riippumattomat muuttujat: X
- Määrittele tunniste: Riippuva muuttuja: y
- Rakenna juna/koesarja
- Määritä alkuperäinen paino
- Määritä häviöfunktio: MSE
- Optimoi malli: Gradienttilasku
- Määritellä:
- Oppimisnopeus
- Epookin lukumäärä
- Erän koko
Tässä opetusohjelmassa opit käyttämään korkean tason API:ta lineaarisen regression TensorFlow-estimaattorissa. Sinun on määritettävä:
- Ominaisuussarakkeet. Jos jatkuva: tf.feature_column.numeric_column(). Voit täyttää luettelon python-luetteloiden ymmärtämisellä
- Estimaattori: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Funktio, jolla tuodaan tiedot, erän koko ja aikakausi: input_fn()
Sen jälkeen olet valmis harjoittelemaan, arvioimaan ja tekemään ennusteita train(), arvioi() ja ennusta()
