Lineaarinen regressio TensorFlow-tekniikalla (esimerkkejä)

Sisällysluettelo:

Anonim

Mikä on lineaarinen regressio?

Lineaarinen regressio on tilastollinen lähestymistapa kahden muuttujan välisten suhteiden mallintamiseen. Tämä mallinnus tehdään skalaarisen vasteen ja yhden tai useamman selittävän muuttujan välillä. Suhdetta yhden selittävän muuttujan kanssa kutsutaan yksinkertaiseksi lineaariseksi regressioksi ja useammalle kuin yhdelle selittävälle muuttujalle sitä kutsutaan monilinjaiseksi 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 joukolla sovellusliittymiä suorittamaan monia koneoppimisalgoritmeja. Tämä on korkean tason sovellusliittymä. TensorFlow kutsuu heitä arvioijiksi

  • Matalan tason sovellusliittymä: Rakenna arkkitehtuuri, mallin optimointi tyhjästä. Se on monimutkaista aloittelijoille
  • Korkean tason sovellusliittymä: Määritä algoritmi. Se on helpompaa. TensorFlow tarjoaa työkalupuheluiden estimaattorin rakentamaan, kouluttamaan, arvioimaan ja tekemään ennusteen.

Tässä opetusohjelmassa käytetään vain arvioita . Laskelmat ovat nopeampi ja helpompi toteuttaa. Opetusohjelman ensimmäisessä osassa kerrotaan, kuinka kaltevuuslaskun optimoijaa voidaan käyttää lineaarisen regressioon kouluttamiseen TensorFlow-ohjelmassa. Toisessa osassa voit ennustaa talon hinnan Bostonin tietojoukon avulla TensorFlow-estimaattorilla.

Lataa Boston DataSet

Tässä TensorFlow Regression -opetusohjelmassa opit:

  • Mikä on lineaarinen regressio?
  • Kuinka kouluttaa lineaarista regressiomallia
  • Kuinka kouluttaa lineaarista regressiota TensorFlow: lla
  • Pandat
  • Numpy ratkaisu
  • Tensorflow-liuos

Kuinka kouluttaa lineaarista regressiomallia

Ennen kuin aloitamme mallin kouluttamisen, katsotaanpa, mikä on lineaarinen regressio.

Kuvittele, että sinulla on kaksi muuttujaa, x ja y, ja tehtävänäsi on ennustaa arvon tietämisen arvo. Jos piirrät tiedot, näet 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 jos kyseessä on satoja tuhansia pisteitä sisältävä tietojoukko.

Lineaarinen regressio arvioidaan yhtälöllä. Muuttuja y selitetään yhdellä tai monilla kovariaateilla. Esimerkissäsi on vain yksi riippuva muuttuja. Jos joudut kirjoittamaan tämän yhtälön, se on:

Kanssa:

  • on x: ään liittyvä paino
  • on mallin jäännös tai virhe. Se sisältää sen, mitä malli ei voi oppia tiedoista

Kuvittele, että sovitat mallin ja löydät seuraavan ratkaisun:

  • = 3,8
  • = 2,78

Voit korvata nuo yhtälön numerot ja siitä tulee:

y = 3,8 + 2,78x

Sinulla on nyt parempi tapa löytää arvot y: lle. Eli voit korvata x millä tahansa arvolla, jonka haluat ennustaa y. Alla olevassa kuvassa on korvattu yhtälössä x kaikilla tietojoukon arvoilla ja piirrettävä tulos.

Punainen viiva edustaa sovitettua arvoa, ts. Y: n arvoja kullekin x: n arvolle. Sinun ei tarvitse nähdä x: n arvoa ennustaa y, jokaisesta x: stä löytyy mikä tahansa punaiselle viivalle. Voit myös ennustaa arvoille x yli 2!

Jos haluat laajentaa lineaarista regressiota useampiin kovariaatteihin, voit lisätä malliin lisää muuttujia. Perinteisen analyysin ja lineaarisen regression ero on lineaarinen regressio, jossa tarkastellaan, kuinka y reagoi jokaisen muuttujan x suhteen riippumatta.

