Linearna regresija s TensorFlowom (primjeri)

Sadržaj:

Anonim

Što je linearna regresija?

Linearna regresija pristup je u statistici za modeliranje odnosa između dvije varijable. Ovo se modeliranje vrši između skalarnog odgovora i jedne ili više objašnjavajućih varijabli. Odnos s jednom objašnjavajućom varijablom naziva se jednostavna linearna regresija, a za više objašnjavajućih varijabli naziva se višestrukom linearnom regresijom.

TensorFlow nudi alate za potpunu kontrolu proračuna. To se radi s API-jem niske razine. Povrh svega, TensorFlow je opremljen širokim nizom API-ja za izvođenje mnogih algoritama strojnog učenja. Ovo je API visoke razine. TensorFlow ih naziva procjeniteljima

  • API niske razine: Izgradite arhitekturu, optimizaciju modela od nule. Komplicirano je za početnike
  • API visoke razine: definirajte algoritam. Jednostavniji je za jelo. TensorFlow nudi alat za procjenu poziva za izradu, obuku, procjenu i predviđanje.

U ovom ćete uputstvu koristiti samo procjenitelje . Izračuni su brži i jednostavniji za provedbu. Prvi dio vodiča objašnjava kako koristiti optimizator gradijentnog spuštanja za vježbanje Linearne regresije u TensorFlowu. U drugom ćete dijelu koristiti skup podataka iz Bostona za predviđanje cijene kuće pomoću procjenitelja TensorFlow.

Preuzmite Boston DataSet

U ovom vodiču za regresiju TensorFlowa naučit ćete:

  • Što je linearna regresija?
  • Kako trenirati model linearne regresije
  • Kako trenirati linearnu regresiju s TensorFlowom
  • Pande
  • Numpy rješenje
  • Tensorflow otopina

Kako trenirati model linearne regresije

Prije nego što počnemo trenirati model, pogledajmo što je linearna regresija.

Zamislite da imate dvije varijable, x i y, a vaš zadatak je predvidjeti vrijednost poznavanja vrijednosti. Ako nacrtate podatke, možete vidjeti pozitivan odnos između vaše neovisne varijable x i ovisne varijable y.

Možete primijetiti, ako je x = 1, y će otprilike biti jednako 6, a ako je x = 2, y će biti oko 8,5.

Ovo nije vrlo točna metoda i sklona je pogreškama, posebno kod skupa podataka sa stotinama tisuća točaka.

Linearna regresija procjenjuje se jednadžbom. Varijablu y objašnjava jedna ili više kovarijacija. U vašem primjeru postoji samo jedna ovisna varijabla. Ako morate napisati ovu jednadžbu, bit će:

S:

  • je težina povezana s x
  • je ostatak ili pogreška modela. Uključuje ono što model ne može naučiti iz podataka

Zamislite da odgovarate modelu i pronađete sljedeće rješenje za:

  • = 3,8
  • = 2,78

Možete zamijeniti te brojeve u jednadžbi i on postaje:

y = 3,8 + 2,78x

Sada imate bolji način za pronalaženje vrijednosti za y. Odnosno, x možete zamijeniti bilo kojom vrijednošću koju želite predvidjeti y. Na donjoj slici zamijenili smo x u jednadžbi sa svim vrijednostima u skupu podataka i iscrtali rezultat.

Crvena crta predstavlja ugrađenu vrijednost, odnosno vrijednosti y za svaku vrijednost x. Ne trebate vidjeti vrijednost x da biste predvidjeli y, za svaki x postoji bilo koji koji pripada crvenoj liniji. Također možete predvidjeti za vrijednosti x veće od 2!

Ako želite proširiti linearnu regresiju na više kovarijacija, možete dodavanjem više varijabli u model. Razlika između tradicionalne analize i linearne regresije je što linearna regresija gleda na to kako će y reagirati za svaku varijablu x uzetu neovisno.

Pogledajmo primjer. Zamislite da želite predvidjeti prodaju prodavaonice sladoleda. Skup podataka sadrži različite informacije kao što su vrijeme (tj. Kišno, sunčano, oblačno), podaci o kupcima (tj. Plaća, spol, bračni status).

