Linearna regresija s TensorFlow (primeri)

Kazalo:

Anonim

Kaj je linearna regresija?

Linearna regresija je pristop v statistiki za modeliranje razmerij med dvema spremenljivkama. To modeliranje poteka med skalarnim odzivom in eno ali več pojasnjevalnimi spremenljivkami. Odnos z eno razlagalno spremenljivko imenujemo preprosta linearna regresija, za več razlagalnih spremenljivk pa večkratna linearna regresija.

TensorFlow ponuja orodja za popoln nadzor nad izračuni. To se naredi z API-jem na nizki ravni. Poleg tega je TensorFlow opremljen s široko paleto API-jev za izvajanje številnih algoritmov strojnega učenja. To je API na visoki ravni. TensorFlow jih imenuje ocenjevalci

  • API na nizki ravni: zgradite arhitekturo in optimizirajte model iz nič. Za začetnike je zapleteno
  • API na visoki ravni: določite algoritem. Je prijaznejši do uporabnika. TensorFlow ponuja orodje za ocenjevanje klicev v orodjarni za izdelavo, usposabljanje, vrednotenje in napovedovanje.

V tej vadnici boste uporabili samo ocenjevalnike . Izračuni so hitrejši in lažji za izvedbo. V prvem delu vadnice je razloženo, kako uporabiti orodje za optimiziranje gradientnega spusta za urjenje linearne regresije v programu TensorFlow V drugem delu boste z naborom podatkov iz Bostona napovedali ceno hiše s pomočjo ocenjevalnika TensorFlow.

Prenesite Boston DataSet

V tej vadnici za regresijo TensorFlow boste izvedeli:

  • Kaj je linearna regresija?
  • Kako usposobiti model linearne regresije
  • Kako trenirati linearno regresijo s TensorFlow
  • Pande
  • Rešitev Numpy
  • Raztopina Tensorflow

Kako usposobiti model linearne regresije

Preden začnemo trenirati model, si oglejmo, kaj je linearna regresija.

Predstavljajte si, da imate dve spremenljivki, x in y, in vaša naloga je napovedati vrednost poznavanja vrednosti. Če izrišete podatke, lahko vidite pozitivno razmerje med vašo neodvisno spremenljivko x in odvisno spremenljivko y.

Opazite lahko, da če je x = 1, bo y približno približno 6 in če je x = 2, bo y približno 8,5.

To ni zelo natančna metoda in je nagnjena k napakam, zlasti pri naboru podatkov s sto tisoč točkami.

Linearno regresijo ovrednotimo z enačbo. Spremenljivko y razlaga ena ali več kovarijant. V vašem primeru je samo ena odvisna spremenljivka. Če morate napisati to enačbo, bo:

Z:

  • je teža, povezana z x
  • je preostanek ali napaka modela. Vključuje tisto, česar se model ne more naučiti iz podatkov

Predstavljajte si, da ustrezate modelu, in najdete naslednjo rešitev za:

  • = 3,8
  • = 2,78

Ta števila lahko nadomestite v enačbi in postane:

y = 3,8 + 2,78x

Zdaj imate boljši način za iskanje vrednosti za y. To pomeni, da lahko x nadomestite s katero koli vrednostjo, za katero želite predvideti y. Na spodnji sliki smo v enačbi x zamenjali z vsemi vrednostmi v naboru podatkov in narisali rezultat.

Rdeča črta predstavlja vgrajeno vrednost, to je vrednost y za vsako vrednost x. Za napovedovanje y vam ni treba videti vrednosti x, za vsak x je vsak, ki spada v rdečo črto. Napovedujete lahko tudi za vrednosti x, večje od 2!

Če želite linearno regresijo razširiti na več kovarijant, lahko z dodajanjem več spremenljivk v model. Razlika med tradicionalno analizo in linearno regresijo je v tem, da linearna regresija preučuje, kako se bo y odzval za vsako spremenljivko x, sprejeto neodvisno.

Poglejmo primer. Predstavljajte si, da želite napovedati prodajo sladoledarnice. Nabor podatkov vsebuje različne informacije, kot so vreme (tj. Deževno, sončno, oblačno), podatki o strankah (tj. Plača, spol, zakonski stan).

