Lineārā regresija ar TensorFlow (piemēri)

Satura rādītājs:

Anonim

Kas ir lineārā regresija?

Lineārā regresija ir pieeja statistikā divu mainīgo attiecību modelēšanai. Šī modelēšana tiek veikta starp skalāru reakciju un vienu vai vairākiem paskaidrojošiem mainīgajiem. Attiecību ar vienu paskaidrojošo mainīgo sauc par vienkāršu lineāro regresiju un vairāk nekā vienam paskaidrojošajam mainīgajam - vairāku lineāru regresiju.

TensorFlow nodrošina rīkus, lai pilnībā kontrolētu aprēķinus. Tas tiek darīts ar zema līmeņa API. Papildus tam TensorFlow ir aprīkots ar plašu API klāstu, lai veiktu daudzus mašīnmācīšanās algoritmus. Šī ir augsta līmeņa API. TensorFlow tos sauc par novērtētājiem

  • Zema līmeņa API: izveidojiet arhitektūru, modeļa optimizāciju no jauna. Iesācējam tas ir sarežģīti
  • Augsta līmeņa API: definējiet algoritmu. Tas ir vieglāk draudzīgs. TensorFlow nodrošina rīku kopas zvanu aprēķinātāju, lai izveidotu, apmācītu, novērtētu un veiktu prognozi.

Šajā apmācībā jūs izmantosiet tikai aprēķinātājus . Aprēķini ir ātrāki un tos ir vieglāk īstenot. Apmācības pirmajā daļā ir paskaidrots, kā izmantot gradienta nolaišanās optimizētāju, lai apmācītu lineāro regresiju TensorFlow. Otrajā daļā jūs izmantosiet Bostonas datu kopu, lai prognozētu mājas cenu, izmantojot TensorFlow novērtētāju.

Lejupielādējiet Bostonas datu kopu

Šajā TensorFlow regresijas apmācībā jūs uzzināsiet:

  • Kas ir lineārā regresija?
  • Kā apmācīt lineārās regresijas modeli
  • Kā apmācīt lineāro regresiju ar TensorFlow
  • Pandas
  • Numpy risinājums
  • Tensorflow šķīdums

Kā apmācīt lineārās regresijas modeli

Pirms sākam apmācīt modeli, apskatīsim, kas ir lineārā regresija.

Iedomājieties, ka jums ir divi mainīgie, x un y, un jūsu uzdevums ir paredzēt vērtību, zinot vērtību. Ja uzzīmējat datus, varat redzēt pozitīvu saistību starp savu neatkarīgo mainīgo x un atkarīgo mainīgo y.

Jūs varat novērot, ja x = 1, y aptuveni būs vienāds ar 6 un, ja x = 2, y būs aptuveni 8,5.

Šī nav ļoti precīza metode un pakļauti kļūdām, īpaši ar datu kopu ar simtiem tūkstošu punktu.

Lineārā regresija tiek vērtēta ar vienādojumu. Mainīgo y izskaidro viens vai daudzi kovariāti. Jūsu piemērā ir tikai viens atkarīgs mainīgais. Ja jums ir jāraksta šis vienādojums, tas būs:

Ar:

  • ir svars, kas saistīts ar x
  • ir modeļa atlikums vai kļūda. Tas ietver to, ko modelis nevar iemācīties no datiem

Iedomājieties, ka jūs atbilstat modelim un atrodat šādu risinājumu:

  • = 3,8
  • = 2,78

Varat aizstāt šos skaitļus vienādojumā, un tas kļūst par:

y = 3,8 + 2,78x

Tagad jums ir labāks veids, kā atrast y vērtības. Tas ir, jūs varat aizstāt x ar jebkuru vērtību, kuru vēlaties paredzēt y. Zemāk redzamajā attēlā vienādojumā mums ir jāaizstāj x ar visām datu kopas vērtībām un jānorāda rezultāts.

Sarkanā līnija apzīmē uzstādīto vērtību, tas ir, y vērtības katrai x vērtībai. Lai prognozētu y, jums nav jāredz x vērtība, katram x ir kāds, kas pieder pie sarkanās līnijas. Varat arī paredzēt, ja x vērtība pārsniedz 2!