Tradicionalna analiza pokušat će predvidjeti prodaju recimo izračunavanjem prosjeka za svaku varijablu i pokušati procijeniti prodaju za različite scenarije. To će dovesti do loših predviđanja i ograničiti analizu na odabrani scenarij.

Ako koristite linearnu regresiju, možete napisati ovu jednadžbu:

Algoritam će pronaći najbolje rješenje za utege; to znači da će pokušati smanjiti troškove (razlika između ugrađene linije i podatkovnih točaka).

Kako algoritam funkcionira

Algoritam će odabrati slučajni broj za svaki i zamijeniti vrijednost x da bi predviđeni vrijednost y. Ako skup podataka ima 100 promatranja, algoritam izračunava 100 predviđenih vrijednosti.

Možemo izračunati pogrešku primijećenu u modelu, koja je razlika između predviđene vrijednosti i stvarne vrijednosti. Pozitivna pogreška znači da model podcjenjuje predviđanje y, a negativna pogreška znači da model precjenjuje predviđanje y.

Vaš je cilj smanjiti kvadrat pogreške. Algoritam izračunava srednju vrijednost kvadratne pogreške. Ovaj se korak naziva minimiziranje pogreške. Za linearnu regresiju je pogreška srednjeg kvadrata , koja se također naziva MSE. Matematički je to:

Gdje:

  • odnosi na predviđenu vrijednost
  • y su stvarne vrijednosti
  • m je broj opažanja

Imajte na umu da je matematički zapis srednje vrijednosti.

Cilj je pronaći najbolje što smanjuje MSE

Ako je prosječna pogreška velika, to znači da model ima loše rezultate i da utezi nisu pravilno odabrani. Da biste ispravili težine, trebate koristiti optimizator. Tradicionalni optimizator naziva se Gradient Descent .

Gradijentni spust uzima izvedenicu i smanjuje ili povećava težinu. Ako je derivat pozitivan, težina se smanjuje. Ako je derivat negativan, težina se povećava. Model će ažurirati težine i preračunati pogrešku. Taj se postupak ponavlja sve dok se pogreška više ne mijenja. Svaki se postupak naziva iteracijom . Osim toga, gradijenti se množe stopom učenja. Označava brzinu učenja.

Ako je stopa učenja premala, trebat će jako dugo da se algoritam konvergira (tj. Zahtijeva puno iteracija). Ako je stopa učenja previsoka, algoritam se možda nikada neće konvergirati.

Iz gornje slike možete vidjeti da model ponavlja postupak 20-ak puta prije nego što je pronašao stabilnu vrijednost pondera, čime je postignuta najmanja pogreška.

Imajte na umu da pogreška nije jednaka nuli već se stabilizira oko 5. To znači da model čini tipičnu pogrešku od 5. Ako želite smanjiti pogrešku, morate dodati više podataka u model, poput više varijabli ili koristiti različite procjenitelje.

Sjećate se prve jednadžbe

Konačni ponderi su 3,8 i 2,78. Video u nastavku prikazuje vam kako gradijentni spust optimizira funkciju gubitka kako bi se pronašli te težine

Kako trenirati linearnu regresiju s TensorFlowom

Sad kad ste bolje razumjeli što se događa iza haube, spremni ste za uporabu API-ja za procjenu koji pruža TensorFlow za vježbanje vaše prve linearne regresije pomoću TensorFlow-a.

Upotrijebit ćete skup podataka iz Bostona, koji uključuje sljedeće varijable

krim stopa kriminala po stanovniku po gradu
zn udio stambenog zemljišta zoniranog za parcele veće od 25.000 sq.ft.
indus udio nerealiziranih hektara po gradu.
nox koncentracija dušikovih oksida
rm prosječni broj soba po stanu
dob udio vlasničkih jedinica izgrađenih prije 1940
dis ponderirane udaljenosti do pet bostonskih centara za zapošljavanje
porez puna vrijednost stope poreza na imovinu po 10.000 dolara
ptratio omjer učenika i učitelja prema gradu
medv Srednja vrijednost domova u kojima žive vlasnici u tisućama dolara

