Lineaarne regressioon TensorFlow abil (näited)

Mis on lineaarne regressioon?

Lineaarne regressioon on lähenemine statistikas kahe muutuja vaheliste seoste modelleerimiseks. See modelleerimine toimub skalaarse vastuse ja ühe või mitme selgitava muutuja vahel. Seoseid ühe seletava muutujaga nimetatakse lihtsaks lineaarseks regressiooniks ja rohkem kui ühe selgitava muutuja jaoks mitmeks lineaarseks regressiooniks.

TensorFlow pakub tööriistu arvutuste täielikuks kontrollimiseks. Seda tehakse madala API-ga. Lisaks sellele on TensorFlow varustatud paljude masinõppealgoritmide täitmiseks suure hulga API-dega. See on kõrgetasemeline API. TensorFlow nimetab neid hinnanguteks

  • Madalama taseme API: ehitage üles arhitektuur, mudeli optimeerimine nullist. Algajale on see keeruline
  • Kõrgel tasemel API: määrake algoritm. See on hõlpsam. TensorFlow näeb pakett kõned hindaja ehitada, rongi, hinnata ja teha ennustus.

Selles õpetuses kasutate ainult prognoosijaid . Arvutused on kiiremad ja neid on lihtsam rakendada. Õpetuse esimeses osas selgitatakse, kuidas kasutada gradientlanguse optimeerijat TensorFlow'is lineaarse regressiooni treenimiseks. Teises osas kasutate TensorFlow hinnangu abil maja hinna ennustamiseks Bostoni andmekogumit.

Laadige alla Bostoni andmekogum

Selles TensorFlow regressiooniõpetuses saate teada:

  • Mis on lineaarne regressioon?
  • Kuidas treenida lineaarset regressioonimudelit
  • Kuidas treenida lineaarset regressiooni TensorFlow abil
  • Pandad
  • Tohutu lahendus
  • Tensorflow lahus

Kuidas treenida lineaarset regressioonimudelit

Enne kui hakkame mudelit koolitama, vaatame, mis on lineaarne regressioon.

Kujutage ette, et teil on kaks muutujat, x ja y, ja teie ülesanne on ennustada väärtuse teadmise väärtust. Andmete koostamisel näete positiivset suhet sõltumatu muutuja x ja sõltuva muutuja y vahel.

Võite täheldada, et kui x = 1, on y ligikaudu 6 ja kui x = 2, on y umbes 8,5.

See pole eriti täpne meetod ja viga, eriti sadade tuhandete punktidega andmestiku puhul.

Lineaarset regressiooni hinnatakse võrrandiga. Muutuja y on seletatav ühe või mitme ühismuutujaga. Teie näites on ainult üks sõltuv muutuja. Kui peate selle võrrandi kirjutama, on see järgmine:

Koos:

  • on x-ga seotud kaal
  • on mudeli jääk või viga. See sisaldab seda, mida mudel andmetest õppida ei saa

Kujutage ette, et sobiksite mudeliga ja leiate järgmise lahenduse:

  • = 3,8
  • = 2,78

Võite võrrandis need numbrid asendada ja see saab:

y = 3,8 + 2,78x

Nüüd on teil parem viis y väärtuste leidmiseks. See tähendab, et saate asendada x mis tahes väärtusega, mida soovite y ennustada. Alloleval pildil on võrrandis x asendatud kõigi andmekogumi väärtustega ja tulemus joonistatakse.

Punane joon tähistab sobitatud väärtust, see tähendab y väärtusi iga x väärtuse jaoks. Y ennustamiseks ei pea nägema x väärtust, iga x puhul on punase joone jaoks mõni väärtus. Samuti saate ennustada, kui x väärtus on suurem kui 2!

Kui soovite laiendada lineaarset regressiooni rohkemate muutujate jaoks, saate mudelisse lisada rohkem muutujaid. Traditsioonilise analüüsi ja lineaarse regressiooni erinevus seisneb selles, et lineaarne regressioon vaatleb, kuidas y reageerib iga sõltumatult võetud muutuja x korral.

Vaatame näite. Kujutage ette, et soovite ennustada jäätisepoe müüki. Andmekogum sisaldab erinevat teavet, näiteks ilm (st vihmane, päikeseline, pilves), klientide teave (nt palk, sugu, perekonnaseis).