Ja vēlaties paplašināt lineāro regresiju ar vairāk kovariātiem, varat modelim pievienot vairāk mainīgo. Atšķirība starp tradicionālo analīzi un lineāro regresiju ir lineārā regresija, kurā aplūkots, kā y reaģēs uz katru mainīgo x neatkarīgi.

Apskatīsim piemēru. Iedomājieties, ka vēlaties prognozēt saldējuma veikala pārdošanas apjomus. Datu kopa satur atšķirīgu informāciju, piemēram, laika apstākļus (ti, lietainu, saulainu, mākoņainu), klientu informāciju (ti, algu, dzimumu, ģimenes stāvokli).

Tradicionālā analīze mēģinās paredzēt pārdošanu, pieņemsim, aprēķinot vidējo vērtību katram mainīgajam un mēģinot novērtēt pārdošanu dažādiem scenārijiem. Tas novedīs pie sliktām prognozēm un ierobežos analīzi tikai izvēlētajā scenārijā.

Ja izmantojat lineāro regresiju, varat uzrakstīt šo vienādojumu:

Algoritms atradīs labāko risinājumu svariem; tas nozīmē, ka tas centīsies samazināt izmaksas (starpība starp uzstādīto līniju un datu punktiem).

Kā darbojas algoritms

Algoritms būs izvēlēties izlases numuru katram un nomainīt vērtību x, lai iegūtu paredzamo vērtību y. Ja datu kopai ir 100 novērojumi, algoritms aprēķina 100 paredzētās vērtības.

Mēs varam aprēķināt kļūdu, kas atzīmēta modelī, kas ir starpība starp prognozēto un reālo vērtību. Pozitīva kļūda nozīmē, ka modelis nepietiekami novērtē y prognozi, un negatīva kļūda nozīmē, ka modelis pārvērtē y prognozi.

Jūsu mērķis ir samazināt kļūdas kvadrātu. Algoritms aprēķina kvadrātveida kļūdas vidējo lielumu. Šo soli sauc par kļūdas samazināšanu. Lineārajai regresijai ir vidējā kvadrāta kļūda , saukta arī par MSE. Matemātiski tas ir:

Kur:

  • attiecas uz prognozēto vērtību
  • y ir reālās vērtības
  • m ir novērojumu skaits

Ņemiet vērā, ka tas ir vidējā matemātiskais apzīmējums.

Mērķis ir atrast labāko, kas mazinātu MSE

Ja vidējā kļūda ir liela, tas nozīmē, ka modeļa veiktspēja ir slikta, un svari nav izvēlēti pareizi. Lai labotu svarus, jums jāizmanto optimizētājs. Tradicionālo optimizētāju sauc par gradienta nolaišanos .

Gradienta nolaišanās ņem atvasinājumu un samazina vai palielina svaru. Ja atvasinājums ir pozitīvs, svars tiek samazināts. Ja atvasinājums ir negatīvs, svars palielinās. Modelis atjauninās svaru un pārrēķinās kļūdu. Šis process tiek atkārtots, līdz kļūda vairs nemainās. Katru procesu sauc par atkārtojumu . Turklāt gradienti tiek reizināti ar mācīšanās ātrumu. Tas norāda mācīšanās ātrumu.

Ja mācīšanās ātrums ir pārāk mazs, paies ļoti ilgs laiks, līdz algoritms saplūst (ti, nepieciešams daudz atkārtojumu). Ja mācīšanās ātrums ir pārāk augsts, algoritms nekad nevar saplūst.

No iepriekš redzamā attēla var redzēt, ka modelis iepriekš atkārtoja procesu apmēram 20 reizes, lai atrastu stabilu svaru svaru, tādējādi sasniedzot zemāko kļūdu.

Ņemiet vērā , ka kļūda nav vienāda ar nulli, bet stabilizējas ap 5. Tas nozīmē, ka modelis pieļauj tipisku kļūdu 5. Ja vēlaties samazināt kļūdu, modelim jāpievieno vairāk informācijas, piemēram, vairāk mainīgo vai jāizmanto dažādi novērtētāji.