Stvorit ćete tri različita skupa podataka:

skup podataka cilj oblik
Trening Obučiti model i dobiti težine 400, 10
Procjena Procijenite izvedbu modela na neviđenim podacima 100, 10
Predvidjeti Upotrijebite model za predviđanje kućne vrijednosti na novim podacima 6, 10

Ciljevi su koristiti značajke skupa podataka za predviđanje vrijednosti kuće.

Tijekom drugog dijela vodiča naučit ćete kako koristiti TensorFlow na tri različita načina uvoza podataka:

  • S Pandama
  • S Numpyem
  • Samo TF

Imajte na umu da sve opcije daju iste rezultate.

Naučit ćete kako koristiti API visoke razine za izgradnju, osposobljavanje za procjenu modela linearne regresije TensorFlow. Ako ste koristili API niske razine, morali ste ručno definirati:

  • Funkcija gubitka
  • Optimizirajte: Gradijentni spust
  • Množenje matrica
  • Grafikon i tenzor

Ovo je zamorno i složenije za početnike.

Pande

Za obuku modela morate uvesti potrebne knjižnice.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Korak 1) Uvezite podatke s pandom.

Definirate imena stupaca i pohranjujete ih u STOLPCE. Za uvoz podataka možete koristiti 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)

Možete ispisati oblik podataka.

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

Izlaz

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

Imajte na umu da je oznaka, tj. Vaš y, uključena u skup podataka. Dakle, trebate definirati dva druga popisa. Jedan koji sadrži samo značajke i onaj koji ima samo naziv naljepnice. Ova dva popisa reći će vašem procjenitelju koje su značajke u skupu podataka i koji je naziv stupca oznaka

To je učinjeno s donjim kodom.

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

Korak 2) Pretvorba podataka

Morate pretvoriti numeričke varijable u odgovarajući format. Tensorflow pruža metodu za pretvaranje kontinuirane varijable: tf.feature_column.numeric_column ().

U prethodnom koraku definirali ste popis značajke koju želite uključiti u model. Sada ih možete koristiti za pretvaranje u numeričke podatke. Ako želite izuzeti značajke u svom modelu, slobodno ispustite jednu ili više varijabli s popisa ZNAČAJKE prije nego što konstruirate značajke_kole

Imajte na umu da ćete za razumijevanje popisa Python s popisom FEATURES stvoriti novi popis s imenom feature_cols. Pomaže vam izbjeći pisanje devet puta tf.feature_column.numeric_column (). Razumijevanje popisa brži je i čišći način za stvaranje novih popisa

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

Korak 3) Definirajte procjenitelj

U ovom koraku morate definirati procjenitelj. Tensorflow trenutno nudi 6 unaprijed izgrađenih procjenitelja, uključujući 3 za zadatak klasifikacije i 3 za zadatak regresije TensorFlow:

  • Regresor
    • DNNRegressor
    • Linearni regresor
    • DNNLineaCombinedRegressor
  • Klasifikator
    • DNNKlasifikator
    • LinearClassifier
    • DNNLineaCombinedClassifier

U ovom ćete uputstvu koristiti Linear Regressor. Da biste pristupili ovoj funkciji, trebate koristiti tf.estimator.

Funkciji su potrebna dva argumenta:

  • feature_columns: Sadrži varijable koje se uključuju u model
  • model_dir: put za spremanje grafa, spremanje parametara modela itd

Tensorflow će automatski stvoriti datoteku pod nazivom vlak u vašem radnom direktoriju. Morate upotrijebiti ovaj put za pristup Tensorboardu kao što je prikazano u donjem primjeru regresije TensorFlow.

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

Izlaz

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}

Škakljivi dio s TensorFlowom način je nahranjenja modela. Tensorflow je dizajniran za rad s paralelnim računanjem i vrlo velikim skupom podataka. Zbog ograničenja resursa stroja, nemoguće je hraniti model svim podacima odjednom. Da biste to učinili, svaki put morate unijeti hrpu podataka. Imajte na umu da govorimo o ogromnom skupu podataka s milijunima ili više zapisa. Ako ne dodate paket, na kraju ćete dobiti pogrešku u memoriji.