Traditsiooniline analüüs püüab müüki ennustada, oletame, et arvutame iga muutuja keskmise ja proovime hinnata müüki erinevate stsenaariumite korral. See toob kaasa halvad prognoosid ja piirab analüüsi valitud stsenaariumiga.

Kui kasutate lineaarset regressiooni, võite kirjutada selle võrrandi:

Algoritm leiab kaaludele parima lahenduse; see tähendab, et ta püüab kulusid minimeerida (vahe sobitatud liini ja andmepunktide vahel).

Kuidas algoritm töötab

Algoritm valib juhusliku arvu iga ja asendada väärtus x saada ennustatud väärtus y. Kui andmekogul on 100 vaatlust, arvutab algoritm 100 ennustatud väärtust.

Saame arvutada mudeli puhul märgitud vea, mis on erinevus ennustatud väärtuse ja tegeliku väärtuse vahel. Positiivne viga tähendab, et mudel alahindab y ennustust ja negatiivne viga tähendab, et mudel hindab y ennustust üle.

Teie eesmärk on minimeerida vea ruut. Algoritm arvutab ruutvea keskmise. Seda sammu nimetatakse vea minimeerimiseks. Lineaarse regressiooni korral on keskmine ruutviga , mida nimetatakse ka MSE-ks. Matemaatiliselt on see:

Kus:

  • viitavad prognoositavale väärtusele
  • y on tegelikud väärtused
  • m on vaatluste arv

Pange tähele, et on keskmise matemaatiline tähistus.

Eesmärk on leida parim, mis minimeerib MSE-d

Kui keskmine viga on suur, tähendab see, et mudel töötab halvasti ja kaalud ei ole õigesti valitud. Kaalude korrigeerimiseks peate kasutama optimeerijat. Traditsioonilist optimeerijat nimetatakse Gradient Descent .

Gradiendi laskumine võtab tuletise ja vähendab või suurendab kaalu. Kui tuletis on positiivne, vähendatakse kaalu. Kui tuletis on negatiivne, suureneb kaal. Mudel värskendab kaalu ja arvutab vea uuesti. Seda protsessi korratakse seni, kuni viga enam ei muutu. Iga protsessi nimetatakse iteratsiooniks . Pealegi korrutatakse gradiendid õpimääraga. See näitab õppimise kiirust.

Kui õppimismäär on liiga väike, võtab algoritmi lähenemine väga kaua aega (st nõuab palju kordusi). Kui õppimismäär on liiga kõrge, ei pruugi algoritm kunagi läheneda.

Ülaltoodud pildilt näete, et mudel kordab protsessi umbes 20 korda enne, et leida kaalude stabiilne väärtus, saavutades seega madalaima vea.

Pange tähele , et viga ei ole võrdne nulliga, vaid stabiliseerub ümber 5. See tähendab, et mudel teeb tüüpilise vea 5. Kui soovite viga vähendada, peate mudelisse lisama rohkem teavet, näiteks rohkem muutujaid või kasutama erinevad hinnangud.

Mäletate esimest võrrandit

Lõplikud kaalud on 3,8 ja 2,78. Allpool olev video näitab teile, kuidas gradientne laskumine optimeerib kadumisfunktsiooni selle kaalu leidmiseks

Kuidas treenida lineaarset regressiooni TensorFlow abil

Nüüd, kui olete kapoti taga toimuvast paremini aru saanud, olete valmis kasutama TensorFlow pakutavat hinnangu API-d oma esimese lineaarse regressiooni treenimiseks TensorFlow abil.

Kasutate Bostoni andmekogumit, mis sisaldab järgmisi muutujaid

krimm elanikkonna kuritegevuse määr linnade kaupa
zn üle 25 000 ruutmeetri suuruste kruntide jaoks eraldatud elamumaa osakaal
indus mittekaubandusettevõtete aakri osakaal linna kohta.
nox lämmastikoksiidide kontsentratsioon
rm keskmine tubade arv eluruumi kohta
vanus enne 1940. aastat ehitatud omanike kasutuses olevate üksuste osakaal
dis kaalutud vahemaad viie Bostoni töökeskuse juurde
maks täisväärtuslik kinnisvara maksumäär 10 000 dollari kohta
ptratio õpilase ja õpetaja suhe linnade kaupa
medv Omanike kasutuses olevate kodude keskmine väärtus tuhandetes dollarites