Tradicionalna analiza bo skušala napovedati prodajo tako, da recimo izračuna povprečje za vsako spremenljivko in poskuša oceniti prodajo za različne scenarije. To bo povzročilo slabe napovedi in omejilo analizo na izbrani scenarij.

Če uporabljate linearno regresijo, lahko zapišete to enačbo:

Algoritem bo našel najboljšo rešitev za uteži; to pomeni, da bo skušal zmanjšati stroške (razlika med vgrajeno črto in podatkovnimi točkami).

Kako deluje algoritem

Algoritem bo izbral naključno število za vsako in nadomestiti vrednost x, da bi dobili predvideno vrednost y. Če ima nabor podatkov 100 opazovanj, algoritem izračuna 100 predvidenih vrednosti.

Izračunamo lahko napako, zabeleženo v modelu, ki je razlika med napovedano vrednostjo in realno vrednostjo. Pozitivna napaka pomeni, da model podcenjuje napoved y, negativna napaka pa, da model precenjuje napoved y.

Vaš cilj je zmanjšati kvadrat napake. Algoritem izračuna povprečje kvadratne napake. Ta korak se imenuje zmanjšanje napake. Za linearno regresijo je napaka srednjega kvadrata , imenovana tudi MSE. Matematično je:

Kje:

  • nanašajo na predvideno vrednost
  • y so dejanske vrednosti
  • m je število opazovanj

Upoštevajte, da matematični zapis srednje vrednosti.

Cilj je najti najboljše, ki zmanjšujejo MSE

Če je povprečna napaka velika, to pomeni, da model deluje slabo in uteži niso pravilno izbrane. Če želite popraviti uteži, morate uporabiti optimizator. Tradicionalni optimizator se imenuje Gradient Descent .

Gradientni spust prevzame izpeljanko in zmanjša ali poveča težo. Če je izpeljanka pozitivna, se teža zmanjša. Če je izpeljanka negativna, se teža poveča. Model bo posodobil uteži in napako preračunal. Ta postopek se ponavlja, dokler se napaka ne spremeni več. Vsak postopek se imenuje ponovitev . Poleg tega se gradienti pomnožijo s stopnjo učenja. Označuje hitrost učenja.

Če je stopnja učenja premajhna, bo trajalo zelo dolgo, da se algoritem zbliža (tj. Zahteva veliko ponovitev). Če je stopnja učenja previsoka, se algoritem morda nikoli ne zbliža.

Iz zgornje slike je razvidno, da model postopek ponovi približno 20-krat, preden najde stabilno vrednost uteži in tako doseže najnižjo napako.

Upoštevajte , da napaka ni enaka nič, ampak se stabilizira okoli 5. To pomeni, da model naredi tipično napako 5. Če želite napako zmanjšati, morate modelu dodati več informacij, na primer več spremenljivk ali uporabiti različnih ocenjevalcev.

Spomnite se prve enačbe

Končni uteži sta 3,8 in 2,78. Spodnji video prikazuje, kako gradientni spust optimizira funkcijo izgube za iskanje teh uteži

Kako trenirati linearno regresijo s TensorFlow

Zdaj, ko bolje razumete, kaj se dogaja za pokrovom motorja, ste pripravljeni na uporabo ocenjevalnega API-ja, ki ga ponuja TensorFlow, za usposabljanje vaše prve linearne regresije z uporabo TensorFlow-a.

Uporabili boste nabor podatkov iz Bostona, ki vključuje naslednje spremenljivke

kriminala stopnja kriminala na prebivalca po mestih
zn delež stanovanjskih zemljišč, zoniranih za parcele nad 25.000 kvadratnih metrov.
indus delež neprodajnih poslovnih hektarjev na mesto.
nox koncentracija dušikovih oksidov
rm povprečno število sob na stanovanje
starost delež lastniških enot, zgrajenih pred 1940
dis tehtane razdalje do petih bostonskih zaposlitvenih centrov
davek stopnja davka na nepremičnine v polni vrednosti na 10.000 dolarjev
ptratio razmerje med učenci in učitelji po mestih
medv Mediana vrednosti lastniških domov v tisočih dolarjev