Na primjer, ako vaši podaci sadrže 100 promatranja, a vi definirate veličinu serije 10, to znači da će model vidjeti 10 promatranja za svaku iteraciju (10 * 10).

Kada model vidi sve podatke, završava jednu epohu . Epoha definira koliko puta želite da model vidi podatke. Bolje je ovaj korak postaviti na none i pustiti da model izvodi iteracijski broj vremena.

Druga informacija koju treba dodati je ako želite promiješati podatke prije svake iteracije. Tijekom treninga važno je promiješati podatke tako da model ne nauči određeni obrazac skupa podataka. Ako model nauči detalje temeljnog uzorka podataka, imat će poteškoće generalizirati predviđanje za neviđene podatke. To se naziva prekomjerno prilagođavanje . Model dobro izvodi podatke o treningu, ali ne može točno predvidjeti nevidljive podatke.

TensorFlow olakšava ova dva koraka. Kad podaci idu u cjevovod, on zna koliko im je promatranja potrebno (batch) i mora li podatke miješati.

Da biste Tensorflow uputili kako hraniti model, možete upotrijebiti pandas_input_fn. Ovaj objekt treba 5 parametara:

  • x: podaci o značajkama
  • y: podaci naljepnice
  • batch_size: serija. Prema zadanim postavkama 128
  • num_epoch: Broj epoha, prema zadanim postavkama 1
  • nasumično miješanje: preslagivanje podataka ili ne. Prema zadanim postavkama, None

Model trebate hraniti mnogo puta pa definirate funkciju koja će ponoviti ovaj postupak. sva ova 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)

Uobičajena metoda za procjenu izvedbe modela je:

  • Obuči model
  • Procijenite model u drugom skupu podataka
  • Napravite predviđanje

Tensorflow procjenitelj pruža tri različite funkcije za jednostavno provođenje ova tri koraka.

Korak 4) : Obučite model

Za procjenu modela možete koristiti vlak procjenitelja. Procjenitelju vlakova trebaju input_fn i broj koraka. Za hranjenje modela možete koristiti funkciju koju ste gore stvorili. Zatim uputite model da se ponovi 1000 puta. Imajte na umu da, ako ne navedete broj epoha, dopustite da se model ponavlja 1000 puta. Ako broj epoha postavite na 1, tada će se model ponoviti 4 puta: U setu treninga nalazi se 400 zapisa, a veličina serije je 128

  1. 128 redaka
  2. 128 redaka
  3. 128 redaka
  4. 16 redaka

Stoga je lakše postaviti broj epoha na nijedno i definirati broj iteracija kao što je prikazano u th ispod primjera klasifikacije TensorFlow.

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

Izlaz

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.

Možete provjeriti hoće li Tensorboard sljedeće naredbe:

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

Korak 5) Procijenite svoj model

Prikladnost vašeg modela na testnom skupu možete procijeniti pomoću donjeg koda:

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

Izlaz

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

Gubitak možete ispisati pomoću donjeg koda:

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

Izlaz

Loss: 3215.895996

Model ima gubitak od 3215. Možete provjeriti sažeti statistički podatak kako biste dobili ideju o tome kolika je pogreška.

training_set['medv'].describe()

Izlaz

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

Iz gornjeg sažetog statističkog podatka znate da je prosječna cijena kuće 22 tisuće, s minimalnom cijenom od 9 tisuća, a maksimalnom 50 tisuća. Model pravi tipičnu pogrešku od 3 tisuće dolara.

Korak 6) Napravite predviđanje

Na kraju, možete upotrijebiti procjenitelj TensorFlow za predviđanje vrijednosti 6 bostonskih kuća.

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

Da biste ispisali procijenjene vrijednosti, možete koristiti ovaj kod:

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

Izlaz

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 predviđa sljedeće vrijednosti:

Kuća

Predviđanje

1

32,29

2

18,96

3

27.27

4

29.29

5

16.43

7

21.46

