Vodič za linearnu regresiju s TensorFlowom [Primjeri]
Evelyn Clarke
Što je linearna regresija?
Linearna regresija je pristup u statistici za modeliranje odnosa između dviju varijabli. Ovo se modeliranje provodi između skalarnog odgovora i jedne ili više eksplanatornih varijabli. Odnos s jednom objašnjavajućom varijablom naziva se jednostavna linearna regresija, a za više od jedne objašnjavajuće varijable naziva se višestruka linearna regresija.
TensorFlow pruža alate za potpunu kontrolu nad izračunima. To se radi pomoću API-ja niske razine. Povrh toga, TensorFlow je opremljen velikim nizom API-ja za izvođenje mnogih stroj za učenje algoritmi. Ovo je API visoke razine. TensorFlow ih naziva estimatorima
- API niske razine: Izgradnja arhitekture, optimizacija modela od nule. Za početnika je komplicirano
- API visoke razine: Definirajte algoritam. Lakši je. TensorFlow pruža kutiju s alatima tzv koji vrši procjenu konstruirati, obučiti, procijeniti i napraviti predviđanje.
U ovom ćete vodiču koristiti samo procjenitelji. Računanja su brža i lakša za implementaciju. Prvi dio vodiča objašnjava kako koristiti optimizator spuštanja gradijenta za treniranje linearne regresije u TensorFlowu. U drugom dijelu, koristit ćete skup podataka iz Bostona za predviđanje cijene kuće pomoću TensorFlow procjenitelja.
Kako trenirati model linearne regresije
Prije nego počnemo trenirati model, pogledajmo što je linearna regresija.
Zamislite da imate dvije varijable, x i y i vaš je zadatak predvidjeti vrijednost poznavanja vrijednosti . Ako iscrtate podatke, možete vidjeti pozitivan odnos između nezavisne varijable x i zavisne varijable y.
Možete primijetiti, ako je x=1,y će otprilike biti jednak 6, a ako je x=2,y će biti oko 8.5.
Ovo nije vrlo precizna metoda i sklona je pogreškama, posebno sa skupom podataka sa stotinama tisuća točaka.
Linearna regresija se procjenjuje jednadžbom. Varijabla y objašnjena je jednom ili više kovarijabli. U vašem primjeru postoji samo jedna zavisna varijabla. Ako morate napisati ovu jednadžbu, ona će biti:
S:
je pristranost. tj. ako je x=0, y=
je težina povezana s x
je rezidual ili greška modela. Uključuje ono što model ne može naučiti iz podataka
Zamislite da odgovarate modelu i da pronađete sljedeće rješenje za:
- = 3.8
- = 2.78
Možete zamijeniti te brojeve u jednadžbi i ona postaje:
y= 3.8 + 2.78x
Sada imate bolji način za pronalaženje vrijednosti za y. To jest, možete zamijeniti x bilo kojom vrijednošću koju želite predvidjeti y. Na donjoj slici zamijenili smo x u jednadžbi sa svim vrijednostima u skupu podataka i nacrtali rezultat.
Crvena linija predstavlja prilagođenu vrijednost, to jest vrijednosti y za svaku vrijednost x. Ne morate 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 kovarijabli, to možete učiniti dodavanjem više varijabli u model. Razlika između tradicionalne analize i linearne regresije je u tome što linearna regresija promatra kako će y reagirati za svaku varijablu x uzetu neovisno.
Pogledajmo primjer. Zamislite da želite predvidjeti prodaju u prodavaonici sladoleda. Skup podataka sadrži različite informacije kao što su vrijeme (tj. kišovito, sunčano, oblačno), informacije o kupcima (tj. plaća, spol, bračni status).
Tradicionalna analiza pokušat će predvidjeti prodaju tako što će, recimo, izračunati prosjek 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 težine; to znači da će pokušati minimizirati trošak (razlika između uklopljene linije i podatkovnih točaka).
Kako algoritam radi
Algoritam će izabrati slučajni broj za svaki 
i 
i zamijenite vrijednost x da dobijete predviđenu vrijednost y. Ako skup podataka ima 100 opažanja, algoritam izračunava 100 predviđenih vrijednosti.
Možemo izračunati pogrešku, primijećeno 
modela, što 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š cilj je minimizirati kvadrat pogreške. Algoritam izračunava srednju vrijednost kvadratne pogreške. Ovaj korak se naziva minimizacija greške. Za linearnu regresiju je Srednja kvadratna pogreška, koji se naziva i MSE. Matematički, to je:
Gdje:
je li težine tako 
odnosi se na predviđenu vrijednost- y je stvarna vrijednost
- m je broj opažanja
odnosi se na predviđenu vrijednostImajte na umu da 
znači da koristi transponiranje matrica. The 
je matematički zapis srednje vrijednosti.
Cilj je pronaći najbolje 
koji minimiziraju MSE
Ako je prosječna pogreška velika, to znači da model radi loše i da težine nisu ispravno odabrane. Da biste ispravili težine, morate koristiti optimizator. Tradicionalni optimizator se zove Gradijentni silazak.
Gradijentni pad uzima derivat i smanjuje ili povećava težinu. Ako je izvod pozitivan, težina se smanjuje. Ako je izvod negativan, težina se povećava. Model će ažurirati težine i ponovno izračunati pogrešku. Ovaj proces se ponavlja sve dok se greška više ne mijenja. Svaki proces se naziva an ponavljanje. Osim toga, gradijenti se množe stopom učenja. Označava brzinu učenja.
Ako je stopa učenja premala, trebat će jako puno vremena da algoritam konvergira (tj. zahtijeva puno ponavljanja). Ako je stopa učenja previsoka, algoritam se možda nikada neće konvergirati.
Na gornjoj slici možete vidjeti da model ponavlja postupak oko 20 puta prije kako bi pronašao stabilnu vrijednost za težine, čime se postiže 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, trebate dodati više informacija modelu kao što je više varijabli ili koristiti različite procjenitelje .
Sjećate se prve jednadžbe
Konačne težine su 3.8 i 2.78. Videozapis u nastavku pokazuje vam kako gradijentni spust optimizira funkciju gubitka za pronalaženje ovih težina
Kako trenirati linearnu regresiju s TensorFlowom
Sada kada bolje razumijete što se događa iza haube, spremni ste koristiti API za procjenu koji nudi TensorFlow za treniranje vaše prve linearne regresije pomoću TensorFlowa.
Koristit ćete Bostonski skup podataka koji uključuje sljedeće varijable
| zločinački | stopa kriminala po glavi stanovnika po gradu |
|---|---|
| zn | udio stambenog zemljišta podijeljenog na parcele veće od 25,000 sq.ft. |
| industrijski | udio ne-maloprodajnih poslovnih hektara po gradu. |
| NOx | koncentracija dušikovih oksida |
| rm | prosječan broj soba po stanu |
| starost | udio jedinica u kojima stanuju vlasnici izgrađenih prije 1940 |
| reći | mjerene udaljenosti do pet bostonskih centara za zapošljavanje |
| porez | stopa poreza na imovinu pune vrijednosti za 10,000 dolara |
| ptratio | omjer učenika i nastavnika po gradovima |
| medv | Srednja vrijednost domova u kojima žive vlasnici u tisućama dolara |
Stvorit ćete tri različita skupa podataka:
| skup podataka | cilj | oblikovati |
|---|---|---|
| Trening | Uvježbajte model i nabavite utege | 400, 10 |
| Procjena | Procijenite izvedbu modela na nevidljivim podacima | 100, 10 |
| Predvidjeti | Koristite model za predviđanje vrijednosti kuće na novim podacima | 6, 10 |
Cilj je koristiti značajke skupa podataka za predviđanje vrijednosti kuće.
Tijekom drugog dijela tutoriala naučit ćete kako koristiti TensorFlow s tri različita načina za uvoz podataka:
- S Pandama
- Kontakt numpy
- Samo TF
Imajte na umu da sve opcije dati iste rezultate.
Naučit ćete kako koristiti API visoke razine za izgradnju, obuku i procjenu TensorFlow linearnog regresijskog modela. Ako ste koristili API niske razine, morali ste ručno definirati:
- Funkcija gubitka
- Optimiziraj: Gradijentni spust
- Množenje matrica
- Graf i tenzor
Ovo je zamorno i kompliciranije za početnike.
pande
Morate uvesti potrebne biblioteke za obuku modela.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Korak 1) Uvezite podatke s panda.
Vi definirate nazive stupaca i pohranjujete ih u COLUMNS. Možete koristiti pd.read_csv() za uvoz podataka.
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čen u skup podataka. Dakle, trebate definirati još dvije liste. Jedan koji sadrži samo značajke i jedan samo s nazivom oznake. Ova dva popisa će vašem procjenitelju reći koje su značajke u skupu podataka i koji je naziv stupca oznaka
To se radi s donjim kodom.
FEATURES = ["crim", "zn", "indus", "nox", "rm",
"age", "dis", "tax", "ptratio"]
LABEL = "medv"
Korak 2) Pretvorite podatke
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čajki koje želite uključiti u model. Sada možete koristiti ovaj popis da ih pretvorite u numeričke podatke. Ako želite isključiti značajke u svom modelu, slobodno ispustite jednu ili više varijabli na popisu FEATURES prije nego što konstruirate feature_cols
Imajte na umu da ćete koristiti Python razumijevanje popisa s popisom FEATURES za stvaranje novog popisa pod nazivom feature_cols. Pomaže vam da izbjegnete pisanje devet puta tf.feature_column.numeric_column(). Razumijevanje popisa brži je i čistiji 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 trebate definirati procjenitelj. Tensorflow trenutačno nudi 6 unaprijed izgrađenih procjenitelja, uključujući 3 za zadatak klasifikacije i 3 za zadatak regresije TensorFlow:
- Regresor
- DNNRegressor
- Linearni regresor
- DNNLineaCombinedRegressor
- razvrstati
- DNNClassifikator
- Linearni klasifikator
- DNNLineaCombinedClassifier
U ovom vodiču koristit ćete linearni regresor. Za pristup ovoj funkciji morate koristiti tf.estimator.
Funkcija treba dva argumenta:
- feature_columns: Sadrži varijable koje treba uključiti u model
- model_dir: staza za pohranu grafa, spremanje parametara modela itd
Tensorflow će automatski stvoriti datoteku pod nazivom train u vašem radnom direktoriju. Morate koristiti ovaj put za pristup Tensorboardu kao što je prikazano u donjem primjeru TensorFlow regresije.
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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a215dc550>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Zamršen dio s TensorFlowom je način na koji se hrani model. Tensorflow je dizajniran za rad s paralelnim računanjem i vrlo velikim skupom podataka. Zbog ograničenja resursa stroja, nemoguće je unijeti sve podatke u model odjednom. Za to morate svaki put unijeti skup podataka. Imajte na umu da govorimo o ogromnom skupu podataka s milijunima ili više zapisa. Ako ne dodate seriju, dobit ćete pogrešku u memoriji.
Na primjer, ako vaši podaci sadrže 100 opažanja i definirate veličinu serije od 10, to znači da će model vidjeti 10 opažanja za svaku iteraciju (10*10).
Kada model vidi sve podatke, završava jedan epoha. Epoha definira koliko puta želite da model vidi podatke. Bolje je postaviti ovaj korak na nijedan i pustiti model da izvrši određeni broj iteracija.
Druga informacija koju treba dodati jest ako želite miješati podatke prije svake iteracije. Tijekom obuke važno je miješati podatke kako model ne bi naučio određeni obrazac skupa podataka. Ako model nauči pojedinosti temeljnog obrasca podataka, imat će poteškoća s generalizacijom predviđanja za nevidljive podatke. Ovo se zove prekomjerno opremanje. Model ima dobre rezultate na podacima za obuku, ali ne može točno predvidjeti za nevidljive podatke.
TensorFlow olakšava ova dva koraka. Kada podaci odu u cjevovod, zna koliko mu je promatranja potrebno (serija) i mora li miješati podatke.
Da biste uputili Tensorflow kako hraniti model, možete koristiti pandas_input_fn. Ovaj objekt treba 5 parametara:
- x: podaci o značajkama
- y: podaci oznake
- veličina_serije: serija. Prema zadanim postavkama 128
- num_epoch: broj epohe, prema zadanim postavkama 1
- shuffle: Miješajte ili ne podatke. Prema zadanim postavkama, Ništa
Morate unijeti model mnogo puta kako biste definirali funkciju za ponavljanje ovog procesa. 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:
- Uvježbajte model
- Procijenite model u drugom skupu podataka
- Napravite predviđanje
Tensorflow estimator pruža tri različite funkcije za jednostavno izvođenje ova tri koraka.
Korak 4): Uvježbajte model
Za procjenu modela možete koristiti niz procjenitelja. Procjenitelj vlaka treba input_fn i nekoliko koraka. Možete upotrijebiti funkciju koju ste izradili iznad za umetanje modela. Zatim naredite modelu da ponovi 1000 puta. Imajte na umu da ne navodite broj epoha, već puštate model da ponavlja 1000 puta. Ako postavite broj epohe na 1, tada će model ponoviti 4 puta: Postoji 400 zapisa u skupu za obuku, a veličina serije je 128
- 128 reda
- 128 reda
- 128 reda
- 16 reda
Stoga je lakše postaviti broj epoha na ništa i definirati broj iteracija kao što je prikazano u donjem primjeru 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 = 1 INFO:tensorflow:global_step/sec: 238.616 INFO:tensorflow:loss = 13909.657, step = 101 (0.420 sec) INFO:tensorflow:global_step/sec: 314.293 INFO:tensorflow:loss = 12881.449, step = 201 (0.320 sec) INFO:tensorflow:global_step/sec: 303.863 INFO:tensorflow:loss = 12391.541, step = 301 (0.327 sec) INFO:tensorflow:global_step/sec: 308.782 INFO:tensorflow:loss = 12050.5625, step = 401 (0.326 sec) INFO:tensorflow:global_step/sec: 244.969 INFO:tensorflow:loss = 11766.134, step = 501 (0.407 sec) INFO:tensorflow:global_step/sec: 155.966 INFO:tensorflow:loss = 11509.922, step = 601 (0.641 sec) INFO:tensorflow:global_step/sec: 263.256 INFO:tensorflow:loss = 11272.889, step = 701 (0.379 sec) INFO:tensorflow:global_step/sec: 254.112 INFO:tensorflow:loss = 11051.9795, step = 801 (0.396 sec) INFO:tensorflow:global_step/sec: 292.405 INFO:tensorflow:loss = 10845.855, step = 901 (0.341 sec) INFO:tensorflow:Saving checkpoints for 1000 into train/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873.
Možete provjeriti Tensorboard hoće li sljedeća naredba:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Korak 5) Ocijenite svoj model
Možete procijeniti odgovara li vaš model na testnom setu 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:13 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-01:43:13 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896
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 sumarnu statistiku da biste dobili predodžbu kolika je pogreška.
training_set['medv'].describe()
Izlaz
count 400.000000 mean 22.625500 std 9.572593 min 5.000000 25% 16.600000 50% 21.400000 75% 25.025000 max 50.000000 Name: medv, dtype: float64
Iz gornje sažete statistike znate da je prosječna cijena kuće 22 tisuće, s minimalnom 9 tisuća, a maksimalnom 50 tisuća. Model čini tipičnu pogrešku od 3 tisuće dolara.
Korak 6) Napravite predviđanje
Konačno, možete koristiti procjenitelj TensorFlow predict za procjenu vrijednosti 6 bostonskih kuća.
y = estimator.predict(
input_fn=get_input_fn(prediction_set,
num_epochs=1,
n_batch = 128,
shuffle=False))
Za ispis procijenjenih 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-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]
Model predviđa sljedeće vrijednosti:
| Kuća | Proricanje | |
|---|---|---|
| 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 tutorialu dubokog učenja pokušat ćete pobijediti linearni model
Numpy rješenje
Ovaj odjeljak objašnjava kako uvježbati model pomoću numpy procjenitelja za unos podataka. Metoda je ista osim što ćete koristiti numpy_input_fn estimator.
training_set_n = pd.read_csv(“E:/boston_train.csv”).vrijednosti
test_set_n = pd.read_csv(“E:/boston_test.csv”).vrijednosti
predviđanje_set_n = pd.read_csv(“E:/boston_predict.csv”).vrijednosti
Korak 1) Uvezite podatke
Prije svega, trebate razlikovati varijable značajki od oznake. To trebate učiniti za podatke o obuci i ocjenu. Brže je definirati funkciju za dijeljenje podataka.
def prepare_data(df):
X_train = df[:, :-3]
y_train = df[:,-3]
return X_train, y_train
Možete upotrijebiti ovu funkciju za razdvajanje oznake od značajki skupa podataka obuke/procjene
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Morate izuzeti zadnji 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, ona 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 dajete upute stupcima značajki i gdje treba spremiti grafikon.
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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1a218d8f28>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Možete koristiti numpy estimapor za unos podataka u model, a zatim trenirati model. 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 = 1 INFO:tensorflow:global_step/sec: 490.057 INFO:tensorflow:loss = 13909.656, step = 101 (0.206 sec) INFO:tensorflow:global_step/sec: 788.986 INFO:tensorflow:loss = 12881.45, step = 201 (0.126 sec) INFO:tensorflow:global_step/sec: 736.339 INFO:tensorflow:loss = 12391.541, step = 301 (0.136 sec) INFO:tensorflow:global_step/sec: 383.305 INFO:tensorflow:loss = 12050.561, step = 401 (0.260 sec) INFO:tensorflow:global_step/sec: 859.832 INFO:tensorflow:loss = 11766.133, step = 501 (0.117 sec) INFO:tensorflow:global_step/sec: 804.394 INFO:tensorflow:loss = 11509.918, step = 601 (0.125 sec) INFO:tensorflow:global_step/sec: 753.059 INFO:tensorflow:loss = 11272.891, step = 701 (0.134 sec) INFO:tensorflow:global_step/sec: 402.165 INFO:tensorflow:loss = 11051.979, step = 801 (0.248 sec) INFO:tensorflow:global_step/sec: 344.022 INFO:tensorflow:loss = 10845.854, step = 901 (0.288 sec) INFO:tensorflow:Saving checkpoints for 1000 into train1/model.ckpt. INFO:tensorflow:Loss for final step: 5925.985. Out[23]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x1a1b6ea860>
Replicirate isti korak s različitim 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:00
INFO:tensorflow:Graph was finalized.
INFO:tensorflow:Restoring parameters from train1/model.ckpt-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Finished evaluation at 2018-05-13-01:44:00
INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.158947, global_step = 1000, loss = 3215.8945
Out[24]:
{'average_loss': 32.158947, 'global_step': 1000, 'loss': 3215.8945}
Konačno, 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-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.961248], dtype=float32), array([27.270979], dtype=float32), array([29.299242], dtype=float32), array([16.43668], dtype=float32), array([21.460878], dtype=float32)]
Tensorflow rješenje
Posljednji odjeljak posvećen je rješenju TensorFlow. Ova metoda je malo kompliciranija od druge.
Imajte na umu da ako koristite Jupyter bilježnica, trebate ponovno pokrenuti i očistiti kernel da biste pokrenuli ovu sesiju.
TensorFlow je napravio izvrstan alat za prosljeđivanje podataka u cjevovod. U ovom odjeljku ćete sami izgraditi funkciju input_fn.
Korak 1) Definirajte put i format podataka
Prije svega, deklarirate dvije varijable s putanjom csv datoteke. Imajte na umu da imate dvije datoteke, jednu za skup za obuku i jednu za skup za testiranje.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Zatim trebate definirati stupce koje želite koristiti iz csv datoteke. Iskoristit ćemo sve. Nakon toga, morate deklarirati tip varijable.
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 na tri dijela:
- Uvezite podatke
- Kreirajte iterator
- Konzumirajte podatke
Ispod je opći kod za definiranje funkcije. Kod će biti objašnjen nakon
def input_fn(data_file, batch_size, num_epoch = None):
# Step 1
def parse_csv(value):
columns = tf.decode_csv(value, record_defaults= RECORDS_ALL)
features = dict(zip(COLUMNS, columns))
#labels = features.pop('median_house_value')
labels = features.pop('medv')
return features, labels
# Extract lines from input files using the
Dataset API. dataset = (tf.data.TextLineDataset(data_file) # Read text file
.skip(1) # Skip header row
.map(parse_csv))
dataset = dataset.repeat(num_epoch)
dataset = dataset.batch(batch_size)
# Step 3
iterator = dataset.make_one_shot_iterator()
features, labels = iterator.get_next()
return features, labels
** Uvezi podatke**
Za csv datoteku, metoda skupa podataka čita jedan po jedan redak. Da biste izgradili skup podataka, morate koristiti objekt TextLineSkup podataka. Vaš skup podataka ima zaglavlje pa morate koristiti skip(1) da biste preskočili prvi redak. U ovom trenutku samo čitate podatke i isključujete zaglavlje u cjevovodu. Za hranjenje modela morate odvojiti značajke od oznake. Metoda koja se koristi za primjenu bilo koje transformacije podataka je karta.
Ova metoda poziva funkciju koju ćete stvoriti kako biste dali upute kako transformirati podatke. Ukratko, morate proslijediti podatke u TextLineObjekt skupa podataka, isključite zaglavlje i primijenite transformaciju koju daje funkcija. Objašnjenje koda
- tf.podaci.TextLineSkup podataka (datoteka_datoteka): Ovaj redak čita csv datoteku
- .skip(1) : preskoči zaglavlje
- .map(parse_csv)): raščlanite zapise u tenzore. Morate definirati funkciju koja daje upute objektu karte. Ovu funkciju možete nazvati parse_csv.
Ova funkcija analizira csv datoteku metodom tf.decode_csv i deklarira značajke i oznaku. Značajke se mogu deklarirati kao rječnik ili tuple. Koristiš metodu rječnika jer je praktičnija. Objašnjenje koda
- tf.decode_csv(value, record_defaults= RECORDS_ALL): metoda decode_csv koristi izlaz TextLineSkup podataka za čitanje csv datoteke. record_defaults upućuje TensorFlow o vrsti stupaca.
- dict(zip(_CSV_COLUMNS, stupci)): Popunite rječnik svim stupcima ekstrahiranim tijekom ove obrade podataka
- features.pop('median_house_value'): Isključite ciljnu varijablu iz varijable značajke i stvorite varijablu oznake
Skupu podataka potrebni su dodatni elementi za iterativno napajanje tenzora. Doista, trebate dodati metodu repeat kako biste skupu podataka omogućili da se nastavi neograničeno hraniti model. Ako ne dodate metodu, model će ponoviti samo jednom, a zatim izbaciti pogrešku jer se u cjevovod više ne unose podaci.
Nakon toga možete kontrolirati veličinu serije metodom serije. To znači da kažete skupu podataka koliko podataka želite proslijediti u cjevovod za svaku iteraciju. Ako postavite veliku veličinu serije, model će biti spor.
Korak 3) Kreirajte iterator
Sada ste spremni za drugi korak: kreirajte iterator za vraćanje elemenata u skup podataka.
Najjednostavniji način kreiranja operatora je pomoću metode make_one_shot_iterator.
Nakon toga možete kreirati značajke i oznake iz iteratora.
Korak 4) Konzumirajte podatke
Možete provjeriti što se događa pomoću funkcije input_fn. Morate pozvati funkciju u sesiji da biste potrošili podatke. Pokušajte s veličinom serije jednakom 1.
Imajte na umu da ispisuje značajke u rječniku i oznaku kao niz.
Prikazat će prvi redak csv datoteke. Možete pokušati pokrenuti ovaj kod mnogo 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čajki
Morate definirati numeričke stupce na sljedeći način:
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 trebate kombinirati sve varijable u kantu
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Korak 5) Izgradite model
Možete uvježbati model s estimatorom 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': <tensorflow.python.training.server_lib.ClusterSpec object at 0x1820a010f0>, '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}
Morate upotrijebiti lambda funkciju kako biste omogućili pisanje argumenta u funkciji inpu_fn. Ako ne koristite a lambda funkcija, 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 = 1 INFO:tensorflow:global_step/sec: 72.5646 INFO:tensorflow:loss = 13909.657, step = 101 (1.380 sec) INFO:tensorflow:global_step/sec: 101.355 INFO:tensorflow:loss = 12881.449, step = 201 (0.986 sec) INFO:tensorflow:global_step/sec: 109.293 INFO:tensorflow:loss = 12391.541, step = 301 (0.915 sec) INFO:tensorflow:global_step/sec: 102.235 INFO:tensorflow:loss = 12050.5625, step = 401 (0.978 sec) INFO:tensorflow:global_step/sec: 104.656 INFO:tensorflow:loss = 11766.134, step = 501 (0.956 sec) INFO:tensorflow:global_step/sec: 106.697 INFO:tensorflow:loss = 11509.922, step = 601 (0.938 sec) INFO:tensorflow:global_step/sec: 118.454 INFO:tensorflow:loss = 11272.889, step = 701 (0.844 sec) INFO:tensorflow:global_step/sec: 114.947 INFO:tensorflow:loss = 11051.9795, step = 801 (0.870 sec) INFO:tensorflow:global_step/sec: 111.484 INFO:tensorflow:loss = 10845.855, step = 901 (0.897 sec) INFO:tensorflow:Saving checkpoints for 1000 into train3/model.ckpt. INFO:tensorflow:Loss for final step: 5925.9873. Out[8]: <tensorflow.python.estimator.canned.linear.LinearRegressor at 0x18225eb8d0>
Možete procijeniti pristajanje vašeg modela na testnom setu pomoću donjeg koda:
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:02 INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. INFO:tensorflow:Finished evaluation at 2018-05-13-02:06:02 INFO:tensorflow:Saving dict for global step 1000: average_loss = 32.15896, global_step = 1000, loss = 3215.896 average_loss, was: 32.158958435058594 loss, was: 3215.89599609375 global_step, was: 1000
Posljednji korak je predviđanje vrijednosti na temelju vrijednosti , matrice značajki. Možete napisati rječnik s vrijednostima koje želite predvidjeti. Vaš model ima 9 značajki pa morate navesti vrijednost za svaku. Model će dati predviđanje za svaku od njih.
U donjem kodu napisali ste vrijednosti svake značajke koja je sadržana 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)
Na kraju 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-1000
INFO:tensorflow:Running local_init_op.
INFO:tensorflow:Done running local_init_op.
(0, {'predictions': array([32.297546], dtype=float32)})
(1, {'predictions': array([18.96125], dtype=float32)})
(2, {'predictions': array([27.270979], dtype=float32)})
(3, {'predictions': array([29.299236], dtype=float32)})
(4, {'predictions': array([16.436684], dtype=float32)})
(5, {'predictions': array([21.460876], dtype=float32)})
INFO:tensorflow:Calling model_fn. INFO:tensorflow:Done calling model_fn. INFO:tensorflow:Graph was finalized. INFO:tensorflow:Restoring parameters from train3/model.ckpt-5000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. (0, {'predictions': array([35.60663], dtype=float32)}) (1, {'predictions': array([22.298521], dtype=float32)}) (2, {'predictions': array([25.74533], dtype=float32)}) (3, {'predictions': array([35.126694], dtype=float32)}) (4, {'predictions': array([17.94416], dtype=float32)}) (5, {'predictions': array([22.606628], dtype=float32)})
Rezime
Da biste obučili model, trebate:
- Definirajte značajke: Neovisne varijable: X
- Definirajte oznaku: Zavisna varijabla: y
- Konstruirajte vlak/set za testiranje
- Definirajte početnu težinu
- Definirajte funkciju gubitka: MSE
- Optimizirajte model: Gradijent spuštanja
- Definirati:
- Stopa učenja
- Broj epohe
- Veličina serije
U ovom vodiču ste naučili kako koristiti API visoke razine za TensorFlow procjenitelj linearne regresije. Trebate definirati:
- Stupci značajki. Ako je kontinuirano: tf.feature_column.numeric_column(). Popis možete popuniti razumijevanjem popisa u pythonu
- Procjenitelj: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Funkcija za uvoz podataka, veličine serije i epohe: input_fn()
Nakon toga, spremni ste za obuku, procjenu i predviđanje pomoću train(), evaluate() i predict()