Ustvarili boste tri različne nabore podatkov:

nabora podatkov cilj obliko
Usposabljanje Izurite model in pridobite uteži 400, 10
Vrednotenje Ocenite uspešnost modela na nevidnih podatkih 100, 10
Predvidite Z modelom predvidejte hišno vrednost na novih podatkih 6, 10

Cilj je uporabiti funkcije nabora podatkov za napovedovanje vrednosti hiše.

V drugem delu vadnice boste izvedeli, kako uporabljati TensorFlow na tri različne načine za uvoz podatkov:

  • S Pandami
  • Z Numpyjem
  • Samo TF

Upoštevajte, da imajo vse možnosti enake rezultate.

Naučili se boste, kako uporabljati API na visoki ravni za izdelavo, izuriti oceno modela linearne regresije TensorFlow. Če ste uporabljali API nizke ravni, ste morali ročno določiti:

  • Funkcija izgube
  • Optimizirajte: gradientni spust
  • Množenje matrik
  • Graf in tenzor

To je za začetnike dolgočasno in bolj zapleteno.

Pande

Za usposabljanje modela morate uvoziti potrebne knjižnice.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Korak 1) Uvozite podatke s pando.

Določite imena stolpcev in jih shranite v stolpce. Za uvoz podatkov lahko uporabite pd.read_csv ().

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

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

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

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

Natisnete lahko obliko podatkov.

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

Izhod

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

Upoštevajte, da je oznaka, tj. Vaš y, vključena v nabor podatkov. Torej morate določiti še dva seznama. Tisti, ki vsebuje samo značilnosti, in tisti, ki vsebuje samo ime nalepke. Ta dva seznama bosta ocenjevalcu povedala, katere so značilnosti nabora podatkov in katero ime stolpca je oznaka

To se naredi s spodnjo kodo.

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

2. korak) Pretvorite podatke

Številske spremenljivke morate pretvoriti v pravilno obliko. Tensorflow ponuja metodo za pretvorbo neprekinjene spremenljivke: tf.feature_column.numeric_column ().

V prejšnjem koraku določite seznam funkcije, ki jo želite vključiti v model. Zdaj jih lahko s tem seznamom pretvorite v številske podatke. Če želite v svojem modelu izključiti funkcije, na seznamu LASTNOSTI pred spuščanjem ene ali več spremenljivk LASTNOSTI

Upoštevajte, da boste za razumevanje seznama Python s seznamom FEATURES ustvarili nov seznam z imenom feature_cols. Pomaga vam preprečiti devetkratno pisanje tf.feature_column.numeric_column (). Razumevanje seznamov je hitrejši in čistejši način za ustvarjanje novih seznamov

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

Korak 3) Določite ocenjevalnik

V tem koraku morate določiti ocenjevalnik. Tensorflow trenutno ponuja 6 vnaprej izdelanih ocenjevalnikov, vključno s 3 za nalogo klasifikacije in 3 za nalogo regresije TensorFlow:

  • Regresor
    • DNNRegressor
    • LinearRegressor
    • DNNLineaCombinedRegressor
  • Klasifikator
    • Klasifikator DNN
    • LinearClassifier
    • DNNLineaCombinedClassifier

V tej vadnici boste uporabili Linear Regressor. Za dostop do te funkcije morate uporabiti tf.estimator.

Funkcija potrebuje dva argumenta:

  • feature_columns: Vsebuje spremenljivke, ki jih je treba vključiti v model
  • model_dir: pot do shranjevanja grafa, shranjevanja parametrov modela itd

Tensorflow bo samodejno ustvaril datoteko z imenom vlak v vašem delovnem imeniku. To pot morate uporabiti za dostop do Tensorboard, kot je prikazano v spodnjem primeru regresije TensorFlow.

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

Izhod

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}

Težaven del s sistemom TensorFlow je način podajanja modela. Tensorflow je zasnovan za delo z vzporednim računalništvom in zelo velikim naborom podatkov. Zaradi omejenosti strojnih virov je nemogoče, da se model napolni z vsemi podatki hkrati. Za to morate vsakič posredovati serijo podatkov. Upoštevajte, da govorimo o ogromnem naboru podatkov z milijoni ali več zapisi. Če ne dodate paketa, boste na koncu dobili napako v pomnilniku.