Jūs atceraties pirmo vienādojumu

Galīgie svari ir 3,8 un 2,78. Zemāk esošajā video parādīts, kā gradienta nolaišanās optimizē zaudējumu funkciju, lai atrastu šos svarus

Kā apmācīt lineāro regresiju ar TensorFlow

Tagad, kad jums ir labāka izpratne par to, kas notiek aiz pārsega, esat gatavs izmantot TensorFlow nodrošināto aplēšu API, lai apmācītu savu pirmo lineāro regresiju, izmantojot TensorFlow.

Jūs izmantosiet Bostonas datu kopu, kas ietver šādus mainīgos

krima noziedzības līmenis uz vienu iedzīvotāju pa pilsētām
zn dzīvojamās zemes daļa, kas paredzēta zonām, kuru platība pārsniedz 25 000 kv.m.
indus mazumtirdzniecības biznesa hektāru proporcija vienā pilsētā.
naks slāpekļa oksīdu koncentrācija
rm vidējais istabu skaits vienā mājoklī
vecums to īpašnieku apdzīvoto vienību īpatsvars, kas uzceltas pirms 1940. gada
dis svērtie attālumi līdz pieciem Bostonas nodarbinātības centriem
nodoklis īpašuma vērtības pilnvērtīga likme par 10 000 dolāriem
ptratio skolēnu un skolotāju attiecība pa pilsētām
medv Īpašnieku apdzīvoto māju vidējā vērtība tūkstošos dolāru

Jūs izveidosiet trīs dažādas datu kopas:

datu kopa objektīvs forma
Apmācība Apmāciet modeli un iegūstiet svarus 400, 10
Novērtēšana Novērtējiet modeļa veiktspēju uz neredzētiem datiem 100, 10
Paredzēt Izmantojiet modeli, lai prognozētu mājas vērtību pēc jauniem datiem 6, 10

Mērķi ir izmantot datu kopas funkcijas, lai prognozētu mājas vērtību.

Apmācības otrās daļas laikā jūs uzzināsiet, kā izmantot TensorFlow ar trim dažādiem datu importēšanas veidiem:

  • Ar Pandām
  • Ar Numpiju
  • Tikai TF

Ņemiet vērā, ka visas opcijas nodrošina vienādus rezultātus.

Jūs uzzināsiet, kā izmantot augsta līmeņa API, lai izveidotu, apmācītu novērtēt TensorFlow lineārās regresijas modeli. Ja izmantojāt zema līmeņa API, jums ar roku bija jādefinē:

  • Zaudēšanas funkcija
  • Optimizēt: gradienta nolaišanās
  • Matricu reizināšana
  • Grafiks un tenors

Iesācējiem tas ir garlaicīgs un sarežģītāks.

Pandas

Lai apmācītu modeli, jums jāimportē nepieciešamās bibliotēkas.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

1. solis) Importējiet datus ar pandu.

Jūs definējat kolonnu nosaukumus un saglabājat tos kolonnās. Datu importēšanai varat izmantot 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, nosaukumi = COLUMNS)

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

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

Varat izdrukāt datu formu.

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

Rezultāts

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

Ņemiet vērā, ka etiķete, ti, jūsu y, ir iekļauta datu kopā. Tāpēc jums ir jādefinē vēl divi saraksti. Viens satur tikai iezīmes un viens ar etiķetes nosaukumu. Šie divi saraksti jūsu aprēķinātājam pateiks, kādas ir datu kopas funkcijas un kāds slejas nosaukums ir iezīme

Tas tiek darīts ar zemāk esošo kodu.

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

2. solis. Konvertējiet datus

Jums jāpārvērš skaitliskie mainīgie pareizajā formātā. Tensorflow nodrošina metodi nepārtraukta mainīgā konvertēšanai: tf.feature_column.numeric_column ().