Katsotaanpa esimerkki. Kuvittele, että haluat ennustaa jäätelökaupan myynnin. Aineisto sisältää erilaisia ​​tietoja, kuten sää (esim. Sateinen, aurinkoinen, pilvinen), asiakastiedot (esim. Palkka, sukupuoli, siviilisääty).

Perinteinen analyysi yrittää ennustaa myyntiä sanomalla laskemalla kunkin muuttujan keskiarvo ja yrittämällä arvioida myynti eri skenaarioille. Se johtaa heikkoihin 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 (sovitetun linjan ja datapisteiden välinen ero).

Kuinka algoritmi toimii

Algoritmi valitsee satunnaisen määrä kunkin ja korvaa x: n arvo saada ennustearvon y. Jos tietojoukossa on 100 havaintoa, algoritmi laskee 100 ennustettua arvoa.

Voimme laskea mallin havaitun virheen, joka on ennustetun arvon ja todellisen arvon ero. Positiivinen virhe tarkoittaa, että malli aliarvioi y: n ennusteen, ja negatiivinen virhe tarkoittaa, että malli yliarvioi y: n ennusteen.

Tavoitteenasi 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ä:

  • viittaa ennustettuun arvoon
  • y on todelliset arvot
  • m on havaintojen lukumäärä

Huomaa, että on keskiarvon matemaattinen merkintä.

Tavoitteena on löytää parhaat, jotka minimoivat MSE: n

Jos keskimääräinen virhe on suuri, se tarkoittaa, että malli toimii huonosti eikä painoja ole valittu oikein. Painojen korjaamiseksi sinun on käytettävä optimoijaa. Perinteistä optimoijaa kutsutaan Gradient Descentiksi .

Gradientin laskeutuminen ottaa johdannaisen ja vähentää tai lisää painoa. Jos johdannainen on positiivinen, paino pienenee. Jos johdannainen on negatiivinen, paino nousee. Malli päivittää painot ja laskee virheen uudelleen. Tätä prosessia toistetaan, kunnes virhe ei enää muutu. Kutakin prosessia kutsutaan iteraatioksi . Lisäksi gradientit kerrotaan oppimisnopeudella. Se osoittaa oppimisen nopeuden.

Jos oppimisnopeus on liian pieni, algoritmin lähentyminen kestää hyvin kauan (eli vaatii paljon iteraatioita). Jos oppimisnopeus on liian korkea, algoritmi ei ehkä koskaan lähene toisiaan.

Yllä olevasta kuvasta näet, että malli toistaa prosessin noin 20 kertaa ennen vakioiden arvojen löytämistä painoille, jolloin saavutetaan pienin virhe.

Huomaa , että virhe ei ole nolla, mutta vakautuu noin 5. Se tarkoittaa, että malli tekee tyypillisen virheen 5. Jos haluat vähentää virhettä, sinun on lisättävä malliin lisätietoja, kuten enemmän muuttujia tai käytettävä eri estimaattorit.

Muistat ensimmäisen yhtälön

Lopulliset painot ovat 3,8 ja 2,78. Alla oleva video näyttää, kuinka kaltevuuslasku optimoi häviötoiminnon näiden painojen löytämiseksi

Kuinka kouluttaa lineaarista regressiota TensorFlow: lla

Nyt kun olet paremmin ymmärtänyt, mitä hupun takana tapahtuu, olet valmis käyttämään TensorFlow: n tarjoamaa estimaattorisovellusliittymää ensimmäisen lineaarisen regressiosi kouluttamiseen TensorFlow-sovelluksen avulla.

Käytät Bostonin tietojoukkoa, joka sisältää seuraavat muuttujat