Če na primer vaši podatki vsebujejo 100 opazovanj in določite velikost serije 10, to pomeni, da bo model za vsako ponovitev (10 * 10) videl 10 opazovanj.

Ko model vidi vse podatke, zaključi eno epoho . Epoha določa, kolikokrat želite, da model vidi podatke. Bolje je, da ta korak nastavite na nič in pustite, da model izvede število ponovitev časa.

Drugi podatek je, če želite podatke premešati pred vsako ponovitvijo. Med usposabljanjem je pomembno, da podatke premešate, da se model ne nauči določenega vzorca nabora podatkov. Če se model nauči podrobnosti osnovnega vzorca podatkov, bo imel težave s posplošitvijo napovedi za nevidne podatke. To se imenuje prekomerno opremljanje . Model dobro deluje na podatkih o vadbi, vendar za nevidne podatke ne more pravilno napovedati.

TensorFlow olajša ta dva koraka. Ko gredo podatki v cevovod, ve, koliko opazovanj potrebujejo (paket) in ali jih je treba premešati.

Če želite Tensorflowu naročiti, kako napajati model, lahko uporabite pandas_input_fn. Ta objekt potrebuje 5 parametrov:

  • x: podatki o lastnostih
  • y: podatki o nalepki
  • batch_size: serija. Privzeto 128
  • num_epoch: Število obdobij, privzeto 1
  • shuffle: Premešaj ali ne podatke. Privzeto Brez

Model morate večkrat nahraniti, zato določite funkcijo, ki bo ponovila ta postopek. vsa ta 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)

Običajna metoda za oceno učinkovitosti modela je:

  • Trenirajte model
  • Ocenite model v drugem naboru podatkov
  • Naredite napovedi

Ocenjevalnik Tensorflow ponuja tri različne funkcije za enostavno izvedbo teh treh korakov.

4. korak : Izurite model

Za oceno modela lahko uporabite vlak za ocenjevanje. Ocenjevalec vlakov potrebuje input_fn in številne korake. Za podajanje modela lahko uporabite funkcijo, ki ste jo ustvarili zgoraj. Nato naročite modelu, da se 1000-krat ponovi. Upoštevajte, da ne določite števila obdobij, temveč pustite, da se model ponovi 1000-krat. Če nastavite število epoh na 1, se bo model ponavljal 4-krat: V kompletu za vadbo je 400 zapisov in velikost serije je 128

  1. 128 vrstic
  2. 128 vrstic
  3. 128 vrstic
  4. 16 vrstic

Zato je lažje nastaviti število epoh na nič in določiti število ponovitev, kot je prikazano na spodnjem primeru klasifikacije TensorFlow.

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

Izhod

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.

Preverite lahko, ali bo Tensorboard imel naslednji ukaz:

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

5. korak) Ocenite svoj model

Primernost vašega modela na testnem kompletu lahko ocenite s spodnjo kodo:

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

Izhod

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

Izgubo lahko natisnete s spodnjo kodo:

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

Izhod

Loss: 3215.895996

Model izgubi 3215. Lahko si ogledate povzetek statističnih podatkov, da dobite idejo, kako velika je napaka.

training_set['medv'].describe()

Izhod

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

Iz zgornjega povzetka statistike veste, da je povprečna cena hiše 22 tisoč, najnižja cena 9 tisoč in največ 50 tisoč. Model naredi običajno napako v višini 3 tisoč dolarjev.

Korak 6) Naredite napoved

Na koncu lahko s pomočjo ocenjevalnika napovedi TensorFlow ocenite vrednost 6 bostonskih hiš.

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

Če želite natisniti ocenjene vrednosti, lahko uporabite to kodo:

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

Izhod

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

Model napoveduje naslednje vrednosti:

Hiša

Napovedovanje

1.

32,29

2.

18.96

3.

27.27

4.

29.29

5.

16.43

7.

21.46

Upoštevajte, da ne poznamo prave vrednosti. V vadnici globokega učenja boste poskušali premagati linearni model