Imajte na umu da ne znamo pravu vrijednost. U vodiču dubokog učenja pokušat ćete pobijediti linearni model

Numpy rješenje

Ovaj odjeljak objašnjava kako trenirati model pomoću numpy procjenitelja za unos podataka. Metoda je ista osim što ćete koristiti procjenjivač numpy_input_fn.

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

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

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

Korak 1) Uvezite podatke

Prije svega, morate razlikovati varijable značajke od oznake. To morate učiniti za podatke o obuci i ocjenu. Brže je definirati funkciju za razdvajanje podataka.

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

Pomoću funkcije možete podijeliti naljepnicu od značajki skupa podataka vlak / procjena

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

Morate izuzeti posljednji stupac skupa podataka predviđanja jer sadrži samo NaN

x_predict = prediction_set_n[:, :-2]

Potvrdite oblik niza. Imajte na umu da oznaka ne bi trebala imati dimenziju, to znači (400,).

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

Izlaz

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

Stupce značajki možete konstruirati na sljedeći način:

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

Procjenitelj je definiran kao i prije, vi upućujete na stupce značajki i na mjesto spremanja grafa.

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

Izlaz

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}

Možete koristiti numpy procjenu za unos podataka u model, a zatim obuku modela. Imajte na umu da smo prije definirali funkciju input_fn kako bismo olakšali čitljivost.

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

Izlaz

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 replicirate s drugim procjeniteljem kako biste procijenili 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)

Izlaz

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}

Napokon, možete izračunati predviđanje. Trebao bi biti sličan pandama.

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

Izlaz

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 otopina

Posljednji je odjeljak posvećen rješenju TensorFlow. Ova metoda je sligthly složenija od one druge.

Imajte na umu da ako koristite Jupyter bilježnicu, morate ponovno pokrenuti i očistiti jezgru da biste pokrenuli ovu sesiju.

TensorFlow je stvorio sjajan alat za prosljeđivanje podataka u cjevovod. U ovom ćete odjeljku sami izgraditi funkciju input_fn.

Korak 1) Definirajte put i format podataka

Prije svega, deklarirate dvije varijable s putanjom csv datoteke. Imate na umu da imate dvije datoteke, jednu za set za obuku i jednu za set za testiranje.

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

Zatim iz CSV datoteke trebate definirati stupce koje želite koristiti. Iskoristit ćemo sve. Nakon toga trebate deklarirati vrstu varijable koja je to.

Varijabla floats definirana je s [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) Definirajte funkciju input_fn

Funkcija se može podijeliti u tri dijela:

  1. Uvezite podatke
  2. Izradite iterator
  3. Potrošite podatke

Ispod je opći kod za definiranje funkcije. Šifra će biti objašnjena nakon

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

** Uvezi podatke **

Za CSV datoteku metoda skupa podataka čita jedan po jedan redak. Da biste izgradili skup podataka, morate koristiti objekt TextLineDataset. Vaš skup podataka ima zaglavlje pa morate preskočiti (1) da biste preskočili prvi redak. U ovom trenutku samo čitate podatke i izuzimate zaglavlje u cjevovodu. Da biste nahranili model, morate odvojiti značajke od naljepnice. Metoda koja se koristi za primjenu bilo kakve transformacije na podatke je karta.

Ova metoda poziva funkciju koju ćete stvoriti kako bi uputili kako transformirati podatke. Ukratko, morate proslijediti podatke u objektu TextLineDataset, izuzeti zaglavlje i primijeniti transformaciju koja je upućena funkcijom. Objašnjenje koda

  • tf.data.TextLineDataset (datoteka_datoteka): Ovaj redak čita CSV datoteku
  • .skip (1): preskočite zaglavlje
  • .map (parse_csv)): raščlaniti zapise u tenzoreMorate definirati funkciju koja će uputiti objekt karte. Ovu funkciju možete nazvati parse_csv.