Loote kolm erinevat andmekogumit:

andmekogum objektiivne kuju
Koolitus Treenige mudelit ja hankige kaalud 400, 10
Hindamine Hinnake mudeli toimimist nägemata andmetel 100, 10
Ennusta Uute andmete põhjal maja väärtuse ennustamiseks kasutage mudelit 6, 10

Eesmärk on kasutada andmekogumi funktsioone maja väärtuse ennustamiseks.

Õpetuse teises osas saate teada, kuidas kasutada TensorFlow'i andmete importimiseks kolme erineval viisil:

  • Pandadega
  • Numpyga
  • Ainult TF

Pange tähele, et kõik valikud pakuvad samu tulemusi.

Saate teada, kuidas kasutada kõrgetasemelist API-d TensorFlow lineaarse regressiooni mudeli koostamiseks, koolitamiseks. Kui kasutasite madala taseme API-d, peate käsitsi määratlema:

  • Kaotuse funktsioon
  • Optimeeri: gradientne laskumine
  • Maatriksite korrutamine
  • Graafik ja tensor

See on algaja jaoks tüütu ja keerulisem.

Pandad

Mudeli koolitamiseks peate importima vajalikud teegid.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

1. samm. Importige andmed pandaga.

Määrate veergude nimed ja salvestate need veergudesse. Andmete importimiseks võite kasutada 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, nimed = COLUMNS)

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

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

Andmete kuju saate printida.

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

Väljund

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

Pange tähele, et silt, st teie y, on lisatud andmekogumisse. Nii et peate määratlema veel kaks loendit. Üks sisaldab ainult funktsioone ja teine ​​ainult sildi nimega. Need kaks loendit ütlevad teie hinnangule, millised on andmekogumi funktsioonid ja milline veeru nimi on silt

Seda tehakse alloleva koodiga.

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

2. samm. Teisendage andmed

Peate teisendama numbrilised muutujad õiges vormingus. Tensorflow pakub meetodit pideva muutuja teisendamiseks: tf.feature_column.numeric_column ().

Eelmises etapis määratlete loendi funktsioon, mille soovite mudelisse lisada. Nüüd saate selle loendi abil muuta need arvandmeteks. Kui soovite oma mudelis funktsioone välja jätta, visake enne funktsiooni_koolid koostamist loendisse FEATURES üks või mitu muutujat

Pange tähele, et uue loendi nimega feature_cols loomiseks kasutate Pythoni loendi mõistmist koos loendiga FEATURES. See aitab teil vältida üheksa korda kirjutamist tf.feature_column.numeric_column (). Loendite mõistmine on kiirem ja puhtam viis uute loendite loomiseks

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

3. samm. Määrake hinnang

Selles etapis peate määrama hindaja. Tensorflow pakub praegu 6 eelnevalt ehitatud prognoosijat, sealhulgas 3 klassifitseerimisülesande jaoks ja 3 regenereerimisülesande TensorFlow jaoks:

  • Regressor
    • DNNRegressor
    • Lineaarregressor
    • DNNLineaCombinedRegressor
  • Klassifikaator
    • DNN klassifikaator
    • Lineaarne klassifikaator
    • DNNLineaCombinedClasizer

Selles õpetuses kasutate lineaarset regressorit. Selle funktsiooni kasutamiseks peate kasutama tf.estimator.

Funktsioon vajab kahte argumenti:

  • feature_columns: Sisaldab mudelisse lisatavaid muutujaid
  • model_dir: tee graafiku salvestamiseks, mudeli parameetrite salvestamiseks jne

Tensorflow loob teie töökataloogi faili nimega rong. Tensorboardile pääsemiseks peate seda teed kasutama, nagu on näidatud allpool toodud TensorFlow regressiooninäites.

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

Väljund

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 abil on keeruline osa mudeli söötmiseks. Tensorflow on loodud töötama paralleelarvutuste ja väga suure andmekogumiga. Masina ressursside piiratuse tõttu on võimatu mudeli kõiki andmeid korraga edastada. Selleks peate iga kord sisestama andmepartiid. Pange tähele, et me räägime tohutust andmestikust, millel on miljoneid või rohkem kirjeid. Kui te ei lisa paketti, tekib mäluviga.