Iepriekšējā darbībā jūs definējat objekta sarakstu, kuru vēlaties iekļaut modelī. Tagad jūs varat izmantot šo sarakstu, lai tos pārveidotu skaitliskos datos. Ja vēlaties izslēgt funkcijas savā modelī, pirms iezīmju_kopu izveidošanas droši nometiet vienu vai vairākus mainīgos FEATURES sarakstā.

Ņemiet vērā, ka izmantosiet Python saraksta izpratni ar sarakstu FEATURES, lai izveidotu jaunu sarakstu ar nosaukumu feature_cols. Tas palīdz izvairīties no deviņu reižu rakstīšanas tf.feature_column.numeric_column (). Sarakstu izpratne ir ātrāks un tīrāks veids, kā izveidot jaunus sarakstus

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

3. solis. Definējiet novērtētāju

Šajā solī jums jādefinē aprēķinātājs. Tensorflow pašlaik nodrošina 6 iepriekš izveidotus novērtētājus, tostarp 3 klasifikācijas uzdevumam un 3 TensorFlow regresijas uzdevumam:

  • Regresors
    • DNNRegresors
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Klasifikators
    • DNNKlasifikators
    • Lineārais klasifikators
    • DNNLineaCombinedClasizer

Šajā apmācībā jūs izmantosiet lineāro regresoru. Lai piekļūtu šai funkcijai, jums jāizmanto tf.estimator.

Funkcijai nepieciešami divi argumenti:

  • feature_columns: satur mainīgos, kas jāiekļauj modelī
  • modelis_dir: ceļš grafika glabāšanai, modeļa parametru saglabāšanai utt

Tensorflow automātiski izveidos failu ar nosaukumu vilciens jūsu darba direktorijā. Jums ir jāizmanto šis ceļš, lai piekļūtu Tensorboard, kā parādīts zemāk esošajā TensorFlow regresijas piemērā.

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

Rezultāts

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}

Viltīgā daļa ar TensorFlow ir veids, kā barot modeli. Tensorflow ir paredzēts darbam ar paralēlu skaitļošanu un ļoti lielu datu kopu. Iekārtas resursu ierobežotības dēļ nav iespējams padot modeli ar visiem datiem vienlaikus. Lai to izdarītu, jums katru reizi jāievada datu pakete. Ņemiet vērā, ka mēs runājam par milzīgu datu kopu ar miljoniem vai vairāk ierakstiem. Ja nepievienosiet partiju, tiks izveidota atmiņas kļūda.

Piemēram, ja jūsu datos ir 100 novērojumi un jūs definējat partijas lielumu 10, tas nozīmē, ka modelis katrai iterācijai redzēs 10 novērojumus (10 * 10).

Kad modelis ir redzējis visus datus, tas pabeidz vienu laikmetu . Laikmets nosaka, cik reizes vēlaties, lai modelis redz datus. Labāk iestatiet šo soli uz nevienu un ļaujiet modelim veikt atkārtotu reižu skaitu.

Otra informācija, kas jāpievieno, ir, ja vēlaties, lai dati tiktu sajaukti pirms katras atkārtošanas. Apmācības laikā ir svarīgi sajaukt datus, lai modelis neiemācītos konkrētu datu kopas modeli. Ja modelis uzzina detalizētu informāciju par datu pamatā esošo modeli, tam būs grūtības vispārināt neredzēto datu prognozi. To sauc par pārspīlēšanu . Modelis labi darbojas pēc treniņa datiem, bet nevar pareizi paredzēt neredzētus datus.

TensorFlow atvieglo šo divu darbību veikšanu. Kad dati nonāk cauruļvadā, viņi zina, cik daudz novērojumu tiem ir nepieciešams (pakete) un vai tiem ir jāmaina dati.

Lai norādītu Tensorflow par modeļa padevi, varat izmantot pandas_input_fn. Šim objektam ir nepieciešami 5 parametri:

  • x: objekta dati
  • y: etiķetes dati
  • batch_size: partija. Pēc noklusējuma 128
  • num_epoch: laikmeta skaits pēc noklusējuma 1
  • jaukt: jaukt datus vai nejaukt tos. Pēc noklusējuma nav

