Lineaarse regressiooni õpetus TensorFlow'ga [näited]
Evelyn Clarke
Mis on lineaarne regressioon?
lineaarne regressioon on statistika lähenemisviis kahe muutuja vaheliste suhete modelleerimiseks. See modelleerimine toimub skalaarvastuse ja ühe või mitme selgitava muutuja vahel. Seost ühe seletava muutujaga nimetatakse lihtsaks lineaarseks regressiooniks ja rohkem kui ühe seletava muutuja puhul mitmekordseks lineaarseks regressiooniks.
TensorFlow pakub tööriistu arvutuste täielikuks kontrollimiseks. Seda tehakse madala taseme API-ga. Lisaks on TensorFlow varustatud suure hulga API-dega, et täita paljusid masinõpe algoritmid. See on kõrgetasemeline API. TensorFlow nimetab neid hindajateks
- Madala taseme API: ehitage üles arhitektuur, mudeli optimeerimine nullist. Algajale on see keeruline
- Kõrgetasemeline API: määrake algoritm. See on hõlpsasti kasutatav. TensorFlow pakub tööriistakasti nimega hindaja konstrueerida, treenida, hinnata ja ennustada.
Selles õpetuses kasutate ainult hinnangulised. Arvutused on kiiremad ja neid on lihtsam rakendada. Õpetuse esimene osa selgitab, kuidas kasutada gradiendi laskumise optimeerijat TensorFlow lineaarse regressiooni treenimiseks. Teises osas kasutate Bostoni andmestikku maja hinna ennustamiseks TensorFlow hinnangu abil.
Kuidas treenida lineaarse regressiooni mudelit
Enne kui hakkame mudelit treenima, vaatame, mis on lineaarne regressioon.
Kujutage ette, et teil on kaks muutujat x ja y ning teie ülesandeks on ennustada väärtuse teadmise väärtust. Andmete joonistamisel näete positiivset seost sõltumatu muutuja x ja sõltuva muutuja y vahel.
Võite jälgida, kui x=1,y on ligikaudu 6 ja kui x=2,y on ligikaudu 8.5.
See ei ole väga täpne meetod ja tõrgeteta, eriti sadade tuhandete punktidega andmekogumi puhul.
Lineaarset regressiooni hinnatakse võrrandiga. Muutujat y seletatakse ü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 eelarvamus. st kui x=0, y=
on x-ga seotud kaal
on mudeli jääk või viga. See sisaldab seda, mida mudel andmetest õppida ei saa
Kujutage ette, et sobite mudeliga ja leiate järgmise lahenduse:
- = 3.8
- = 2.78
Saate need arvud võrrandis asendada ja see muutub:
y = 3.8 + 2.78x
Nüüd on teil parem viis y väärtuste leidmiseks. See tähendab, et saate x asendada mis tahes väärtusega, mida soovite y ennustada. Alloleval pildil oleme võrrandis asendanud x kõigi andmestiku väärtustega ja joonistanud tulemuse.
Punane joon tähistab sobitatud väärtust, st iga x väärtuse y väärtusi. Y ennustamiseks ei pea te nägema x väärtust, iga x jaoks on mõni, mis kuulub punasele joonele. Samuti saate ennustada väärtusi x, mis on suuremad kui 2!
Kui soovite laiendada lineaarset regressiooni rohkematele ühismuutujatele, saate seda teha, lisades mudelile rohkem muutujaid. Traditsioonilise analüüsi ja lineaarse regressiooni erinevus seisneb selles, et lineaarne regressioon vaatleb, kuidas y reageerib igale muutujale x, mis võetakse sõltumatult.
Vaatame näidet. Kujutage ette, et soovite ennustada jäätisepoe müüki. Andmekogum sisaldab erinevat teavet, nagu ilm (st vihmane, päikeseline, pilvine), klienditeave (st palk, sugu, perekonnaseis).
Traditsiooniline analüüs püüab müüki ennustada, näiteks arvutades iga muutuja keskmise ja proovides hinnata müüki erinevate stsenaariumide jaoks. See toob kaasa kehvad prognoosid ja piirab analüüsi valitud stsenaariumiga.
Kui kasutate lineaarset regressiooni, saate kirjutada järgmise võrrandi:
Algoritm leiab kaaludele parima lahenduse; see tähendab, et ta püüab minimeerida kulusid (erinevus sobitatud joone ja andmepunktide vahel).
Kuidas algoritm töötab
Algoritm valib igaühe jaoks juhusliku arvu 
ja 
ja asendage x väärtus, et saada y ennustatud väärtus. Kui andmekogumil on 100 vaatlust, arvutab algoritm 100 prognoositud väärtust.
Saame vea arvutada, märkis 
mudelist, mis on prognoositud väärtuse ja tegeliku väärtuse erinevus. 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 ruutu. Algoritm arvutab ruutvea keskmise. Seda sammu nimetatakse vea minimeerimiseks. Lineaarse regressiooni jaoks on Keskmise ruudu viga, mida nimetatakse ka MSE-ks. Matemaatiliselt on see:
kus:
kas kaalud on nii 
viitab prognoositud väärtusele- y on tegelikud väärtused
- m on vaatluste arv
viitab prognoositud väärtuselePange tähele, et 
tähendab, et see kasutab maatriksite transponeerimist. The 
on keskmise matemaatiline tähistus.
Eesmärk on leida parim 
mis vähendavad MSE-d
Kui keskmine viga on suur, tähendab see, et mudel töötab halvasti ja kaalud pole õigesti valitud. Kaalude korrigeerimiseks peate kasutama optimeerijat. Traditsioonilist optimeerijat nimetatakse Gradiendi laskumine.
Gradiendi laskumine võtab tuletise ja vähendab või suurendab kaalu. Kui tuletis on positiivne, vähendatakse kaalu. Kui tuletis on negatiivne, siis kaal suureneb. Mudel värskendab kaalusid ja arvutab vea uuesti. Seda protsessi korratakse seni, kuni viga enam ei muutu. Iga protsessi nimetatakse an iteratsioon. Pealegi korrutatakse gradiendid õppimiskiirusega. See näitab õppimise kiirust.
Kui õppimiskiirus on liiga väike, kulub algoritmi ühtlustamiseks väga kaua aega (st nõuab palju iteratsioone). Kui õppimiskiirus on liiga kõrge, ei pruugi algoritm kunagi läheneda.
Ülaltoodud pildilt näete, et mudel kordab protsessi umbes 20 korda enne, et leida kaaludele stabiilne väärtus, saavutades seega väikseima vea.
Pange tähele, et, ei ole viga võrdne nulliga, vaid stabiliseerub 5 ümber. See tähendab, et mudel teeb tüüpiliseks veaks 5. Kui soovite viga vähendada, peate mudelisse lisama rohkem teavet (nt rohkem muutujaid) või kasutama erinevaid hinnanguid. .
Mäletate esimest võrrandit
Lõplikud kaalud on 3.8 ja 2.78. Allolev video näitab teile, kuidas gradiendiga laskumine optimeerib selle kaalu leidmiseks kaotusfunktsiooni
Kuidas treenida TensorFlow abil lineaarset regressiooni
Nüüd, kui olete kapoti taga toimuvast paremini aru saanud, olete valmis kasutama TensorFlow pakutavat hindaja API-d, et treenida oma esimest lineaarset regressiooni TensorFlow abil.
Kasutate Bostoni andmestikku, mis sisaldab järgmisi muutujaid
| krim | kuritegevuse tase elaniku kohta linnade kaupa |
|---|---|
| zn | üle 25,000 XNUMX ruutjalga kruntidele tsoneeritud elamumaa osakaal. |
| indus | mitte-jaekaubanduse 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ööhõivekeskuseni |
| maks | täisväärtuslik kinnisvaramaksumäär 10,000 XNUMX dollari kohta |
| ptratio | õpilaste ja õpetajate suhe linnade kaupa |
| medv | Omaniku kasutuses olevate kodude mediaanväärtus tuhandetes dollarites |
Loote kolm erinevat andmekogumit:
| andmestik | eesmärk | kujundada |
|---|---|---|
| koolitus | Treenige modelli ja hankige raskused | 400, 10 |
| Hindamine | Hinnake mudeli toimivust nähtamatute andmete põhjal | 100, 10 |
| Ennusta | Kasutage mudelit maja väärtuse ennustamiseks uute andmete põhjal | 6, 10 |
Eesmärk on kasutada andmestiku funktsioone maja väärtuse ennustamiseks.
Õpetuse teises osas saate teada, kuidas kasutada TensorFlow kolmel erineval viisil andmete importimiseks:
- Pandadega
- koos Nuhklik
- Ainult TF
Pange tähele, et kõik valikud pakkuda samu tulemusi.
Õpid, kuidas kasutada kõrgetasemelist API-d TensorFlow lineaarse regressioonimudeli koostamiseks ja hindamiseks. Kui kasutasite madala taseme API-t, pidite käsitsi määratlema:
- Kaotuse funktsioon
- Optimeerimine: gradient laskumine
- Maatriksite korrutamine
- Graafik ja tensor
See on algajale tüütu ja keerulisem.
Pandad
Mudeli koolitamiseks peate importima vajalikud teegid.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Step 1) Importige andmed rakendusega panda.
Määrate veergude nimed ja salvestate need veergudesse COLUMNS. Andmete importimiseks saate 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, names=VEERUD)
test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True,skiprows=1, names=VEERUD)
ennustamise_komplekt = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, names=VEERUND)
Saate printida andmete kuju.
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, sisaldub andmekogumis. Seega peate määratlema kaks muud loendit. Üks sisaldab ainult funktsioone ja teine ainult sildi nime. Need kaks loendit näitavad teie hindajale, millised on andmestiku funktsioonid ja mis veeru nimi on silt
Seda tehakse alloleva koodiga.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Step 2) Teisenda andmed
Peate numbrilised muutujad õigesse vormingusse teisendama. Tensorflow pakub meetodit pideva muutuja teisendamiseks: tf.feature_column.numeric_column().
Eelmises etapis määratlete funktsioonide loendi, mida soovite mudelisse lisada. Nüüd saate seda loendit kasutada nende arvulisteks andmeteks teisendamiseks. Kui soovite oma mudelis funktsioone välistada, jätke loendisse FEATURES üks või mitu muutujat, enne kui loote tunnuse_cols.
Pange tähele, et te kasutate Python loendi mõistmine loendiga FUNKTSIOONID, et luua uus loend nimega funktsiooni_cols. See aitab vältida üheksakordset kirjutamist tf.feature_column.numeric_column(). Loendi mõistmine on kiirem ja puhtam viis uute loendite loomiseks
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Step 3) Määratlege hindaja
Selles etapis peate määrama hinnangu. Tensorflow pakub praegu 6 eelehitatud hindajat, sealhulgas 3 klassifitseerimisülesande jaoks ja 3 TensorFlow regressiooniülesande jaoks:
- Regressor
- DNNRegressor
- Lineaarne regressor
- DNNLineaCombinedRegressor
- klassifitseerima
- DNNC-klassifikaator
- Lineaarne klassifikaator
- DNNLineaCombinedClassifier
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öökataloogis automaatselt faili nimega rong. Peate kasutama seda teed, et pääseda juurde Tensorboardile, nagu on näidatud allolevas 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': <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 keeruline osa on mudeli toitmise viis. Tensorflow on loodud töötama paralleelse andmetöötluse ja väga suure andmestikuga. Masinaressursside piiratuse tõttu ei ole võimalik mudelit kõigi andmetega korraga ette anda. Selleks peate iga kord söötma hulga andmeid. Pange tähele, et me räägime tohutust andmekogumist, mis sisaldab miljoneid või rohkem kirjeid. Kui te partii ei lisa, tekib mälutõrge.
Näiteks kui teie andmed sisaldavad 100 vaatlust ja määrate partii suuruseks 10, tähendab see, et mudel näeb iga iteratsiooni kohta 10 vaatlust (10*10).
Kui mudel on kõik andmed näinud, lõpetab see ühe epohh. Epohh määrab, mitu korda soovite, et mudel andmeid näeks. Parem on määrata selle sammu väärtuseks mitte ükski ja lasta mudelil sooritada korduste arv.
Teine lisatav teave on see, kui soovite andmeid enne iga iteratsiooni segada. Koolituse ajal on oluline andmeid segamini ajada, et mudel ei õpiks konkreetset andmestiku mustrit. Kui mudel õpib tundma andmete aluseks oleva mustri üksikasju, on tal raskusi nähtamatute andmete prognoosi üldistamisega. Seda nimetatakse üleliigne. Mudel toimib treeningandmetega hästi, kuid ei suuda nägemata andmete puhul õigesti ennustada.
TensorFlow muudab need kaks sammu lihtsaks. Kui andmed lähevad konveierisse, teab ta, mitu vaatlust ta vajab (partii) ja kas ta peab andmeid segama.
Tensorflow'le mudeli söötmise juhendamiseks võite kasutada käsku pandas_input_fn. See objekt vajab 5 parameetrit:
- x: funktsiooni andmed
- y: sildi andmed
- partii_suurus: partii. Vaikimisi 128
- num_epoch: epohhi arv, vaikimisi 1
- segamine: segage andmeid või mitte. Vaikimisi puudub
Peate mudelit mitu korda söötma, et määratleda funktsioon selle protsessi kordamiseks. 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 järgmine:
- Treeni modelli
- Hinnake mudelit teises andmekogumis
- Tehke ennustus
Tensorflow hindaja pakub kolme erinevat funktsiooni, et need kolm sammu hõlpsalt läbi viia.
Step 4): Treeni modelli
Mudeli hindamiseks saate kasutada hindajarongi. Rongi hindaja vajab sisendit_fn ja mitmeid samme. Saate mudeli söötmiseks kasutada ülal loodud funktsiooni. Seejärel juhendate mudelit 1000 korda itereerima. Pange tähele, et te ei määra epohhide arvu, vaid lasete mudelil itereerida 1000 korda. Kui määrate ajastu arvuks 1, siis mudel kordab 4 korda: Treeningkomplektis on 400 kirjet ja partii suurus on 128
- 128 rida
- 128 rida
- 128 rida
- 16 rida
Seetõttu on lihtsam seada epohhi arvuks mitte ükski ja määratleda iteratsioonide arv, nagu on näidatud allolevas 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 = 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.
Saate kontrollida, kas Tensorboard kasutab järgmist käsku:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Step 5) Hinnake oma mudelit
Saate hinnata oma mudeli sobivust testikomplektile alloleva 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: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
Saate kaotuse printida alloleva koodiga:
loss_score = ev["loss"]
print("Loss: {0:f}".format(loss_score))
Väljund
Loss: 3215.895996
Mudelil on kadu 3215. Saate vaadata koondstatistikat, et saada aimu, kui suur viga on.
training_set['medv'].describe()
Väljund
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
Ülaltoodud koondstatistikast saate teada, et maja keskmine hind on 22 tuhat, mille miinimumhind on 9 tuhat ja maksimaalne 50 tuhat. Mudel teeb tüüpiliseks veaks 3k dollarit.
Step 6) Tehke ennustus
Lõpuks saate kasutada 6 Bostoni maja väärtuse hindamiseks prognoosijat TensorFlow.
y = estimator.predict(
input_fn=get_input_fn(prediction_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Hinnanguliste 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-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)]
Mudel prognoosib järgmisi väärtusi:
| maja | Ennustus | |
|---|---|---|
| 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 tegelikku väärtust. Süvaõppe õpetuses proovite ületada lineaarset mudelit
Numbe lahendus
Selles jaotises selgitatakse, kuidas koolitada mudelit, kasutades andmete edastamiseks numpy hindajat. Meetod on sama, välja arvatud see, et kasutate numpy_input_fn hindajat.
training_set_n = pd.read_csv(“E:/boston_train.csv”).values
test_set_n = pd.read_csv(“E:/boston_test.csv”).values
ennustus_set_n = pd.read_csv(“E:/boston_predict.csv”).values
Step 1) Importige andmed
Kõigepealt peate eristama funktsiooni muutujaid sildist. Peate seda tegema koolitusandmete ja hindamise jaoks. Andmete jagamiseks on kiirem defineerida funktsioon.
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
Funktsiooni abil saate sildi eraldada rongi/andmekogumi funktsioonidest
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Peate ennustusandmestiku viimase veeru välja jätma, 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)
Funktsioonide veerge saate koostada järgmiselt.
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Hindaja on defineeritud nagu varem, sina annad juhised funktsioonide veergudele ja kuhu graafik salvestada.
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': <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}
Saate kasutada numpy estimapori andmete sisestamiseks mudelisse ja seejärel mudeli treenimiseks. Pange tähele, et loetavuse hõlbustamiseks määratleme funktsiooni input_fn enne.
# 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 = 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>
Oma mudeli hindamiseks kordate sama sammu erineva hinnanguga
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: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}
Lõpuks saate ennustuse 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-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 lahendus
Viimane osa on pühendatud TensorFlow lahendusele. See meetod on pisut keerulisem kui teine.
Pange tähele, et kui kasutate Jupyter märkmik, peate selle seansi käivitamiseks taaskäivitama ja kerneli puhastama.
TensorFlow on loonud suurepärase tööriista andmete edastamiseks torusse. Selles jaotises saate ise luua funktsiooni input_fn.
Step 1) Määrake andmete tee ja vorming
Esiteks deklareerite kaks muutujat csv-faili teega. Pange tähele, et teil on kaks faili, üks treeningkomplekti ja teine testimiskomplekti jaoks.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Seejärel peate määratlema csv-failis veerud, mida soovite kasutada. Kasutame kõik ära. Pärast seda peate deklareerima muutuja tüübi.
Floats muutuja on defineeritud [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]]
Step 2) Määratlege funktsioon input_fn
Funktsiooni saab jagada kolmeks osaks:
- Importige andmed
- Loo iteraator
- Tarbi andmeid
Allpool on üldine kood funktsiooni määratlemiseks. Koodi selgitatakse hiljem
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
** Importige andmed**
CSV-faili puhul loeb andmestikumeetod ühe rea korraga. Andmestiku koostamiseks peate kasutama objekti TextLineAndmekogum. Teie andmestikul on päis, seega peate esimese rea vahelejätmiseks kasutama käsku skip(1). Sel hetkel loete ainult andmeid ja välistate konveieri päise. Mudeli söötmiseks peate funktsioonid sildist eraldama. Andmete mis tahes teisenduse rakendamiseks kasutatav meetod on kaart.
See meetod kutsub välja funktsiooni, mille loote, et anda juhiseid andmete teisendamiseks. Lühidalt öeldes peate edastama andmed TextLineAndmestikuobjekt, välistage päis ja rakendage teisendust, mida juhendab funktsioon.Koodi selgitus
- tf.data.TextLineDataset(data_file): see rida loeb csv-faili
- .skip(1) : jätab päise vahele
- .map(parse_csv)): sõelub kirjed tensoriteksPeate määratlema funktsiooni kaardiobjekti juhendamiseks. Seda funktsiooni saab kutsuda parse_csv.
See funktsioon analüüsib csv-faili meetodiga tf.decode_csv ning deklareerib funktsioonid ja sildi. Funktsioone saab deklareerida sõnastiku või korteegina. Kasutad sõnastiku meetodit, sest see on mugavam.Koodi selgitus
- tf.decode_csv(value, record_defaults= RECORDS_ALL): meetod decode_csv kasutab TextLineAndmekogum csv-faili lugemiseks. record_defaults juhendab TensorFlow'd veergude tüübi kohta.
- dict(zip(_CSV_COLUMNS, veerud)): täitke sõnastik kõigi selle andmetöötluse käigus ekstraheeritud veergudega
- features.pop('median_house_value'): Sihtmuutuja välistamine funktsioonimuutuja hulgast ja sildimuutuja loomine
Andmekogum vajab tensorite iteratiivseks söötmiseks täiendavaid elemente. Tõepoolest, peate lisama meetodi korduse, et andmestik saaks mudeli söötmiseks lõputult jätkata. Kui te meetodit ei lisa, kordab mudel ainult ühe korra ja annab seejärel veateate, kuna konveierisse ei sisestata rohkem andmeid.
Pärast seda saate partii suurust kontrollida partii meetodil. See tähendab, et annate andmestikule teada, kui palju andmeid soovite iga iteratsiooni puhul konveieris edastada. Kui määrate suure partii suuruse, on mudel aeglane.
Samm 3) Loo iteraator
Nüüd olete teiseks sammuks valmis: looge iteraator andmestiku elementide tagastamiseks.
Lihtsaim viis operaatori loomiseks on meetod make_one_shot_iterator.
Pärast seda saate iteraatorist funktsioone ja silte luua.
4. samm) tarbige andmeid
Saate kontrollida, mis juhtub funktsiooniga input_fn. Andmete tarbimiseks peate funktsiooni seansi ajal kutsuma. Proovige partii suurust 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))
Step 4) Määratlege funktsiooni veerg
Numbrilised veerud 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 ühendama kõik muutujad ämbrisse
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Step 5) Ehitage mudel
Mudelit saate treenida hinnangulise LinearRegressor abil.
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': <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}
Argumendi kirjutamise lubamiseks funktsioonis inpu_fn peate kasutama lambda-funktsiooni. Kui te ei kasuta a lambda funktsioon, te ei saa modelli koolitada.
# 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 = 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>
Saate hinnata oma mudeli sobivust testikomplektile alloleva 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: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
Viimane samm on väärtuse ennustamine tunnuste maatriksite väärtuse põhjal. Saate kirjutada sõnastikku väärtustega, mida soovite ennustada. Teie mudelil on 9 funktsiooni, seega peate igaühe jaoks andma väärtuse. Mudel annab ennustuse igaühe kohta.
Allolevasse koodi kirjutasite iga funktsiooni väärtused, mis sisalduvad df_predict csv-failis.
Peate kirjutama uue funktsiooni input_fn, kuna andmekogumil pole silti. Andmestikust saate kasutada 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 prindite 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-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)})
kokkuvõte
Modelli koolitamiseks peate:
- Määratlege omadused: Sõltumatud muutujad: X
- Määrake silt: Sõltuv muutuja: y
- Ehitage rong/katsekomplekt
- Määrake algkaal
- Defineerige kadufunktsioon: MSE
- Mudeli optimeerimine: gradient laskumine
- Määratlege:
- Õppimise määr
- Ajastu arv
- Partii suurus
Selles õpetuses õppisite kasutama kõrgetasemelist API-d lineaarse regressiooni TensorFlow hinnangu jaoks. Peate määratlema:
- Funktsiooniveerud. Kui pidev: tf.feature_column.numeric_column(). Saate täita loendi pythoni loendi mõistmisega
- Hindaja: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Funktsioon andmete, partii suuruse ja epohhi importimiseks: input_fn()
Pärast seda olete valmis treenima, hindama ja ennustama kasutades train(), hindama() ja ennustama()