Ova funkcija raščlanjuje csv datoteku metodom tf.decode_csv i deklarira značajke i oznaku. Značajke se mogu deklarirati kao rječnik ili skup. Koristite metodu rječnika jer je prikladnija. Objašnjenje koda

  • tf.decode_csv (vrijednost, snimke-zadane vrijednosti = RECORDS_ALL): metoda decode_csv koristi izlaz TextLineDataset za čitanje csv datoteke. record_defaults upućuje TensorFlow o vrsti stupaca.
  • dict (zip (_CSV_COLUMNS, stupci)): Popunite rječnik svim stupcima izdvojenim tijekom ove obrade podataka
  • features.pop ('median_house_value'): Izuzmite ciljanu varijablu iz varijable značajke i stvorite varijablu oznake

Skup podataka treba daljnje elemente za iterativno hranjenje tenzora. Zapravo, morate dodati ponavljanje metode kako biste omogućili da skup podataka nastavi neograničeno da bi se napajao model. Ako ne dodate metodu, model će ponoviti samo jednom, a zatim će izbaciti pogrešku jer se u cjevovod više ne unose podaci.

Nakon toga možete kontrolirati veličinu serije batch metodom. To znači da skupu podataka kažete koliko podataka želite proslijediti u cjevovod za svaku iteraciju. Ako postavite veliku veličinu serije, model će biti spor.

Korak 3) Izradite iterator

Sada ste spremni za drugi korak: stvorite iterator za vraćanje elemenata u skupu podataka.

Najjednostavniji način stvaranja operatora je metodom make_one_shot_iterator.

Nakon toga možete iz iteratora stvoriti značajke i oznake.

Korak 4) Unesite podatke

Možete provjeriti što se događa s funkcijom input_fn. Morate pozvati funkciju u sesiji da biste potrošili podatke. Pokušavate s veličinom serije jednakom 1.

Imajte na umu da značajke u rječniku i naljepnicu ispisuje kao niz.

Pokazat će prvi redak csv datoteke. Možete pokušati pokrenuti ovaj kod više puta s različitim veličinama serije.

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)

Izlaz

({'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) Definirajte stupac značajke

Morate definirati numeričke stupce kako slijedi:

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

Imajte na umu da morate kombinirati sve varijable u segmentu

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

Korak 5) Izgradite model

Model možete trenirati s procjeniteljem LinearRegressor.

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

Izlaz

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}

Morate upotrijebiti lambda funkciju da dopustite zapisivanje argumenta u funkciju inpu_fn. Ako ne koristite lambda funkciju, ne možete trenirati model.

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

Izlaz

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

Pomoću donjeg koda možete procijeniti sposobnost vašeg modela na testnom setu:

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

Izlaz

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

Posljednji korak je predviđanje vrijednosti na temelju vrijednosti, matrica značajki. Možete napisati rječnik s vrijednostima koje želite predvidjeti. Vaš model ima 9 značajki pa za svaku trebate unijeti vrijednost. Model će pružiti predviđanje za svakog od njih.

U donji kod napisali ste vrijednosti svake značajke koja se nalazi u df_predict csv datoteci.

Morate napisati novu funkciju input_fn jer u skupu podataka nema oznake. Možete koristiti API from_tensor iz skupa podataka.

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)

Napokon, ispisujete predviđanja.

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

Izlaz

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

Sažetak

Da biste trenirali model, morate:

  • Definirajte značajke: Nezavisne varijable: X
  • Definirajte oznaku: Ovisna varijabla: y
  • Napravite vlak / ispitni sklop
  • Definirajte početnu težinu
  • Definirajte funkciju gubitka: MSE
  • Optimizirajte model: Gradijentni spust
  • Definirati:
    • Stopa učenja
    • Broj epohe
    • Veličina serije

U ovom vodiču naučili ste kako koristiti API visoke razine za procjenu linearne regresije TensorFlow. Morate definirati:

  1. Stupci s značajkama. Ako je kontinuirano: tf.feature_column.numeric_column (). Popis možete popuniti razumijevanjem popisa python
  2. Procjenitelj: tf.estimator.LinearRegressor (stupci_like, model_dir)
  3. Funkcija za uvoz podataka, veličine serije i epohe: input_fn ()

Nakon toga, spremni ste za treniranje, procjenu i predviđanje s train (), evaluacija () i predviđanje ()