Jums ir jābaro modelis daudzas reizes, lai jūs definētu funkciju, lai atkārtotu šo procesu. visa šī funkcija 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)

Parastā modeļa veiktspējas novērtēšanas metode ir:

  • Apmāciet modeli
  • Novērtējiet modeli citā datu kopā
  • Veikt pareģošanu

Tensorflow aprēķinātājs nodrošina trīs dažādas funkcijas, lai viegli veiktu šos trīs soļus.

4. solis) : apmāciet modeli

Lai novērtētu modeli, varat izmantot novērtētāja vilcienu. Vilciena aprēķinātājam ir nepieciešama ievade_fn un vairāki soļi. Modeļa padevei varat izmantot iepriekš izveidoto funkciju. Pēc tam jūs norādāt modelim atkārtot 1000 reizes. Ņemiet vērā, ka jūs nenorādat laikmetu skaitu, bet modelim ļaujat atkārtoties 1000 reizes. Ja jūs iestatāt laikmeta skaitu uz 1, modelis atkārtosies 4 reizes: apmācības komplektā ir 400 ierakstu, un partijas lielums ir 128

  1. 128 rindas
  2. 128 rindas
  3. 128 rindas
  4. 16 rindas

Tāpēc ir vieglāk iestatīt laikmeta skaitu uz nevienu un noteikt atkārtojuma skaitu, kā parādīts zemāk esošajā TensorFlow klasifikācijas piemērā.

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

Rezultāts

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.

Jūs varat pārbaudīt, vai Tensorboard būs šāda komanda:

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

5. solis) Novērtējiet savu modeli

Jūs varat novērtēt sava modeļa piemērotību testa komplektam, izmantojot šādu kodu:

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

Rezultāts

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

Zaudējumu var izdrukāt ar zemāk redzamo kodu:

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

Rezultāts

Loss: 3215.895996

Modeļa zaudējumi ir 3215. Jūs varat pārbaudīt kopsavilkuma statistiku, lai iegūtu priekšstatu par kļūdas lielumu.

training_set['medv'].describe()

Rezultāts

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

No iepriekš apkopotās statistikas jūs zināt, ka vidējā mājas cena ir 22 tūkstoši, ar minimālo cenu 9 tūkstoši un maksimāli 50 tūkstošus. Modelis pieļauj tipisku 3k dolāru kļūdu.

6. solis. Veiciet prognozi

Visbeidzot, jūs varat izmantot aprēķinātāju TensorFlow prognozēt, lai novērtētu 6 Bostonas māju vērtību.

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

Lai drukātu aprēķinātās vērtības, varat izmantot šo kodu:

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

Rezultāts

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

Modelis paredz šādas vērtības:

Māja

Prognozēšana

1

32.29

2

18.96

3

27.27

4

29.29

5

16.43

7

21.46

Ņemiet vērā, ka mēs nezinām uzņēmuma patieso vērtību. Dziļo mācību apmācībā jūs mēģināsiet pārspēt lineāro modeli

Numpy risinājums

Šajā sadaļā ir paskaidrots, kā apmācīt modeli, izmantojot skaitļu aprēķinātāju, lai ievadītu datus. Metode ir tā pati, izņemot to, ka izmantosiet numpy_input_fn aprēķinātāju.

training_set_n = pd.read_csv ("E: /boston_train.csv"). vērtības

test_set_n = pd.read_csv ("E: /boston_test.csv"). vērtības

prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). vērtības

1. darbība. Importējiet datus

Pirmkārt, jums ir jānošķir iezīmju mainīgie. Tas jādara apmācības datiem un novērtēšanai. Datu sadalīšanai ir ātrāk definēt funkciju.

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

Varat izmantot funkciju, lai sadalītu etiķeti no vilciena funkcijām / novērtētu datu kopu

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

Jums jāizslēdz prognozēšanas datu kopas pēdējā kolonna, jo tajā ir tikai NaN

x_predict = prediction_set_n[:, :-2]

Apstipriniet masīva formu. Ņemiet vērā, ka etiķetei nevajadzētu būt izmēram, tas nozīmē (400,).

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

