Ce este regresia liniară?
Regresia liniară este o abordare în statistici pentru modelarea relațiilor dintre două variabile. Această modelare se face între un răspuns scalar și una sau mai multe variabile explicative. Relația cu o variabilă explicativă se numește regresie liniară simplă și pentru mai multe variabile explicative se numește regresie liniară multiplă.
TensorFlow oferă instrumente pentru a avea control deplin asupra calculelor. Acest lucru se face cu API-ul de nivel scăzut. În plus, TensorFlow este echipat cu o gamă largă de API-uri pentru a efectua mai mulți algoritmi de învățare automată. Acesta este API-ul de nivel înalt. TensorFlow îi numește estimatori
- API de nivel scăzut: construiți arhitectura, optimizarea modelului de la zero. Este complicat pentru un începător
- API de nivel înalt: definiți algoritmul. Este mai ușor de utilizat. TensorFlow oferă un set de instrumente pentru estimarea apelurilor pentru a construi, instrui, evalua și face o predicție.
În acest tutorial, veți utiliza numai estimatorii . Calculele sunt mai rapide și sunt mai ușor de implementat. Prima parte a tutorialului explică modul de utilizare a optimizatorului de coborâre în gradient pentru a antrena o regresie liniară în TensorFlow. În a doua parte, veți utiliza setul de date Boston pentru a prezice prețul unei case folosind estimatorul TensorFlow.
Descărcați Boston DataSet
În acest tutorial TensorFlow Regression, veți afla:
- Ce este regresia liniară?
- Cum se antrenează un model de regresie liniară
- Cum se antrenează o regresie liniară cu TensorFlow
- Panda
- Soluție Numpy
- Soluție Tensorflow
Cum se antrenează un model de regresie liniară
Înainte de a începe să instruim modelul, să analizăm ce este o regresie liniară.
Imaginați-vă că aveți două variabile, x și y, iar sarcina dvs. este să preziceți valoarea cunoașterii valorii. Dacă parcelați datele, puteți vedea o relație pozitivă între variabila dvs. independentă, x și variabila dvs. dependentă y.
Puteți observa, dacă x = 1, y va fi aproximativ egal cu 6 și dacă x = 2, y va fi în jur de 8,5.
Aceasta nu este o metodă foarte precisă și predispusă la erori, mai ales cu un set de date cu sute de mii de puncte.
O regresie liniară este evaluată cu o ecuație. Variabila y este explicată de una sau mai multe covariabile. În exemplul dvs., există o singură variabilă dependentă. Dacă trebuie să scrieți această ecuație, aceasta va fi:
Cu:
- este greutatea asociată cu x
- este rezidualul sau eroarea modelului. Include ceea ce modelul nu poate învăța din date
Imaginați-vă că vă potriviți modelul și găsiți următoarea soluție pentru:
- = 3,8
- = 2,78
Puteți înlocui aceste numere în ecuație și devine:
y = 3,8 + 2,78x
Acum aveți o modalitate mai bună de a găsi valorile pentru y. Adică, puteți înlocui x cu orice valoare pe care doriți să o preziceți y. În imaginea de mai jos, înlocuim x în ecuație cu toate valorile din setul de date și trasăm rezultatul.
Linia roșie reprezintă valoarea potrivită, adică valorile lui y pentru fiecare valoare a lui x. Nu este nevoie să vedeți valoarea lui x pentru a prezice y, pentru fiecare x există orice care aparține liniei roșii. De asemenea, puteți prezice valori pentru x mai mari de 2!
Dacă doriți să extindeți regresia liniară la mai multe covariabile, puteți adăuga mai multe variabile la model. Diferența dintre analiza tradițională și regresia liniară este că regresia liniară arată cum va reacționa y pentru fiecare variabilă x luată independent.
Să vedem un exemplu. Imaginați-vă că doriți să preziceți vânzările unei înghețării. Setul de date conține informații diferite, cum ar fi vremea (adică ploios, însorit, înnorat), informații despre clienți (adică salariu, sex, stare civilă).
Analiza tradițională va încerca să prezică vânzarea, să presupunem că calculăm media pentru fiecare variabilă și vom încerca să estimăm vânzarea pentru diferite scenarii. Aceasta va duce la predicții slabe și va limita analiza la scenariul ales.
Dacă utilizați regresia liniară, puteți scrie această ecuație:
Algoritmul va găsi cea mai bună soluție pentru greutăți; înseamnă că va încerca să minimizeze costul (diferența dintre linia montată și punctele de date).
Cum funcționează algoritmul
Algoritmul va alege un număr aleatoriu pentru fiecare înlocui valoarea lui x pentru a obține valoarea prezisă a lui y. Dacă setul de date are 100 de observații, algoritmul calculează 100 de valori prezise.
Putem calcula eroarea, notată de model, care este diferența dintre valoarea prezisă și valoarea reală. O eroare pozitivă înseamnă că modelul subestimează predicția lui y, iar o eroare negativă înseamnă că modelul supraestimează predicția lui y.
Scopul dvs. este să reduceți la minimum pătratul erorii. Algoritmul calculează media erorii pătrate. Acest pas se numește minimizarea erorii. Pentru regresia liniară este eroarea pătrată medie , numită și MSE. Din punct de vedere matematic, este:
Unde:
- se referă la valoarea prezisă
- y este valorile reale
- m este numărul de observații
Rețineți că notația matematică a mediei.
Scopul este de a găsi cele mai bune care să minimizeze MSE
Dacă eroarea medie este mare, înseamnă că modelul funcționează slab și greutățile nu sunt alese corect. Pentru a corecta greutățile, trebuie să utilizați un optimizator. Optimizatorul tradițional se numește Descendență descendentă .
Coborârea în gradient ia derivata și scade sau mărește greutatea. Dacă derivatul este pozitiv, greutatea scade. Dacă derivatul este negativ, greutatea crește. Modelul va actualiza greutățile și va recalcula eroarea. Acest proces se repetă până când eroarea nu se mai modifică. Fiecare proces se numește iterație . În plus, gradienții sunt înmulțiți cu o rată de învățare. Indică viteza de învățare.
Dacă rata de învățare este prea mică, va dura foarte mult timp pentru ca algoritmul să convergă (adică necesită multe iterații). Dacă rata de învățare este prea mare, este posibil ca algoritmul să nu convergă niciodată.
Puteți vedea din imaginea de mai sus, modelul repetă procesul de aproximativ 20 de ori înainte pentru a găsi o valoare stabilă pentru greutăți, atingând astfel cea mai mică eroare.
Rețineți că , eroarea nu este egală cu zero, dar se stabilizează în jurul valorii de 5. Înseamnă că modelul face o eroare tipică de 5. Dacă doriți să reduceți eroarea, trebuie să adăugați mai multe informații la model, cum ar fi mai multe variabile sau utilizați diferiți estimatori.
Îți amintești prima ecuație
Greutățile finale sunt de 3,8 și 2,78. Videoclipul de mai jos vă arată cum coborârea în gradient optimizează funcția de pierdere pentru a găsi aceste greutăți
Cum se antrenează o regresie liniară cu TensorFlow
Acum, că aveți o mai bună înțelegere a ceea ce se întâmplă în spatele capotei, sunteți gata să utilizați API-ul estimator furnizat de TensorFlow pentru a vă antrena prima regresie liniară utilizând TensorFlow.
Veți utiliza setul de date Boston, care include următoarele variabile
crim | rata criminalității pe cap de locuitor în funcție de oraș |
---|---|
zn | proporție de teren rezidențial zonat pentru loturi de peste 25.000 de metri pătrați. |
indus | proporția de acri de afaceri care nu sunt cu amănuntul pe oraș. |
nox | concentrația de oxizi nitrici |
rm | numărul mediu de camere pe locuință |
vârstă | proporția unităților ocupate de proprietari construite înainte de 1940 |
dis | distanțe ponderate până la cinci centre de angajare din Boston |
impozit | rata totală a impozitului pe proprietate pe 10.000 de dolari |
ptratio | raportul elev-profesor pe oraș |
medv | Valoarea medie a locuințelor ocupate de proprietari în mii de dolari |
Veți crea trei seturi de date diferite:
set de date | obiectiv | formă |
---|---|---|
Instruire | Antrenează modelul și obține greutățile | 400, 10 |
Evaluare | Evaluează performanța modelului pe date nevăzute | 100, 10 |
Prezice | Utilizați modelul pentru a prezice valoarea internă a datelor noi | 6, 10 |
Obiectivul este de a utiliza caracteristicile setului de date pentru a prezice valoarea casei.
În a doua parte a tutorialului, veți învăța cum să utilizați TensorFlow cu trei moduri diferite de a importa datele:
- Cu panda
- Cu Numpy
- Numai TF
Rețineți că toate opțiunile oferă aceleași rezultate.
Veți învăța cum să utilizați API-ul de nivel înalt pentru a construi, instrui și evalua un model de regresie liniară TensorFlow. Dacă utilizați API-ul de nivel scăzut, trebuia să definiți manual:
- Funcția de pierdere
- Optimizare: coborâre în gradient
- Multiplicarea matricilor
- Grafic și tensor
Acest lucru este plictisitor și mai complicat pentru începători.
Panda
Trebuie să importați bibliotecile necesare pentru a instrui modelul.
import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools
Pasul 1) Importați datele cu panda.
Definiți numele coloanelor și le stocați în COLUMNE. Puteți utiliza pd.read_csv () pentru a importa datele.
COLUMNS = ["crim", "zn", "indus", "nox", "rm", "age","dis", "tax", "ptratio", "medv"]
training_set = pd.read_csv ("E: /boston_train.csv", skipinitialspace = Adevărat, skiprows = 1, nume = COLUMNE)
test_set = pd.read_csv ("E: /boston_test.csv", skipinitialspace = Adevărat, skiprows = 1, nume = COLUMNE)
prediction_set = pd.read_csv ("E: /boston_predict.csv", skipinitialspace = Adevărat, skiprows = 1, nume = COLUMNE)
Puteți imprima forma datelor.
print(training_set.shape, test_set.shape, prediction_set.shape)
Ieșire
(400, 10) (100, 10) (6, 10)
Rețineți că eticheta, adică y-ul dvs., este inclusă în setul de date. Deci, trebuie să definiți alte două liste. Una care conține doar caracteristicile și una cu numele etichetei numai. Aceste două liste vor spune estimatorului dvs. care sunt caracteristicile din setul de date și ce nume de coloană este eticheta
Se face cu codul de mai jos.
FEATURES = ["crim", "zn", "indus", "nox", "rm","age", "dis", "tax", "ptratio"]LABEL = "medv"
Pasul 2) Convertiți datele
Trebuie să convertiți variabilele numerice în formatul corespunzător. Tensorflow oferă o metodă de conversie a variabilei continue: tf.feature_column.numeric_column ().
În pasul anterior, definiți o listă cu o caracteristică pe care doriți să o includeți în model. Acum puteți utiliza această listă pentru a le converti în date numerice. Dacă doriți să excludeți caracteristici din modelul dvs., nu ezitați să renunțați la una sau mai multe variabile din lista CARACTERISTICI înainte de a construi feature_cols
Rețineți că veți utiliza Python list comprehension cu lista CARACTERISTICI pentru a crea o nouă listă numită feature_cols. Vă ajută să evitați să scrieți de nouă ori tf.feature_column.numeric_column (). O înțelegere a listelor este o modalitate mai rapidă și mai curată de a crea liste noi
feature_cols = [tf.feature_column.numeric_column(k) for k in FEATURES]
Pasul 3) Definiți estimatorul
În acest pas, trebuie să definiți estimatorul. Tensorflow oferă în prezent 6 estimatori pre-construiți, inclusiv 3 pentru sarcina de clasificare și 3 pentru sarcina de regresie TensorFlow:
- Regresor
- DNNRegressor
- LinearRegressor
- DNNLineaCombinedRegressor
- Clasificator
- DNNClassifier
- LinearClassifier
- DNNLineaCombinedClassifier
În acest tutorial, veți utiliza regresorul liniar. Pentru a accesa această funcție, trebuie să utilizați tf.estimator.
Funcția are nevoie de două argumente:
- feature_columns: Conține variabilele de inclus în model
- model_dir: cale pentru a stoca graficul, a salva parametrii modelului etc.
Tensorflow va crea automat un fișier numit tren în directorul dvs. de lucru. Trebuie să utilizați această cale pentru a accesa Tensorboard așa cum se arată în exemplul de regresie TensorFlow de mai jos.
estimator = tf.estimator.LinearRegressor(feature_columns=feature_cols,model_dir="train")
Ieșire
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}
Partea dificilă cu TensorFlow este modalitatea de a alimenta modelul. Tensorflow este conceput pentru a funcționa cu calcul paralel și cu seturi de date foarte mari. Datorită limitării resurselor mașinii, este imposibil să alimentați modelul cu toate datele simultan. Pentru aceasta, trebuie să alimentați de fiecare dată un lot de date. Rețineți că vorbim despre un set de date imens cu milioane sau mai multe înregistrări. Dacă nu adăugați lotul, veți ajunge la o eroare de memorie.
De exemplu, dacă datele dvs. conțin 100 de observații și definiți o dimensiune a lotului de 10, înseamnă că modelul va vedea 10 observații pentru fiecare iterație (10 * 10).
Când modelul a văzut toate datele, termină o epocă . O epocă definește de câte ori doriți ca modelul să vadă datele. Este mai bine să setați acest pas la nici unul și să lăsați modelul să efectueze iterația de câte ori.
O a doua informație de adăugat este dacă doriți să amestecați datele înainte de fiecare iterație. În timpul antrenamentului, este important să amestecați datele, astfel încât modelul să nu învețe un model specific al setului de date. Dacă modelul află detaliile tiparului de bază al datelor, va avea dificultăți în generalizarea predicției pentru datele nevăzute. Aceasta se numește supradezionare . Modelul funcționează bine în ceea ce privește datele de antrenament, dar nu poate prezice corect datele nevăzute.
TensorFlow face ca acești doi pași să fie ușor de făcut. Când datele merg la conductă, știe de câte observații are nevoie (lot) și dacă trebuie să amestece datele.
Pentru a instrui Tensorflow cum să alimenteze modelul, puteți utiliza pandas_input_fn. Acest obiect are nevoie de 5 parametri:
- x: date despre caracteristici
- y: datele etichetei
- batch_size: lot. În mod implicit 128
- num_epoch: Numărul de epocă, implicit 1
- shuffle: Shuffle sau nu datele. În mod implicit, Niciuna
Trebuie să alimentați modelul de multe ori, astfel încât să definiți o funcție pentru a repeta acest proces. toată această funcție 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)
Metoda obișnuită de evaluare a performanței unui model este:
- Antrenează modelul
- Evaluează modelul într-un set de date diferit
- Faceți predicție
Estimatorul Tensorflow oferă trei funcții diferite pentru a realiza cu ușurință acești trei pași.
Pasul 4) : Antrenează modelul
Puteți utiliza trenul estimator pentru a evalua modelul. Estimatorul trenului are nevoie de input_fn și de mai mulți pași. Puteți utiliza funcția pe care ați creat-o mai sus pentru a alimenta modelul. Apoi, instruiți modelul să itereze de 1000 de ori. Rețineți că, nu specificați numărul de epoci, lăsați modelul să itereze de 1000 de ori. Dacă setați numărul de epocă la 1, atunci modelul va itera de 4 ori: există 400 de înregistrări în setul de antrenament, iar dimensiunea lotului este 128
- 128 de rânduri
- 128 de rânduri
- 128 de rânduri
- 16 rânduri
Prin urmare, este mai ușor să setați numărul de epocă la niciunul și să definiți numărul de iterații așa cum se arată în exemplul de clasificare TensorFlow de mai jos.
estimator.train(input_fn=get_input_fn(training_set,num_epochs=None,n_batch = 128,shuffle=False),steps=1000)
Ieșire
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.
Puteți verifica dacă Tensorboard va avea următoarea comandă:
activate hello-tf# For MacOStensorboard --logdir=./train# For Windowstensorboard --logdir=train
Pasul 5) Evaluează-ți modelul
Puteți evalua potrivirea modelului dvs. pe setul de testare cu codul de mai jos:
ev = estimator.evaluate(input_fn=get_input_fn(test_set,num_epochs=1,n_batch = 128,shuffle=False))
Ieșire
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
Puteți imprima pierderea cu codul de mai jos:
loss_score = ev["loss"]print("Loss: {0:f}".format(loss_score))
Ieșire
Loss: 3215.895996
Modelul are o pierdere de 3215. Puteți verifica statistica rezumativă pentru a vă face o idee despre cât de mare este eroarea.
training_set['medv'].describe()
Ieșire
count 400.000000mean 22.625500std 9.572593min 5.00000025% 16.60000050% 21.40000075% 25.025000max 50.000000Name: medv, dtype: float64
Din statisticile rezumative de mai sus, știți că prețul mediu pentru o casă este de 22 mii, cu un preț minim de 9 mii și maxim de 50 mii. Modelul face o eroare tipică de 3k dolari.
Pasul 6) Faceți predicția
În cele din urmă, puteți utiliza estimatorul TensorFlow predict pentru a estima valoarea a 6 case din Boston.
y = estimator.predict(input_fn=get_input_fn(prediction_set,num_epochs=1,n_batch = 128,shuffle=False))
Pentru a imprima valorile estimate ale, puteți utiliza acest cod:
predictions = list(p["predictions"] for p in itertools.islice(y, 6))print("Predictions: {}".format(str(predictions)))
Ieșire
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)]
Modelul prognozează următoarele valori:
Casă |
Predicție | |
---|---|---|
1 |
32.29 | |
2 |
18,96 | |
3 |
27,27 | |
4 |
29.29 | |
5 |
16.43 | |
7 |
21.46 |
Rețineți că nu cunoaștem adevărata valoare a. În tutorialul de învățare profundă, veți încerca să bateți modelul liniar
Soluție Numpy
Această secțiune explică modul de instruire a modelului utilizând un estimator numpy pentru a alimenta datele. Metoda este aceeași excepție pe care o veți utiliza estimatorul numpy_input_fn.
training_set_n = pd.read_csv ("E: /boston_train.csv"). valori
test_set_n = pd.read_csv ("E: /boston_test.csv"). valori
prediction_set_n = pd.read_csv ("E: /boston_predict.csv"). valori
Pasul 1) Importați datele
În primul rând, trebuie să diferențiați variabilele caracteristice de etichetă. Trebuie să faceți acest lucru pentru datele de formare și evaluare. Este mai rapid să definiți o funcție pentru a împărți datele.
def prepare_data(df):X_train = df[:, :-3]y_train = df[:,-3]return X_train, y_train
Puteți utiliza funcția pentru a împărți eticheta de caracteristicile setului de date tren / evaluare
X_train, y_train = prepare_data(training_set_n)X_test, y_test = prepare_data(test_set_n)
Trebuie să excludeți ultima coloană a setului de date de predicție, deoarece conține doar NaN
x_predict = prediction_set_n[:, :-2]
Confirmați forma tabloului. Rețineți că, eticheta nu trebuie să aibă o dimensiune, înseamnă (400,).
print(X_train.shape, y_train.shape, x_predict.shape)
Ieșire
(400, 9) (400,) (6, 9)
Puteți construi coloanele de caracteristici după cum urmează:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Estimatorul este definit ca înainte, instruiți coloanele caracteristicilor și unde să salvați graficul.
estimator = tf.estimator.LinearRegressor(feature_columns=feature_columns,model_dir="train1")
Ieșire
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}
Puteți utiliza estimaporul numpy pentru a alimenta datele către model și apoi pentru a instrui modelul. Rețineți că, definim funcția input_fn înainte pentru a ușura lizibilitatea.
# 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)
Ieșire
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]:
Replicați același pas cu un estimator diferit pentru a vă evalua modelul
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)
Ieșire
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}
În cele din urmă, puteți calcula predicția. Ar trebui să fie similar cu panda.
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)))
Ieșire
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)]
Soluție Tensorflow
Ultima secțiune este dedicată unei soluții TensorFlow. Această metodă este puțin mai complicată decât cealaltă.
Rețineți că, dacă utilizați notebook-ul Jupyter, trebuie să reporniți și să curățați nucleul pentru a rula această sesiune.
TensorFlow a construit un instrument excelent pentru a transmite datele în conductă. În această secțiune, veți construi singură funcția input_fn.
Pasul 1) Definiți calea și formatul datelor
În primul rând, declarați două variabile cu calea fișierului csv. Rețineți că aveți două fișiere, unul pentru setul de antrenament și unul pentru setul de testare.
import tensorflow as tf
df_train = "E:/boston_train.csv"
df_eval = "E:/boston_test.csv"
Apoi, trebuie să definiți coloanele pe care doriți să le utilizați din fișierul CSV. Vom folosi toate. După aceea, trebuie să declarați tipul de variabilă care este.
Variabila Floats este definită de [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]]
Pasul 2) Definiți funcția input_fn
Funcția poate fi împărțită în trei părți:
- Importați datele
- Creați iteratorul
- Consumați datele
Mai jos este codul general pentru a defini funcția. Codul va fi explicat după
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
** Importați datele **
Pentru un fișier csv, metoda setului de date citește rând pe rând. Pentru a construi setul de date, trebuie să utilizați obiectul TextLineDataset. Setul dvs. de date are un antet, deci trebuie să utilizați skip (1) pentru a sări peste prima linie. În acest moment, citiți doar datele și excludeți antetul din conductă. Pentru a alimenta modelul, trebuie să separați caracteristicile de etichetă. Metoda utilizată pentru a aplica orice transformare a datelor este hartă.
Această metodă apelează o funcție pe care o veți crea pentru a instrui cum să transformați datele. Pe scurt, trebuie să treceți datele în obiectul TextLineDataset, să excludeți antetul și să aplicați o transformare care este instruită de o funcție.
- tf.data.TextLineDataset (data_file): Această linie citește fișierul csv
- .skip (1): sări peste antet
- .map (parse_csv)): analizați înregistrările în tensori Trebuie să definiți o funcție pentru a instrui obiectul hartă. Puteți apela această funcție parse_csv.
Această funcție analizează fișierul CSV cu metoda tf.decode_csv și declară caracteristicile și eticheta. Caracteristicile pot fi declarate ca dicționar sau tuplu. Folosiți metoda dicționarului, deoarece este mai convenabilă. Explicație cod
- tf.decode_csv (valoare, record_defaults = RECORDS_ALL): metoda decode_csv folosește ieșirea din TextLineDataset pentru a citi fișierul csv. record_defaults instruiește TensorFlow despre tipul de coloane.
- dict (zip (_CSV_COLUMNS, coloane)): Populați dicționarul cu toate coloanele extrase în timpul procesării datelor
- features.pop ('median_house_value'): excludeți variabila țintă din variabila caracteristică și creați o variabilă etichetă
Setul de date are nevoie de alte elemente pentru a alimenta iterativ tensorii. Într-adevăr, trebuie să adăugați metoda repetare pentru a permite setului de date să continue la nesfârșit să alimenteze modelul. Dacă nu adăugați metoda, modelul va itera o singură dată și apoi va arunca o eroare deoarece nu mai sunt introduse date în conductă.
După aceea, puteți controla dimensiunea lotului cu metoda lotului. Înseamnă că spuneți setului de date câte date doriți să transmiteți în conductă pentru fiecare iterație. Dacă setați o dimensiune mare a lotului, modelul va fi lent.
Pasul 3) Creați iteratorul
Acum sunteți gata pentru al doilea pas: creați un iterator pentru a returna elementele din setul de date.
Cel mai simplu mod de a crea un operator este cu metoda make_one_shot_iterator.
După aceea, puteți crea caracteristicile și etichetele din iterator.
Pasul 4) Consumați datele
Puteți verifica ce se întâmplă cu funcția input_fn. Trebuie să apelați funcția într-o sesiune pentru a consuma datele. Încercați cu o dimensiune a lotului egală cu 1.
Rețineți că tipărește caracteristicile într-un dicționar și eticheta ca matrice.
Va afișa prima linie a fișierului CSV. Puteți încerca să rulați acest cod de multe ori cu diferite dimensiuni de lot.
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)
Ieșire
({'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))
Pasul 4) Definiți coloana caracteristică
Trebuie să definiți coloanele numerice după cum urmează:
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')
Rețineți că trebuie să combinați toate variabilele dintr-o bucket
base_columns = [X1, X2, X3,X4, X5, X6,X7, X8, X9]
Pasul 5) Construiți modelul
Puteți instrui modelul cu estimatorul LinearRegressor.
model = tf.estimator.LinearRegressor(feature_columns=base_columns, model_dir='train3')
Ieșire
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}
Trebuie să utilizați o funcție lambda pentru a permite scrierea argumentului în funcția inpu_fn. Dacă nu utilizați o funcție lambda, nu puteți antrena modelul.
# Train the estimatormodel.train(steps =1000,input_fn= lambda : input_fn(df_train,batch_size=128, num_epoch = None))
Ieșire
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]:
Puteți evalua potrivirea modelului dvs. pe setul de test cu codul de mai jos:
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]))
Ieșire
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
Ultimul pas este prezicerea valorii bazate pe valoarea matricelor caracteristicilor. Puteți scrie un dicționar cu valorile pe care doriți să le preziceți. Modelul dvs. are 9 caracteristici, deci trebuie să oferiți o valoare pentru fiecare. Modelul va oferi o predicție pentru fiecare dintre ele.
În codul de mai jos, ați scris valorile fiecărei caracteristici conținute în fișierul csv df_predict.
Trebuie să scrieți o nouă funcție input_fn deoarece nu există nicio etichetă în setul de date. Puteți utiliza API-ul from_tensor din Dataset.
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)
În cele din urmă, tipăriți predicțiile.
for pred in enumerate(pred_results):print(pred)
Ieșire
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)})
rezumat
Pentru a instrui un model, trebuie să:
- Definiți caracteristicile: Variabile independente: X
- Definiți eticheta: Variabilă dependentă: y
- Construiți un tren / set de testare
- Definiți greutatea inițială
- Definiți funcția de pierdere: MSE
- Optimizați modelul: coborâre în gradient
- Defini:
- Rata de învățare
- Numărul epocii
- Dimensiunea lotului
În acest tutorial, ați învățat cum să utilizați API-ul de nivel înalt pentru un estimator de regresie liniară TensorFlow. Trebuie să definiți:
- Coloane cu caracteristici. Dacă este continuu: tf.feature_column.numeric_column (). Puteți completa o listă cu înțelegerea listei python
- Estimatorul: tf.estimator.LinearRegressor (feature_columns, model_dir)
- O funcție pentru importul datelor, dimensiunea lotului și epoca: input_fn ()
După aceea, sunteți gata să vă antrenați, să evaluați și să faceți predicții cu trenul (), să evaluați () și să prevedeți ()