Crim asukasta kohden rikollisuusaste kaupungeittain
zn osuus yli 25 000 neliömetrin tontteihin kaavoitetusta asuinmaasta
indus muut kuin vähittäiskaupan yrityshehtaarit kaupunkia kohti.
nox typpioksidien pitoisuus
rm huoneiden keskimääräinen lukumäärä asuntoa kohti
ikä osuus ennen vuotta 1940 rakennetuista omistusasunnoista
dis painotetut etäisyydet viiteen Bostonin työvoimakeskukseen
verottaa kiinteän omaisuuden veroaste 10000 dollaria kohti
ptratio oppilaan ja opettajan suhde kaupunkikohtaisesti
medv Omistaja-asuntojen mediaaniarvo tuhansissa dollareissa

Luot kolme erilaista tietoaineistoa:

tietojoukko tavoite muoto
Koulutus Harjoittele mallia ja hanki painot 400, 10
Arviointi Arvioi mallin suorituskyky näkymättömillä tiedoilla 100, 10
Ennustaa Mallin avulla voit ennustaa talon arvon uusille tiedoille 6, 10

Tavoitteena on käyttää tietoaineiston ominaisuuksia talon arvon ennustamiseen.

Opetusohjelman toisen osan aikana opit käyttämään TensorFlowia kolmella eri tavalla tietojen tuomiseen:

  • Pandojen kanssa
  • Numpyn kanssa
  • Vain TF

Huomaa, että kaikki vaihtoehdot tarjoavat samat tulokset.

Opit käyttämään korkean tason sovellusliittymää TensorFlow-lineaarisen regressiomallin rakentamiseen, kouluttamiseen. Jos käytit matalan tason sovellusliittymää, joudut määrittelemään käsin:

  • Menetystoiminto
  • Optimoi: kaltevuuslasku
  • Matriisien kertolasku
  • Kuvaaja ja tensori

Tämä on tylsiä ja monimutkaisempaa aloittelijoille.

Pandat

Sinun on tuotava tarvittavat kirjastot mallin kouluttamiseksi.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Vaihe 1) Tuo tiedot pandalla.

Määrität sarakkeiden nimet ja tallennat ne sarakkeisiin. Voit tuoda tiedot pd.read_csv () -toiminnon avulla.

COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]

training_set = pd.read_csv ("E: /boston_train.csv", skipinitialspace = True, skiprows = 1, nimet = COLUMNS)

test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = True, skiprows = 1, nimet = COLUMNS)

prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = True, skiprows = 1, nimet = COLUMNS)

Voit tulostaa tietojen muodon.

print(training_set.shape, test_set.shape, prediction_set.shape)

Tuotos

(400, 10) (100, 10) (6, 10)

Huomaa, että tarra, eli y, sisältyy aineistoon. Joten sinun on määritettävä kaksi muuta luetteloa. Yksi sisältää vain ominaisuudet ja toinen vain tarran nimen. Nämä kaksi luetteloa kertovat arvioijalle, 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 oikeassa muodossa. Tensorflow tarjoaa menetelmän jatkuvan muuttujan muuntamiseksi: tf.feature_column.numeric_column ().

Edellisessä vaiheessa määrität luettelon ominaisuuden, jonka haluat sisällyttää malliin. Nyt voit muuttaa tätä luetteloa numeerisiksi tiedoiksi. Jos haluat sulkea pois malleja ominaisuuksista, pudota yksi tai useampia muuttujia FEATURES-luetteloon, ennen kuin rakennat feature_cols

Huomaa, että käytät Python-luettelon ymmärtämistä FEATURES-luettelon kanssa uuden luettelon luomiseksi nimeltään feature_cols. Sen avulla voit välttää kirjoittamasta yhdeksän kertaa tf.feature_column.numeric_column (). Luettelon ymmärtäminen on nopeampi ja puhtaampi tapa luoda uusia luetteloita

feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]

Vaihe 3) Määritä estimaattori