Rezultāts

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

Funkciju kolonnas varat izveidot šādi:

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

Aprēķinātājs ir definēts tāpat kā iepriekš, jūs norādāt funkciju kolonnas un vietu, kur saglabāt diagrammu.

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

Rezultāts

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}

Lai ievadītu datus modelī un pēc tam apmācītu modeli, varat izmantot numpy becslēju. Ņemiet vērā, ka mēs iepriekš definējam input_fn funkciju, lai atvieglotu lasāmību.

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

Rezultāts

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

Lai novērtētu savu modeli, jūs atkārtojat to pašu darbību ar citu novērtētāju

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)

Rezultāts

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}

Visbeidzot, jūs varat aprēķināt prognozi. Tam vajadzētu būt līdzīgam pandām.

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

Rezultāts

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 šķīdums

Pēdējā sadaļa ir veltīta TensorFlow risinājumam. Šī metode ir nedaudz sarežģītāka nekā otra.

Ņemiet vērā, ka, ja izmantojat Jupyter piezīmjdatoru, jums ir jārestartē un jātīra kodols, lai palaistu šo sesiju.

TensorFlow ir izveidojis lielisku rīku datu pārsūtīšanai cauruļvadā. Šajā sadaļā jūs pats izveidosiet ievades_fn funkciju.

1. solis. Definējiet ceļu un datu formātu

Pirmkārt, jūs deklarējat divus mainīgos ar csv faila ceļu. Ņemiet vērā, ka jums ir divi faili, viens apmācības komplektam un viens testēšanas komplektam.

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

Pēc tam no csv faila jādefinē kolonnas, kuras vēlaties izmantot. Mēs izmantosim visu. Pēc tam jums jādeklarē mainīgā tips.

Mainīgo mainīgo nosaka ar [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. solis. Definējiet ievades_fn funkciju

Funkciju var sadalīt trīs daļās:

  1. Importējiet datus
  2. Izveidojiet iteratoru
  3. Patērē datus

Zemāk ir vispārīgais kods, lai noteiktu funkciju. Kods tiks paskaidrots pēc

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

** Importējiet datus **

CSV failam datu kopas metode nolasa vienu rindu vienlaikus. Lai izveidotu datu kopu, jums jāizmanto objekts TextLineDataset. Jūsu datu kopai ir galvene, tāpēc, lai izlaistu pirmo rindu, jums jāizmanto skip (1). Šajā brīdī jūs lasāt tikai datus un izslēdzat galveni cauruļvadā. Lai padotu modeli, jums jāatdala funkcijas no etiķetes. Metode, ko izmanto jebkuras transformācijas veikšanai datiem, ir karte.

Šī metode izsauc funkciju, kuru jūs izveidosiet, lai norādītu, kā pārveidot datus. Īsumā jums jānodod dati objektā TextLineDataset, jāizslēdz galvene un jāpielieto transformācija, kuru uzdod funkcija.

  • tf.data.TextLineDataset (data_file): Šajā rindā tiek lasīts csv fails
  • .skip (1): izlaidiet galveni
  • .map (parse_csv)): parsējiet ierakstus tenoros. Lai norādītu kartes objektu, jums jānosaka funkcija. Šo funkciju varat saukt parse_csv.

Šī funkcija parsē csv failu ar metodi tf.decode_csv un deklarē funkcijas un iezīmi. Funkcijas var deklarēt kā vārdnīcu vai abas. Jūs izmantojat vārdnīcas metodi, jo tā ir ērtāka. Koda skaidrojums

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): metode decode_csv izmanto TextLineDataset izeju, lai lasītu csv failu. record_defaults norāda TensorFlow par kolonnu veidu.
  • dict (zip (_CSV_COLUMNS, kolonnas)): aizpildiet vārdnīcu ar visām kolonnām, kas iegūtas šīs datu apstrādes laikā
  • features.pop ('median_house_value'): Izslēdziet mērķa mainīgo no objekta mainīgā un izveidojiet iezīmju mainīgo