Näiteks kui teie andmed sisaldavad 100 vaatlust ja määrate partii suuruseks 10, tähendab see, et mudel näeb iga iteratsiooni jaoks 10 vaatlust (10 * 10).

Kui mudel on kõik andmed näinud, lõpetab see ühe ajastu . Epohh määratleb, mitu korda soovite, et mudel andmeid näeks. Parem on seada see samm nulliks ja lasta mudelil korrata mitu korda.

Teine lisatav teave on see, kui soovite enne iga iteratsiooni andmeid segada. Koolituse ajal on oluline andmeid segada, et mudel ei õpiks andmekogumi konkreetset mustrit. Kui mudel saab teada andmete aluseks oleva mustri üksikasjad, on tal raskusi nähtamatute andmete prognoosi üldistamisega. Seda nimetatakse üleliigseks . Mudel toimib treeningandmetega hästi, kuid ei saa nähtamatute andmete korral õigesti ennustada.

TensorFlow muudab selle kahe sammu hõlpsaks. Kui andmed lähevad torujuhtmele, teab ta, kui palju vaatlusi ta vajab (partii) ja kas see peab andmeid segama.

Tensorflow juhendamiseks, kuidas mudelit toita, saate kasutada pandas_input_fn. See objekt vajab 5 parameetrit:

  • x: funktsiooniandmed
  • y: sildi andmed
  • partii_suurus: partii. Vaikimisi 128
  • num_epoch: ajastu arv, vaikimisi 1
  • juhuslik: juhi andmeid või mitte. Vaikimisi pole

Peate mudelit mitu korda söötma, et saaksite selle protsessi kordamiseks määrata funktsiooni. kogu see funktsioon 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)

Tavaline meetod mudeli toimivuse hindamiseks on:

  • Treenige mudelit
  • Hinnake mudelit teises andmekogumis
  • Tehke ennustusi

Selle kolme etapi hõlpsaks täitmiseks pakub Tensorflow hinnanguline funktsioon kolme erinevat funktsiooni.

4. samm) : koolitage mudelit

Mudeli hindamiseks võite kasutada hindaja rongi. Rongihindaja vajab sisestust_fn ja mitmeid samme. Mudeli söötmiseks saate kasutada ülaltoodud funktsiooni. Seejärel juhendate mudelit kordama 1000 korda. Pange tähele, et te ei määra ajastute arvu, vaid lasete mudelil korduda 1000 korda. Kui määrate ajajärgu arvuks 1, siis kordub mudel 4 korda: treeningkomplektis on 400 kirjet ja partii suurus on 128

  1. 128 rida
  2. 128 rida
  3. 128 rida
  4. 16 rida

Seetõttu on lihtsam seada ajastu arv nulliks ja määratleda iteratsiooni arv, nagu on näidatud allpool TensorFlow klassifikatsiooni näites.

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

Väljund

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into train/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.

Võite kontrollida, kas Tensorboard teeb järgmist käsku:

activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train

5. samm. Hinnake oma mudelit

Oma mudeli sobivust testikomplektis saate hinnata järgmise koodiga:

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

Väljund

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

Kaotuse saate printida alloleva koodiga:

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

Väljund

Loss: 3215.895996

Mudeli kaotus on 3215. Kokkuvõtlikust statistikast saate ülevaadet, kui suur viga on.

training_set['medv'].describe()

Väljund

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

Ülaltoodud kokkuvõtlikust statistikast teate, et maja keskmine hind on 22 tuhat, miinimumhind 9 tuhat ja maksimaalselt 50 tuhat. Mudel teeb tüüpilise vea 3k dollarit.

6. samm. Tehke ennustus

Lõpuks võite kasutada 6 Bostoni maja väärtuse hindamiseks hindajat TensorFlow ennustada.

y = estimator.predict(input_fn=get_input_fn(prediction_set,num_epochs=1,n_batch = 128,shuffle=False))

Prognoositud väärtuste printimiseks võite kasutada seda koodi:

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

Väljund

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

Mudel prognoosib järgmisi väärtusi:

Maja

Ennustamine

1

32.29

2

18.96

3

27.27

4

29.29

5

16.43

7

21.46