Tässä vaiheessa sinun on määritettävä estimaattori. Tensorflow tarjoaa tällä hetkellä 6 ennalta rakennettua estimaattoria, joista 3 on luokitustehtävää ja 3 TensorFlow-regressiotehtävää varten:

  • Regressori
    • DNNRekisteri
    • Lineaarinen regressori
    • DNNLineaYhdistetty regresori
  • Luokittelija
    • DNN-luokittelija
    • Lineaarinen luokittelija
    • DNNLineaCombinedClassifizer

Tässä opetusohjelmassa käytetään lineaarista regressoria. Tämän toiminnon käyttämiseksi sinun on käytettävä tf.estimator -ohjelmaa.

Funktio tarvitsee kaksi argumenttia:

  • feature_columns: Sisältää malliin sisällytettävät muuttujat
  • model_dir: polku kaavion tallentamiseen, malliparametrien tallentamiseen jne

Tensorflow luo automaattisesti tiedoston nimeltä juna työhakemistoon. Sinun on käytettävä tätä polkua päästäksesi Tensorboard-levylle alla olevan TensorFlow-regressioesimerkin mukaisesti.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")

Tuotos

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': , '_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 syöttää mallia. Tensorflow on suunniteltu toimimaan rinnakkaislaskennan ja erittäin suuren tietojoukon kanssa. Koneresurssien rajallisuuden vuoksi on mahdotonta syöttää mallia kaikilla tiedoilla kerralla. Tätä varten sinun on syötettävä erä tietoja joka kerta. Huomaa, että puhumme valtavasta aineistosta, jossa on miljoonia tai enemmän tietueita. Jos et lisää erää, päädyt muistivirheeseen.

Esimerkiksi, jos tietosi sisältävät 100 havaintoa ja määrität eräkoon 10, se tarkoittaa, että malli näkee 10 havaintoa kullekin iteraatiolle (10 * 10).

Kun malli on nähnyt kaikki tiedot, se viimeistelee yhden aikakauden . Epookki määrittää kuinka monta kertaa haluat mallin näkevän tiedot. On parempi asettaa tämä vaihe olemattomaksi ja antaa mallin suorittaa iterointi useita kertoja.

Toinen lisättävä tieto on, jos haluat sekoittaa tietoja ennen jokaista iteraatiota. Koulutuksen aikana on tärkeää sekoittaa tietoja, jotta malli ei opi tietojoukon tiettyä mallia. Jos malli oppii tietojen taustalla olevan mallin yksityiskohdat, sillä on vaikeuksia yleistää näkymättömän datan ennustetta. Tätä kutsutaan yliasennukseksi . Malli toimii hyvin harjoitustiedoilla, mutta ei voi ennustaa näkymättömille tiedoille oikein.

TensorFlow tekee tämän kahden vaiheen tekemisen helpoksi. Kun data menee putkistoon, se tietää kuinka monta havaintoa se tarvitsee (erä) ja jos se on sekoitettava tietoja.

Voit opastaa Tensorflow'ta mallin syöttämisestä käyttämällä pandas_input_fn-tiedostoa. Tämä objekti tarvitsee 5 parametria:

  • x: ominaisuustiedot
  • y: tunnistetiedot
  • batch_size: erä. Oletuksena 128
  • num_epoch: aikakauden lukumäärä oletusarvoisesti 1
  • satunnaistoisto: Sekoita tietoja. Oletuksena Ei mitään

Sinun on syötettävä mallia useita kertoja, jotta määrität toiminnon 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 ennuste

Tensorflow estimaattorissa on kolme erilaista toimintoa näiden kolmen vaiheen suorittamiseksi helposti.

Vaihe 4) : Harjoittele mallia

Voit käyttää estimaattorijunaa mallin arvioimiseksi. Junaestimaattori tarvitsee input_fn ja useita vaiheita. Voit käyttää yllä luomaa toimintoa mallin syöttämiseen. Sitten kehotat mallia toistamaan 1000 kertaa. Huomaa, että et määritä aikakausien määrää, annat mallin toistaa 1000 kertaa. Jos asetat aikakauden lukumääräksi 1, malli toistaa neljä kertaa: Harjoittelusarjassa on 400 tietuetta ja eräkoko on 128

  1. 128 riviä
  2. 128 riviä
  3. 128 riviä
  4. 16 riviä