Rešitev Numpy

V tem razdelku je razloženo, kako trenirati model z uporabo numpy ocenjevalnika za podajanje podatkov. Metoda je enaka, razen da boste uporabili ocenjevalnik numpy_input_fn.

training_set_n = pd.read_csv ("E: /boston_train.csv"). vrednosti

test_set_n = pd.read_csv ("E: /boston_test.csv"). vrednosti

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

Korak 1) Uvozite podatke

Najprej morate razlikovati spremenljivke lastnosti od oznake. To morate storiti za podatke o usposabljanju in vrednotenje. Hitreje je določiti funkcijo za razdelitev podatkov.

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

S funkcijo lahko oznako ločite od značilnosti nabora podatkov o vlaku / oceni

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

Izključiti morate zadnji stolpec nabora podatkov za napovedi, ker vsebuje samo NaN

x_predict = prediction_set_n[:, :-2]

Potrdite obliko polja. Upoštevajte, da nalepka ne sme imeti dimenzij, to pomeni (400,).

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

Izhod

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

Stolpce funkcij lahko sestavite na naslednji način:

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

Ocenjevalec je določen kot prej, vi ukažete stolpcem lastnosti in kam shraniti graf.

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

Izhod

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}

Numpy-oceno lahko uporabite za podajanje podatkov v model in nato usposabljanje modela. Upoštevajte, da funkcijo input_fn definiramo prej, da olajšamo berljivost.

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

Izhod

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

Isti korak ponovite z drugim ocenjevalnikom, da ocenite svoj model

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)

Izhod

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}

Končno lahko izračunate napoved. Morala bi biti podobna pandam.

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

Izhod

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

Raztopina Tensorflow

Zadnji del je namenjen rešitvi TensorFlow. Ta metoda je sligthly bolj zapletena kot druga.

Če uporabljate prenosni računalnik Jupyter, morate znova zagnati in očistiti jedro, da zaženete to sejo.

TensorFlow je izdelal odlično orodje za prenos podatkov v cevovod. V tem razdelku boste funkcijo input_fn zgradili sami.

Korak 1) Določite pot in obliko podatkov

Najprej deklarirate dve spremenljivki s potjo datoteke csv. Upoštevajte, da imate dve datoteki, eno za komplet za vadbo in eno za sklop za testiranje.

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

Nato morate iz datoteke csv določiti stolpce, ki jih želite uporabiti. Uporabili bomo vse. Po tem morate navesti vrsto spremenljivke, za katero gre.

Spremenljivka Floats je definirana z [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]]

Korak 2) Določite funkcijo input_fn

Funkcijo lahko razdelimo na tri dele:

  1. Uvozite podatke
  2. Ustvari iterator
  3. Porabite podatke

Spodaj je splošna koda za določitev funkcije. Koda bo razložena po

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

** Uvozi podatke **

Za datoteko CSV metoda nabora podatkov bere eno vrstico naenkrat. Če želite zgraditi nabor podatkov, morate uporabiti objekt TextLineDataset. Vaš nabor podatkov ima glavo, zato morate preskočiti prvo vrstico s preskoči (1). Na tej točki preberete samo podatke in izključite glavo v cevovodu. Če želite model nahraniti, morate funkcije ločiti od nalepke. Metoda, ki se uporablja za kakršno koli preoblikovanje podatkov, je map.

Ta metoda pokliče funkcijo, ki jo boste ustvarili, da boste dobili navodila za pretvorbo podatkov. Na kratko morate podatke posredovati v objektu TextLineDataset, izključiti glavo in uporabiti preoblikovanje, ki ga ukaže funkcija.

  • tf.data.TextLineDataset (data_file): V tej vrstici je prebrana datoteka CSV
  • .skip (1): preskočite glavo
  • .map (parse_csv)): razčlenite zapise v tenzorje Določiti morate funkcijo, ki bo ukazala objekt zemljevida. To funkcijo lahko pokličete parse_csv.