Pange tähele, et me ei tea selle tegelikku väärtust. Sügava õppimise õpetuses proovite lineaarset mudelit ületada

Tohutu lahendus

Selles jaotises selgitatakse, kuidas mudelit koolitada, kasutades andmete sisestamiseks numpy-prognoosijat. Meetod on sama, välja arvatud see, et kasutate prognoosijat numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). väärtused

test_set_n = pd.read_csv ("E: /boston_test.csv"). väärtused

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). väärtused

1. samm. Importige andmed

Kõigepealt peate eristama tunnuse muutujad. Seda peate tegema koolituse andmete ja hindamise jaoks. Andmete jagamiseks on kiirem määratleda funktsioon.

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

Funktsiooni abil saate sildi rongi / andmekogumi hindamise funktsioonidest lahutada

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

Peate välja jätma ennustuse andmekogumi viimase veeru, kuna see sisaldab ainult NaN-i

x_predict = prediction_set_n[:, :-2]

Kinnitage massiivi kuju. Pange tähele, et sildil ei tohiks olla mõõdet, see tähendab (400,).

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

Väljund

(400, 9) (400,) (6, 9)

Funktsiooniveerge saate koostada järgmiselt:

feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]

Hindaja on määratletud nagu varem. Juhendate funktsiooniveerge ja graafiku salvestamise kohta.

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

Väljund

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}

Andmete mudelisse toomiseks ja seejärel mudeli koolitamiseks võite kasutada numpy-hinnangut. Pange tähele, et loetavuse hõlbustamiseks määratleme enne funktsiooni input_fn.

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

Väljund

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into 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]:

Mudeli hindamiseks kordate sama sammu teise hindajaga

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)

Väljund

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}

Lõpuks saate prognoosi arvutada. See peaks olema sarnane pandadega.

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

Väljund

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 lahus

Viimane osa on pühendatud TensorFlow lahendusele. See meetod on pisut keerukam kui teine.

Pange tähele, et kui kasutate Jupyteri sülearvutit, peate selle seansi käivitamiseks taaskäivitama ja puhastama kerneli.

TensorFlow on loonud suurepärase tööriista andmete edastamiseks torujuhtmesse. Selles jaotises koostate funktsiooni input_fn ise.

1. samm. Määrake andmete tee ja vorming

Kõigepealt deklareerite csv-faili teega kaks muutujat. Pange tähele, et teil on kaks faili, üks treeningukomplekti ja teine ​​testimiskomplekti jaoks.

import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"

Seejärel peate määrama veerud, mida soovite csv-failist kasutada. Me kasutame kõiki. Pärast seda peate deklareerima muutuja tüübi, mis see on.

Ujuki muutuja määratletakse väärtusega [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]]

2. samm. Määrake funktsioon input_fn

Funktsiooni saab jagada kolmeks osaks:

  1. Importige andmed
  2. Looge iteraator
  3. Kasutage andmeid

Allpool on funktsiooni määratlemiseks üldkood. Kood selgitatakse pärast

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

** Andmete importimine **

Csv-faili puhul loeb andmekogumi meetod ühte rida korraga. Andmekogumi loomiseks peate kasutama objekti TextLineDataset. Teie andmekogul on päis, seega peate esimese rea vahele jätmiseks kasutama skip (1). Sel hetkel loete ainult andmeid ja välistate gaasijuhtme päise. Mudeli söötmiseks peate sildist eraldama funktsioonid. Andmete mis tahes teisendamise rakendamiseks on kasutatud kaarti.

See meetod kutsub funktsiooni, mille loote, et juhendada, kuidas andmeid teisendada. Lühidalt öeldes peate andmed edastama objektis TextLineDataset, välistama päise ja rakendama funktsiooni juhendatud teisenduse.

  • tf.data.TextLineDataset (data_file): see rida loeb csv-faili
  • .skip (1): jätke päis vahele
  • .map (parse_csv)): sõeluge kirjed tensoritesse. Kaardiobjekti juhendamiseks peate määratlema funktsiooni. Seda funktsiooni saate nimetada parse_csv.