Siksi on helpompaa asettaa aikakausien lukumäärä olemattomaksi ja määritellä iteraatioiden lukumäärä kuten alla olevassa TensorFlow-luokitusesimerkissä on esitetty.

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

Tuotos

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 = 1INFO:tensorflow:global_step/sec: 238.616INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec)INFO:tensorflow:global_step/sec: 314.293INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec)INFO:tensorflow:global_step/sec: 303.863INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec)INFO:tensorflow:global_step/sec: 308.782INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec)INFO:tensorflow:global_step/sec: 244.969INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec)INFO:tensorflow:global_step/sec: 155.966INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec)INFO:tensorflow:global_step/sec: 263.256INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec)INFO:tensorflow:global_step/sec: 254.112INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec)INFO:tensorflow:global_step/sec: 292.405INFO: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 MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train

Vaihe 5) Arvioi mallisi

Voit arvioida mallisi sopivuuden testisarjaan alla olevan koodin avulla:

ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))

Tuotos

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:43:13INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896

Voit tulostaa häviön alla olevalla koodilla:

loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))

Tuotos

Loss: 3215.895996

Mallin tappio on 3215. Voit tarkistaa yhteenvetotilaston saadaksesi käsityksen virheen suuruudesta.

training_set['medv'].describe()

Tuotos

count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64

Yllä olevasta yhteenvetotilastosta tiedät, että talon keskihinta on 22 tuhatta, vähimmäishinta 9 tuhatta ja enintään 50 tuhatta. Malli tekee tyypillisen virheen 3k dollaria.

Vaihe 6) Tee ennuste

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 arviot arvoista käyttämällä tätä koodia:

predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))

Tuotos

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO: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ä arvon todellista arvoa. Syvän oppimisen opetusohjelmassa yrität voittaa lineaarisen mallin

Numpy ratkaisu

Tässä osassa 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

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). arvot

Vaihe 1) Tuo tiedot

Ensinnäkin sinun on erotettava ominaisuusmuuttujat tarrasta. Tämä on tehtävä harjoitustietoja ja arviointia varten. On nopeampi määritellä toiminto tietojen jakamiseksi.

def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train

Voit käyttää toimintoa jakamaan tarra junan ominaisuuksista / arvioi tietojoukko

X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n)

Sinun on suljettava pois ennakointitietojoukon viimeinen sarake, koska se sisältää vain NaN

x_predict = prediction_set_n[:, :-2]

Vahvista taulukon muoto. Huomaa, että tarralla ei pitäisi olla mittaa, se tarkoittaa (400,).

print(X_train.shape, y_train.shape, x_predict.shape)

Tuotos

(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 aiemmin, ohjeet ominaisuussarakkeisiin ja mihin kuvaaja tallennetaan.

estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")

Tuotos

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': , '_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 syöttää tiedot malliin numpy-estimaattorin avulla ja kouluttaa mallia. Huomaa, että määritämme input_fn-funktion aikaisemmin 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)

Tuotos

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 = 1INFO:tensorflow:global_step/sec: 490.057INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec)INFO:tensorflow:global_step/sec: 788.986INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec)INFO:tensorflow:global_step/sec: 736.339INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec)INFO:tensorflow:global_step/sec: 383.305INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec)INFO:tensorflow:global_step/sec: 859.832INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec)INFO:tensorflow:global_step/sec: 804.394INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec)INFO:tensorflow:global_step/sec: 753.059INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec)INFO:tensorflow:global_step/sec: 402.165INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec)INFO:tensorflow:global_step/sec: 344.022INFO: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]:

Voit toistaa saman vaiheen eri estimaattorilla arvioidaksesi mallisi

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)

Tuotos

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-01:44:00INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945Out[24]:{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}

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

Tuotos

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000INFO: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-liuos

Viimeinen osa on omistettu TensorFlow-ratkaisulle. Tämä menetelmä on hieman monimutkaisempi kuin toinen.

Huomaa, että jos käytät Jupyter-muistikirjaa, sinun on käynnistettävä ja puhdistettava ydin tämän istunnon suorittamiseksi.

TensorFlow on rakentanut upean työkalun tietojen siirtämiseksi putkilinjalle. Tässä osiossa rakennat input_fn-toiminnon itse.

Vaihe 1) Määritä tietojen polku ja muoto

Ensinnäkin ilmoitat kaksi muuttujaa csv-tiedoston polun kanssa. Huomaa, että sinulla on kaksi tiedostoa, yksi harjoitusjoukolle ja toinen testausjoukolle.

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 kaikkia. Sen jälkeen sinun on ilmoitettava muuttujan tyyppi.

Kelluva muuttuja määritetää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-toiminto

Toiminto voidaan jakaa kolmeen osaan:

  1. Tuo tiedot
  2. Luo iteraattori
  3. Kuluta tiedot

Alla on yleiskoodi toiminnon määrittelemiseksi. Koodi selitetään sen jälkeen

def input_fn(data_file, batch_size, num_epoch = None):# Step 1def 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 theDataset 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 3iterator = dataset.make_one_shot_iterator()features, labels = iterator.get_next()return features, labels

** Tuo tiedot **

Csv-tiedostolle tietojoukko-menetelmä lukee yhden rivin kerrallaan. Jos haluat rakentaa tietojoukon, sinun on käytettävä objektia TextLineDataset. Tietojoukossasi on otsikko, joten sinun on ohitettava ensimmäinen rivi ohitus (1) -toiminnolla. Tässä vaiheessa luet vain tiedot ja poissulkevat otsikon. Mallin syöttämiseksi sinun on erotettava ominaisuudet tarrasta. Menetelmä, jota käytetään muunnoksen tekemiseen dataan, on kartta.

Tämä menetelmä kutsuu toimintoa, jonka luot luomaan tietojen muuntamiseksi. Lyhyesti sanottuna sinun on välitettävä tiedot TextLineDataset-objektissa, suljettava otsikko pois ja sovellettava muunnos, jonka funktio ohjaa.

  • tf.data.TextLineDataset (data_file): Tämä rivi lukee csv-tiedoston
  • .skip (1): ohita otsikko
  • .map (parse_csv)): jäsennä tietueet tensoreihin Sinun on määritettävä funktio karttaobjektin opastamiseksi. Voit kutsua tätä toimintoa parse_csv.

Tämä funktio jäsentää csv-tiedoston menetelmällä tf.decode_csv ja ilmoittaa ominaisuudet ja tarran. Ominaisuudet voidaan julistaa sanakirjaksi tai dupleksi. Käytät sanastomenetelmää, koska se on helpompaa

  • tf.decode_csv (arvo, tietueen oletusarvot = RECORDS_ALL): menetelmä decode_csv käyttää TextLineDataset-lähdön lukemaan csv-tiedoston. record_defaults opastaa TensorFlow'ta saraketyypistä.
  • dict (zip (_CSV_COLUMNS, sarakkeet)): Täytä sanakirja kaikista sarakkeista, jotka on purettu tämän tietojenkäsittelyn aikana
  • features.pop ('median_house_value'): Sulje kohdemuuttuja ominaisuusmuuttujasta ja luo tunnistemuuttuja

Aineisto tarvitsee lisää elementtejä tensoreiden iteratiiviseen syöttämiseen. Itse asiassa sinun on lisättävä menetelmän toisto, jotta tietojoukko voi jatkua loputtomasti mallin syöttämiseksi. Jos et lisää menetelmää, malli toistaa vain yhden kerran ja heittää sitten virheen, koska lisää tietoja ei syötetä.