Datu kopai ir vajadzīgi papildu elementi, lai atkārtoti barotu tenorus. Patiešām, jums jāpievieno metodes atkārtojums, lai datu kopa varētu turpināties bezgalīgi, lai padotu modeli. Ja nepievienojat metodi, modelis atkārtos tikai vienu reizi un pēc tam radīs kļūdu, jo vairāk datu netiek ievadīti.

Pēc tam jūs varat kontrolēt partijas lielumu, izmantojot partijas metodi. Tas nozīmē, ka jūs sakāt datu kopai, cik daudz datu vēlaties nodot katrā atkārtojumā. Ja iestatāt lielu partijas lielumu, modelis būs lēns.

3. solis) Izveidojiet iteratoru

Tagad esat gatavs otrajam solim: izveidojiet iteratoru, lai atgrieztu datu kopas elementus.

Vienkāršākais operatora izveides veids ir metode make_one_shot_iterator.

Pēc tam jūs varat izveidot funkcijas un etiķetes no iteratora.

4. solis. Patērējiet datus

Varat pārbaudīt, kas notiek ar input_fn funkciju. Lai patērētu datus, sesijā ir jāizsauc funkcija. Jūs mēģināt ar partijas lielumu, kas vienāds ar 1.

Ņemiet vērā, ka tas izdrukā vārdnīcas funkcijas un etiķeti kā masīvu.

Tajā tiks parādīta csv faila pirmā rinda. Jūs varat mēģināt palaist šo kodu daudzas reizes ar dažādu partijas lielumu.

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)

Rezultāts

({'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. solis. Definējiet objekta kolonnu

Skaitliskās kolonnas jādefinē šādi:

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

Ņemiet vērā, ka visi mainīgie ir jāapvieno spainī

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

5. solis. Izveidojiet modeli

Jūs varat apmācīt modeli ar novērtētāju LinearRegressor.

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

Rezultāts

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}

Lai ļautu ierakstīt argumentu funkcijā inpu_fn, jums jāizmanto lambda funkcija. Ja neizmantojat lambda funkciju, jūs nevarat apmācīt modeli.

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

Rezultāts

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

Jūs varat novērtēt sava modeļa piemērotību testa komplektā ar šādu kodu:

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

Rezultāts

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

Pēdējais solis ir vērtības prognozēšana, pamatojoties uz funkciju matricu vērtību. Varat uzrakstīt vārdnīcu ar vērtībām, kuras vēlaties paredzēt. Jūsu modelim ir 9 funkcijas, tāpēc jums katram jānorāda vērtība. Modelis sniegs prognozi katram no tiem.

Zemāk esošajā kodā jūs ierakstījāt katras funkcijas vērtības, kas ir df_predict csv failā.

Jums jāuzraksta jauna input_fn funkcija, jo datu kopā nav etiķetes. Varat izmantot API no_tensor no datu kopas.

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)

Visbeidzot, jūs izdrukājat prognozes.

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

Rezultāts

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

Kopsavilkums

Lai apmācītu modeli, jums:

  • Definējiet pazīmes: Neatkarīgie mainīgie: X
  • Definējiet iezīmi: Atkarīgais mainīgais: y
  • Kontrolējiet vilcienu / testa komplektu
  • Definējiet sākotnējo svaru
  • Definējiet zaudējumu funkciju: MSE
  • Optimizējiet modeli: gradienta nolaišanās
  • Definēt:
    • Mācīšanās ātrums
    • Laikmeta skaits
    • Partijas lielums

Šajā apmācībā jūs uzzinājāt, kā izmantot augsta līmeņa API lineārās regresijas TensorFlow novērtētājam. Jums jādefinē:

  1. Iezīmju kolonnas. Ja nepārtraukts: tf.feature_column.numeric_column (). Sarakstu var aizpildīt ar python saraksta izpratni
  2. Novērtētājs: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Funkcija datu, sērijas lieluma un laikmeta importēšanai: input_fn ()

Pēc tam jūs esat gatavs trenēties, novērtēt un prognozēt ar vilcienu (), novērtēt () un prognozēt ()