See funktsioon sõelub csv-faili meetodiga tf.decode_csv ning deklareerib funktsioonid ja sildi. Funktsioone saab deklareerida sõnastiku või dupleksina. Kasutate sõnastiku meetodit, kuna see on mugavam. Koodi selgitus

  • tf.decode_csv (väärtus, record_defaults = RECORDS_ALL): meetod decode_csv kasutab csv-faili lugemiseks TextLineDataset väljundit. record_defaults annab TensorFlow'ile juhiseid veergude tüübi kohta.
  • dict (zip (_CSV_COLUMNS, veerud)): täitke sõnastik kõigi selle andmetöötluse käigus eraldatud veergudega
  • features.pop ('median_house_value'): jätke sihtmuutuja funktsioonimuutujast välja ja looge sildimuutuja

Andmekogum vajab tenorite korduvaks toitmiseks täiendavaid elemente. Tõepoolest, peate lisama meetodi korduse, et andmekogum saaks mudeli söötmiseks lõputult jätkuda. Kui te meetodit ei lisa, kordab mudel ainult ühe korra ja viskab seejärel tõrke, kuna gaasijuhtme kaudu ei sisestata enam andmeid.

Pärast seda saate partii suurust kontrollida partiimeetodiga. See tähendab, et ütlete andmekogumile, kui palju andmeid soovite iga korduse jaoks edastada. Kui määrate suure partii suuruse, on mudel aeglane.

Samm 3) Looge iteraator

Nüüd olete valmis teiseks sammuks: andmekogumi elementide tagastamiseks looge iteraator.

Lihtsaim viis operaatori loomiseks on meetod make_one_shot_iterator.

Pärast seda saate iteraatorist luua funktsioonid ja sildid.

4. samm. Tarbige andmeid

Saate kontrollida, mis juhtub funktsiooniga input_fn. Andmete tarbimiseks peate seansil kutsuma funktsiooni. Proovite partii suurusega 1.

Pange tähele, et see prindib sõnastiku funktsioonid ja sildi massiivina.

See näitab csv-faili esimest rida. Võite proovida seda koodi mitu korda erineva partii suurusega käivitada.

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)

Väljund

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

4. samm. Määrake funktsiooniveerg

Numbriveerud peate määratlema järgmiselt:

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

Pange tähele, et peate kõik muutujad ämbrisse ühendama

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

5. samm. Ehitage mudel

Mudeli saate koolitada hindajaga LinearRegressor.

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

Väljund

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}

Argumendi kirjutamiseks funktsiooni inpu_fn peate kasutama lambda funktsiooni. Kui te ei kasuta lambda funktsiooni, ei saa te mudelit treenida.

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

Väljund

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Create CheckpointSaverHook.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.INFO:tensorflow:Saving checkpoints for 1 into 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]:

Oma mudeli sobivust testikomplektis saate hinnata järgmise koodiga:

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

Väljund

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

Viimane samm on väärtuse ennustamine funktsioonide maatriksite väärtuse põhjal. Võite kirjutada sõnastiku väärtustega, mida soovite ennustada. Teie mudelil on 9 funktsiooni, nii et peate igale väärtusele vastama. Mudel annab prognoosi neile kõigile.

Allolevasse koodi kirjutasite kõigi funktsioonide väärtused, mis sisalduvad failis df_predict csv.

Peate kirjutama uue funktsiooni input_fn, kuna andmestikus pole silti. Võite kasutada andmekomplekti API from_tensor.

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)

Lõpuks printite ennustused.

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

Väljund

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

Kokkuvõte

Mudeli koolitamiseks peate:

  • Määratlege omadused: Iseseisvad muutujad: X
  • Määrake silt: Sõltuv muutuja: y
  • Ehitage rong / katsekomplekt
  • Määrake algkaal
  • Määratlege kadumisfunktsioon: MSE
  • Optimeerige mudelit: gradientne laskumine
  • Määratlege:
    • Õppimise määr
    • Ajastu arv
    • Partii suurus

Selles õpetuses õppisite kasutama kõrgel tasemel API-d lineaarse regressiooni TensorFlow prognoosija jaoks. Peate määratlema:

  1. Funktsiooni veerud. Kui see on pidev: tf.feature_column.numeric_column (). Saate loendi asendada pythoni loendi mõistmisega
  2. Hinnanguline: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Funktsioon andmete, partii suuruse ja ajastu importimiseks: input_fn ()

Pärast seda olete valmis treenima, hindama ja rongiga ennustama (), hindama () ja ennustama ()

Huvitavad Artiklid...