Ta funkcija razčleni datoteko csv z metodo tf.decode_csv in razglasi lastnosti in oznako. Funkcije lahko prijavite kot slovar ali nabor. Uporabljate slovarsko metodo, ker je bolj priročna. Razlaga kode

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): metoda decode_csv uporablja izhod besedila TextLineDataset za branje datoteke csv. record_defaults navodi TensorFlow o vrsti stolpcev.
  • dict (zip (_CSV_COLUMNS, stolpci)): Zapolnite slovar z vsemi stolpci, ekstrahiranimi med to obdelavo podatkov
  • features.pop ('median_house_value'): iz spremenljivke lastnosti izključite ciljno spremenljivko in ustvarite spremenljivko oznake

Nabor podatkov potrebuje dodatne elemente za iterativno napajanje tenzorjev. Dejansko morate dodati metodo ponovitve, da dovolite naboru podatkov neomejeno nadaljevanje napajanja modela. Če metode ne dodate, se model ponovi samo enkrat in nato prikaže napako, ker se v cevovod ne poda več podatkov.

Po tem lahko nadzorujete velikost serije s paketno metodo. To pomeni, da naboru podatkov poveste, koliko podatkov želite posredovati v pripravi za vsako ponovitev. Če nastavite veliko velikost serije, bo model počasen.

Korak 3) Ustvarite iterator

Zdaj ste pripravljeni na drugi korak: ustvarite iterator za vrnitev elementov v naboru podatkov.

Najenostavnejši način ustvarjanja operaterja je z metodo make_one_shot_iterator.

Po tem lahko iz iteratorja ustvarite funkcije in oznake.

4. korak) Porabite podatke

Preverite lahko, kaj se zgodi s funkcijo input_fn. Za porabo podatkov morate v seji poklicati funkcijo. Poskusite s serijo velikosti 1.

Upoštevajte, da tiska funkcije v slovarju in nalepko kot matriko.

Prikazala se bo prva vrstica datoteke csv. To kodo lahko poskusite zagnati večkrat z različno velikostjo paketa.

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)

Izhod

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

Korak 4) Določite stolpec lastnosti

Številske stolpce morate določiti tako:

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

Upoštevajte, da morate vse spremenljivke združiti v vedro

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

5. korak) Zgradite model

Model lahko usposobite z ocenjevalnikom LinearRegressor.

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

Izhod

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}

Za zapis argumenta v funkcijo inpu_fn morate uporabiti funkcijo lambda. Če ne uporabljate funkcije lambda, modela ne morete usposobiti.

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

Izhod

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

S spodnjo kodo lahko ocenite ustreznost svojega modela na testnem kompletu:

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

Izhod

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

Zadnji korak je napovedovanje vrednosti na podlagi vrednosti matric lastnosti. Lahko napišete slovar z vrednostmi, ki jih želite predvideti. Vaš model ima 9 funkcij, zato morate za vsako navesti vrednost. Model bo zagotovil napoved za vsakega od njih.

V spodnjo kodo ste zapisali vrednosti vsake funkcije, ki je v datoteki df_predict csv.

Napisati morate novo funkcijo input_fn, ker v naboru podatkov ni oznake. Uporabite lahko API from_tensor iz nabora podatkov.

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)

Končno napovedi natisnete.

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

Izhod

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

Povzetek

Če želite usposobiti model, morate:

  • Določite lastnosti: Neodvisne spremenljivke: X
  • Določite oznako: Odvisna spremenljivka: y
  • Izdelajte vlak / testni sklop
  • Določite začetno težo
  • Določite funkcijo izgube: MSE
  • Optimizirajte model: gradientni spust
  • Določite:
    • Stopnja učenja
    • Število obdobij
    • Velikost serije

V tej vadnici ste se naučili uporabljati API na visoki ravni za ocenjevalnik linearne regresije TensorFlow. Določiti morate:

  1. Stolpci s funkcijami. Če je neprekinjeno: tf.feature_column.numeric_column (). Seznam lahko zapolnite z razumevanjem seznama python
  2. Ocenjevalec: tf.estimator.LinearRegressor (stolpci_funkcij, model_dir)
  3. Funkcija za uvoz podatkov, velikosti serije in obdobja: input_fn ()

Po tem ste pripravljeni trenirati, ovrednotiti in napovedovati z train (), evaluacijo () in napovedovanjem ()