Sen jälkeen voit säätää eräkokoa erämenetelmällä. Se tarkoittaa, että kerrot tietojoukolle, kuinka monta tietoa haluat välittää jokaisessa iteraatiossa. 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.

Sen jälkeen voit luoda ominaisuudet ja tarrat iteraattorista.

Vaihe 4) Kuluta tiedot

Voit tarkistaa, mitä tapahtuu input_fn-toiminnolla. Sinun on kutsuttava toiminto istunnossa tietojen kuluttamiseksi. Yrität eräkoossa yhtä kuin 1.

Huomaa, että se tulostaa sanakirjan ominaisuudet ja tarran taulukkoina.

Se näyttää csv-tiedoston ensimmäisen rivin. Voit yrittää suorittaa tämän koodin useita kertoja eri erä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)

Tuotos

({'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 ryhmään

base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]

Vaihe 5) Rakenna malli

Voit kouluttaa mallia estimaattorilla LinearRegressor.

model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')

Tuotos

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': , '_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 argumentti voidaan kirjoittaa funktioon inpu_fn. Jos et käytä lambda-toimintoa, et voi kouluttaa mallia.

# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))

Tuotos

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 = 1INFO:tensorflow:global_step/sec: 72.5646INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec)INFO:tensorflow:global_step/sec: 101.355INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec)INFO:tensorflow:global_step/sec: 109.293INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec)INFO:tensorflow:global_step/sec: 102.235INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec)INFO:tensorflow:global_step/sec: 104.656INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec)INFO:tensorflow:global_step/sec: 106.697INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec)INFO:tensorflow:global_step/sec: 118.454INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec)INFO:tensorflow:global_step/sec: 114.947INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec)INFO:tensorflow:global_step/sec: 111.484INFO: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]:

Voit arvioida mallisi sopivuuden testisarjaan alla olevan koodin avulla:

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

Tuotos

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Starting evaluation at 2018-05-13-02:06:02INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896average_loss, was: 32.158958435058594loss, was: 3215.89599609375global_step, was: 1000

Viimeinen vaihe on arvon ennustaminen ominaisuuksien matriisien arvon perusteella. Voit kirjoittaa sanakirjan arvoilla, jotka haluat ennustaa. Mallissasi on 9 ominaisuutta, joten sinun on annettava jokaiselle arvo. Malli antaa ennusteen kullekin niistä.

Alla olevaan koodiin kirjoitit jokaisen ominaisuuden arvot, jotka sisältyvät df_predict csv-tiedostoon.

Sinun on kirjoitettava uusi input_fn-funktio, koska tietojoukossa ei ole tunnistetta. Voit käyttää API-tiedostoa 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)

Viimeinkin, tulostat ennusteet.

for pred in enumerate(pred_results):print(pred)

Tuotos

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000INFO: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ääritä ominaisuudet: Itsenäiset muuttujat: X
  • Määritä tunniste: Riippuva muuttuja: y
  • Rakenna juna / testisarja
  • Määritä alkuperäinen paino
  • Määritä häviöfunktio: MSE
  • Optimoi malli: kaltevuuslasku
  • Määritellä:
    • Oppimisnopeus
    • Aikakauden lukumäärä
    • Erän koko

Tässä opetusohjelmassa opit käyttämään korkean tason sovellusliittymää TensorFlow-lineaarisen regressioestimaattorin kanssa. Sinun on määriteltävä:

  1. Feature sarakkeet. Jos jatkuva: tf.feature_column.numeric_column (). Voit täyttää luettelon python-luettelon ymmärtämisellä
  2. Estimaattori: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Toiminto tietojen, eräkoon ja aikakauden tuomiseksi: input_fn ()

Sen jälkeen olet valmis harjoittelemaan, arvioimaan ja ennustamaan junalla (), arvioimaan () ja ennustamaan ()