Tutorial de regresie liniară cu TensorFlow [Exemple]

⚡ Rezumat inteligent

Regresia liniară în TensorFlow modelează relația dintre caracteristicile numerice și o valoare țintă continuă. Această demonstrație antrenează un predictor al prețurilor locuințelor din Boston în trei moduri separate, folosind Pandas, NumPy și conductele de intrare native TensorFlow cu estimatorul LinearRegressor.

  • 🔘 Forma model: O regresie liniară se potrivește cu y = bias + ponderare × x, extinsă cu mai multe covariate pentru probleme multivariate.
  • ☑️ Bucla de antrenament: Coborârea gradientului ajustează ponderile la fiecare iterație până când eroarea medie pătratică nu mai scade.
  • ✅ API-ul estimatorului: Funcția LinearRegressor are nevoie doar de coloane de caracteristici, un director de model și o funcție de intrare.
  • 🧪 Trei conducte: Seturile de date Pandas, NumPy și TensorFlow native alimentează același model și returnează predicții identice.
  • 🛠️ Exemplu lucrat: Nouă caracteristici ale orașului Boston prevăd valoarea mediană a unei case și ating o pierdere de test de 3215.
  • ⚠️ Versiunea realității: Estimatorii au fost depreciați în TensorFlow 2.12 și eliminați în 2.16, așadar lucrările noi trebuie portate în Keras.

Regresia liniară cu TensorFlow

Ce este regresia liniară?

linear Regression este o abordare în statistică pentru modelarea relațiilor dintre două variabile. Această modelare se realizează între un răspuns scalar și una sau mai multe variabile explicative. Relația cu o variabilă explicativă se numește regresie liniară simplă, iar cu 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 realiza multe masina de învățare algoritmi. Aceasta este API-ul de nivel înalt, iar TensorFlow le numește estimatori.

  • API de nivel scăzutConstruiți arhitectura și optimizarea modelului de la zero. Este complicat pentru un începător.
  • API de nivel înaltDefiniți algoritmul. Este ușor de utilizat. TensorFlow oferă o cutie de instrumente numită estimator pentru a construi, antrena, evalua și face o predicție.

În acest tutorial, veți folosi numai estimatoriCalculele sunt mai rapide și mai ușor de implementat. Prima parte explică modul de utilizare a optimizatorului de descreștere a gradientului pentru a antrena o regresie liniară în TensorFlow. Într-o a doua parte, veți utiliza setul de date Boston pentru a prezice prețul unei case folosind un estimator TensorFlow.

Descărcați Boston DataSet

Cum se antrenează un model de regresie liniară

Înainte de a începe antrenarea modelului, să vedem ce este de fapt o regresie liniară.

Imaginează-ți că ai două variabile, x și y, iar sarcina ta este să prezici valoarea lui y cunoscând valoarea lui x. Dacă reprezinți grafic datele, poți observa o relație pozitivă între variabila independentă, x, și variabila dependentă, y, așa cum arată diagrama de dispersie de mai jos.

Diagramă de dispersie a lui x în funcție de y care prezintă o relație liniară pozitivă

Puteți observa că dacă x = 1, y va fi aproximativ egal cu 6, iar dacă x = 2, y va fi în jur de 8.5.

Aceasta nu este o metodă foarte precisă și este predispusă la erori, mai ales în cazul unui set de date care conține sute de mii de puncte.

O regresie liniară este evaluată cu o ecuație. Variabila y este explicată prin una sau mai multe covariabile. În exemplul dvs., există o singură variabilă dependentă. Dacă trebuie să scrieți această ecuație, va fi:

Ecuație simplă de regresie liniară cu o eroare, o pondere și un termen de eroare

Cu:

  • Simbolul coeficientului de polarizare este tendința. Adică, dacă x=0, y=Valoarea coeficientului de polarizare când x este egal cu zero
  • Simbolul coeficientului de ponderare asociat cu x este greutatea asociată cu x
  • Simbolul termenului de eroare reziduală este reziduul 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:

  • Coeficient de polarizare ajustat egal cu 3.8 = 3.8
  • Coeficient de greutate ajustat egal cu 2.78 = 2.78

Puteți înlocui acele 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 doriți pentru a prezice y. În imaginea de mai jos, am înlocuit x în ecuație cu toate valorile din setul de date și am reprezentat grafic rezultatul.

Linie de regresie ajustată trasată cu roșu prin punctele de date reprezentate grafic

Linia roșie reprezintă valoarea ajustată, 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ă o valoare care aparține liniei roșii. De asemenea, puteți prezice valori ale lui x mai mari de 2.

Dacă doriți să extindeți regresia liniară la mai multe covariate, puteți face acest lucru adăugând mai multe variabile la model. Diferența dintre analiza tradițională și regresia liniară este că regresia liniară analizează modul în care y va reacționa pentru fiecare variabilă x luată independent.

Să vedem un exemplu. Imaginați-vă că doriți să preziceți vânzările unei gelaterii. Setul de date conține diferite informații, cum ar fi vremea (ploios, însorit, înnorat) și informații despre clienți (salariu, sex, stare civilă).

Analiza tradițională va încerca să prezică vânzarea, să zicem, calculând media pentru fiecare variabilă și încercând să estimeze vânzarea pentru diferite scenarii. Aceasta va duce la predicții slabe și va restricționa analiza la scenariul ales.

Dacă utilizați regresia liniară, puteți scrie această ecuație:

Ecuație de regresie liniară multiplă care combină mai multe covariabile ponderate

Algoritmul va găsi cea mai bună soluție pentru ponderi; asta înseamnă că va încerca să minimizeze costul, care este diferența dintre linia ajustată și punctele de date.

Cum funcționează algoritmul

Diagrama de mai jos rezumă bucla pe care o repetă algoritmul: alegerea ponderilor, prezicerea lui y, măsurarea erorii și corectarea ponderilor.

Diagrama de flux a buclei de antrenament de regresie liniară de la ponderi aleatorii la eroare minimizată

Algoritmul va alege un număr aleatoriu pentru fiecare Coeficient de polarizare inițializat aleatoriu și Coeficient de ponderare inițializat aleatoriu și înlocuiți 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, a notat Termenul de eroare al modelului utilizat în calculul pierderilor, a modelului, 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.

Obiectiv de minimizare a erorii pătratice scris în notație matematică

Scopul tău este să minimizezi pătratul erorii. Algoritmul calculează media erorii pătratice. Acest pas se numește minimizarea erorii. Pentru regresia liniară, aceasta este Eroare pătrată medie, numit și MSE. Din punct de vedere matematic, este:

Formula erorii medii pătratice scrisă în notație matricială

Unde:

  • Simbolul vectorului de greutate utilizat în formula MSE sunt greutățile, deci Notația valorii prezise utilizată în formula MSE se referă la valoarea prezisă
  • y este valorile reale
  • m este numărul de observații

Rețineți că Notația matricei de ponderi transpuse înseamnă că folosește transpunerea matricelor. The Notația sumativă și medie utilizată în formula MSE este notația matematică a mediei.

Scopul este de a găsi cel mai bun Simbolul greutății optime care minimizează MSE-ul care minimizează MSE-ul.

Dacă eroarea medie este mare, înseamnă că modelul are performanțe slabe și greutățile nu sunt alese corect. Pentru a corecta greutățile, trebuie să utilizați un optimizator. Optimizatorul tradițional este numit Coborâre în gradient.

Coborârea gradientului preia derivata și scade sau crește ponderea. Dacă derivata este pozitivă, ponderea scade. Dacă derivata este negativă, ponderea crește. Modelul va actualiza ponderile și va recalcula eroarea. Acest proces se repetă până când eroarea nu se mai modifică. Fiecare trecere se numește... repetareÎn plus, gradienții sunt înmulțiți cu o rată de învățare, care indică viteza învățării.

Dacă rata de învățare este prea mică, va dura foarte mult până când algoritmul va converge, deoarece necesită mult mai multe iterații. Dacă rata de învățare este prea mare, algoritmul s-ar putea să nu convergă niciodată. Curba de pierderi de mai jos reprezintă grafic eroarea în funcție de numărul de iterații pentru acest set de date.

Curba de pierdere care arată scăderea și stabilizarea erorii după aproximativ douăzeci de iterații

Puteți observa din imaginea de mai sus că modelul repetă procesul de aproximativ 20 de ori înainte de a găsi o valoare stabilă pentru ponderi, atingând astfel cea mai mică eroare.

Rețineți că eroarea nu este egală cu zero, ci se stabilizează în jurul valorii de 5. Aceasta î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 să utilizați estimatori diferiți.

Îți amintești prima ecuație:

Ecuația de regresie liniară ajustată finală cu ponderile rezolvate

Ponderile finale sunt 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 ponderi.

Cum să antrenezi o regresie liniară cu TensorFlow

Acum că înțelegeți mai bine ce se întâmplă în spatele capotei, sunteți gata să utilizați API-ul estimator furnizat de TensorFlow pentru a antrena prima regresie liniară folosind TensorFlow.

Notă privind versiunea: Fluxul de lucru al estimatorului prezentat mai jos a fost scris pentru TensorFlow 1.x și versiunile timpurii 2.x. TensorFlow a marcat tf.estimator și tf.feature_column API-urile au fost complet depreciate în versiunea 2.12 și au fost eliminate Estimators în versiunea 2.16. La o instalare curentă, rulați acest cod într-un TensorFlow 1.15 sau 2.x-with-tf.compat.v1 mediu sau să îl portezi la Keras, unde tf.keras.layers.Dense(1) plus straturile de preprocesare înlocuiesc LinearRegressor și coloanele de caracteristici. Conceptele - caracteristici, etichete, loturi, epoci, MSE și coborâre în gradient - rămân neschimbate.

Veți utiliza setul de date Boston, care include următoarele variabile.

Variabil Descriere
crim rata criminalității pe cap de locuitor pe oraș
zn proporție de teren rezidențial zonat pentru loturi de peste 25,000 sq.ft.
Indus proporția de hectare comerciale non-retail pe oraș.
nox concentrația de oxizi nitrici
rm numărul mediu de camere pe locuință
vârstă proporția de unități ocupate de proprietar construite înainte de 1940
spune distanțe ponderate până la cinci centre de angajare din Boston
impozit cota de impozit pe proprietate la valoarea întreagă pe 10,000 de dolari
ptratio raportul elev-profesor pe oraș
medv Valoarea medie a caselor ocupate de proprietari în mii de dolari

Veți crea trei seturi de date diferite:

date CCD obiectiv forma
Pregătire Antrenați modelul și obțineți greutățile 400, 10
Evaluare Evaluați performanța modelului pe date nevăzute 100, 10
prezice Utilizați modelul pentru a estima valoarea casei pe date 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 în trei moduri diferite de a importa datele:

  • Cu panda
  • cu NumPy
  • Doar TensorFlow

Rețineți că toate cele trei opțiuni oferă aceleași rezultate.

Vei învăța cum să utilizezi API-ul de nivel înalt pentru a construi, antrena și evalua un model de regresie liniară TensorFlow. Dacă ai utiliza API-ul de nivel scăzut, ar trebui să definești manual:

  • Funcția de pierdere
  • Optimizator: coborâre în gradient
  • Înmulțirea matricelor
  • Grafic și tensor

Acest lucru este plictisitor și mai complicat pentru un începător.

Soluția Pandas

Trebuie să importați bibliotecile necesare pentru a antrena modelul.

import pandas as pd
from sklearn import datasets
import tensorflow as tf
import itertools

Pas 1) Importă datele cu ursi panda.

Definești numele coloanelor și le stochezi în COLUMNS. Poți folosi pd.read_csv() pentru a importa datele.

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

Îndreptați fiecare apel către fișierele CSV pe care le-ați descărcat anterior.

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)

Puteți imprima forma datelor.

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

producție

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

Rețineți că eticheta, adică y-ul dvs., este inclusă în setul de date. Prin urmare, trebuie să definiți alte două liste: una care conține doar caracteristicile și una care conține doar numele etichetei. Aceste două liste îi vor spune estimatorului dvs. care sunt caracteristicile din setul de date și care nume de coloană este eticheta.

Se face cu codul de mai jos.

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

Pas 2) Convertiți datele

Trebuie să convertiți variabilele numerice în formatul corect. TensorFlow oferă o metodă pentru a converti o variabilă continuă: tf.feature_column.numeric_column().

În pasul anterior, ați definit o listă de caracteristici pe care doriți să le 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 model, puteți elimina una sau mai multe variabile din lista FEATURES înainte de a construi feature_cols.

Rețineți că veți folosi un Python înțelegerea listei cu lista FEATURES pentru a crea o listă nouă numită feature_cols. Acest lucru vă ajută să evitați scrierea funcției tf.feature_column.numeric_column() de nouă ori. O înțelegere a listei 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]

Pas 3) Definiți estimatorul

În acest pas, trebuie să definiți estimatorul. TensorFlow oferă șase estimatori predefiniti, trei pentru sarcini de clasificare și trei pentru sarcini de regresie TensorFlow:

  • Regressor
    • DNNRegressor
    • LinearRegressor
    • Regresor combinat liniar DNNLiner
  • clasifica
    • DNNClassifier
    • Clasificator liniar
    • DNNLinearCombinedClassifier

În acest tutorial, veți folosi Linear Regressor. 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: calea pentru stocarea graficului, salvarea parametrilor modelului și așa mai departe

TensorFlow va crea automat un folder numit train în directorul 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")

producție

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}

Partea dificilă cu TensorFlow este modul de alimentare a modelului. TensorFlow este conceput să funcționeze cu calcul paralel și seturi de date foarte mari. Din cauza limitării resurselor mașinii, este imposibil să se alimenteze modelul cu toate datele simultan. Pentru aceasta, trebuie să se alimenteze un lot de date de fiecare dată. Rețineți că vorbim despre seturi de date uriașe, cu milioane sau mai multe înregistrări. Dacă nu adăugați un lot, veți ajunge să aveți o eroare de memorie.

De exemplu, dacă datele dumneavoastră 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, acesta 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 zero și să lăsați modelul să efectueze un număr stabilit de iterații.

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 anumit model al setului de date. Dacă modelul învață detaliile modelului subiacent al datelor, va avea dificultăți în generalizarea predicției pentru datele nevăzute. Aceasta se numește supraadaptare. Modelul are performanțe bune pe datele de antrenament, dar nu poate prezice corect pentru datele nevăzute.

TensorFlow simplifică acești doi pași. Când datele ajung în canal, știe de câte observații are nevoie (în 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 cinci parametri:

  • x: date caracteristice
  • y: date de etichetă
  • batch_size: lot. Implicit 128
  • num_epoch: numărul de epoci, implicit 1
  • amestecare: amestecă datele sau nu. În mod implicit, Niciuna

Trebuie să alimentați modelul de mai multe ori, așa că definiți o funcție pentru a repeta acest proces. Apelați 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
  • Evaluați modelul pe un set de date diferit
  • Faceți o predicție

Estimatorul TensorFlow oferă trei funcții diferite pentru a realiza cu ușurință acești trei pași.

Pas 4) Antrenează modelul

Puteți utiliza metoda trenului de estimatori pentru a ajusta modelul. Estimatorul trenului are nevoie de un input_fn și de un număr de pași. Puteți utiliza funcția creată mai sus pentru a alimenta modelul. Apoi, instruiți modelul să iterateze de 1000 de ori. Rețineți că nu specificați numărul de epoci; lăsați modelul să iterateze de 1000 de ori. Dacă setați numărul de epoci la 1, atunci modelul va itera de patru ori, deoarece există 400 de înregistrări în setul de antrenament, iar dimensiunea lotului este de 128:

  1. 128 de rânduri
  2. 128 de rânduri
  3. 128 de rânduri
  4. 16 de rânduri

Prin urmare, este mai ușor să setezi numărul de epoci la zero și să definești 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)

producție

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.

Puteți verifica TensorBoard cu următoarea comandă:

activate hello-tf
# For MacOS
tensorboard --logdir=./train
# For Windows
tensorboard --logdir=train

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

producție

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

Puteți imprima pierderea cu codul de mai jos:

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

producție

Loss: 3215.895996

Modelul are o pierdere de 3215. Puteți verifica statisticile rezumative pentru a vă face o idee despre cât de mare este eroarea.

training_set['medv'].describe()

producție

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

Din statistica rezumativă de mai sus, știți că prețul mediu pentru o casă este de 22 de mii, cu un preț minim de 5 mii și un maxim de 50 de mii. Deoarece pierderea raportată este eroarea medie pătratică, eroarea tipică în unitățile originale este aproximativ rădăcina pătrată din 32.16, ceea ce reprezintă aproximativ 5.7 mii de dolari.

Pas 6) Faceți predicția

În cele din urmă, puteți utiliza metoda de predicție a estimatorului TensorFlow pentru a estima valoarea a șase case din Boston.

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

Pentru a afișa valorile estimate, puteți utiliza acest cod:

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

producție

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

Modelul prognozează următoarele valori:

casă Prezicere
1 32.29
2 18.96
3 27.27
4 29.29
5 16.43
6 21.46

Rețineți că nu cunoaștem adevărata valoare a acestor șase case. În tutorialul de deep learning, veți încerca să depășiți modelul liniar.

Soluția NumPy

Această secțiune explică modul de antrenare a modelului folosind un estimator NumPy pentru a alimenta datele. Metoda este aceeași, cu excepția faptului că veți utiliza estimatorul numpy_input_fn.

Citește aceleași trei fișiere CSV, dar păstrează doar matricele NumPy brute cu .values.

training_set_n = pd.read_csv("E:/boston_train.csv").values
test_set_n = pd.read_csv("E:/boston_test.csv").values
prediction_set_n = pd.read_csv("E:/boston_predict.csv").values

Pas 1) Importă datele

În primul rând, trebuie să diferențiezi variabilele caracteristice de etichetă. Trebuie să faci acest lucru pentru datele de antrenament și datele de evaluare. Este mai rapid să definești o funcție pentru a diviza 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 separa eticheta de caracteristicile trenului și a evalua seturile de date.

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 aceasta conține doar NaN.

x_predict = prediction_set_n[:, :-2]

Confirmați forma matricei. Rețineți că eticheta nu trebuie să aibă o a doua dimensiune, ceea ce înseamnă (400,).

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

producție

(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: specificați coloanele de caracteristici și locul unde se salvează graficul.

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

producție

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}

Puteți utiliza estimatorul NumPy pentru a introduce datele în model și apoi pentru a antrena modelul. Rețineți că definim funcția input_fn în prealabil pentru a facilita lizibilitatea.

# Train the estimator
train_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)

producție

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>

Replicați același pas cu o funcție de intrare diferită pentru a 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)

producție

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}

În final, poți calcula predicția. Ar trebui să fie similară cu rezultatul Pandas.

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

producție

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

Soluție TensorFlow

Ultima secțiune este dedicată unui aspect pur TensorFlow soluție. Această metodă este puțin mai complicată decât celelalte două.

Rețineți că, dacă utilizați un Jupyter caiet, trebuie să reporniți și să ștergeți kernelul 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.

Pas 1) Definiți calea și formatul datelor

În primul rând, declarați două variabile cu calea către fișierele 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. Le vom folosi pe toate. După aceea, trebuie să declarați tipul fiecărei variabile.

Variabilele cu număr de înălțimi flotante sunt definite prin [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]]

Pas 2) Definiți funcția input_fn

Funcția poate fi împărțită în trei părți:

  1. Importă datele
  2. Creați iteratorul
  3. Consumați datele

Mai jos este codul general pentru definirea funcției. Codul va fi explicat ulterior.

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

Importă datele

Pentru un fișier CSV, metoda dataset citește câte o linie pe rând. Pentru a construi setul de date, trebuie să utilizați obiectul TextLineSet de date. Setul dvs. de date are un antet, așa că 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 fluxul de lucru. Pentru a alimenta modelul, trebuie să separați caracteristicile de etichetă. Metoda utilizată pentru a aplica orice transformare datelor este harta.

Această metodă apelează o funcție pe care o veți crea pentru a instrui cum să transforme datele. Pe scurt, trebuie să transmiteți datele în TextLineObiect Dataset, exclude antetul și aplică o transformare instruită de o funcție.

Code explicație

  • tf.data.TextLineDataset(data_file): această linie citește fișierul CSV
  • .skip(1): sare peste antet
  • .map(parse_csv)): analizează înregistrările în tensori

Trebuie să definiți o funcție care să instruiască obiectul hărții. 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 un dicționar sau ca un tuplu. Metoda dicționarului se utilizează deoarece este mai convenabilă.

Code explicație

  • tf.decode_csv(value, record_defaults= RECORDS_ALL): metoda decode_csv folosește ieșirea TextLineSet de date pentru citirea fișierului CSV. record_defaults dă instrucțiuni TensorFlow cu privire la tipurile de coloane. În TensorFlow 2.x, acest simbol se află la tf.io.decode_csv.
  • dict(zip(COLOANE, coloane)): populează dicționarul cu toate coloanele extracutilizate în timpul acestei prelucrări de date
  • features.pop('medv'): exclude variabila țintă din variabilele de caracteristică și creează o variabilă de etichetă

Setul de date are nevoie de elemente suplimentare pentru a alimenta iterativ tensorii. Într-adevăr, trebuie să adăugați metoda `repeat` pentru a permite setului de date să continue la nesfârșit pentru a alimenta modelul. Dacă nu adăugați metoda, modelul va itera o singură dată și apoi va genera o eroare deoarece nu mai sunt introduse date în pipeline.

După aceea, puteți controla dimensiunea lotului cu metoda batch. Aceasta înseamnă că îi spuneți setului de date câte date doriți să fie transmise în conductă pentru fiecare iterație. Dacă setați o dimensiune mare a lotului, modelul va fi lent.

Pas 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.

Pas 4) Consumați datele

Poți verifica ce se întâmplă cu funcția input_fn. Trebuie să apelezi funcția într-o sesiune pentru a consuma datele. Încerci cu o dimensiune a lotului egală cu 1.

Rețineți că afișează caracteristicile dintr-un dicționar și eticheta ca o matrice.

Va afișa prima linie a fișierului CSV. Puteți încerca să rulați acest cod de mai multe ori cu loturi de diferite dimensiuni.

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)

producție

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

Pas 5) 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 într-un bucket.

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

Pas 6) Construiți modelul

Puteți antrena modelul cu estimatorul LinearRegressor.

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

producție

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}

Trebuie să utilizați un funcția lambda pentru a vă permite să scrieți argumentele pentru funcția input_fn. Dacă nu utilizați o funcție lambda, nu puteți antrena modelul.

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

producție

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>

Puteți evalua potrivirea modelului dvs. pe setul de testare 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]))

producție

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

Ultimul pas este prezicerea valorii țintei pe baza valorii matricei de caracteristici. Puteți scrie un dicționar cu valorile pe care doriți să le preziceți. Modelul dvs. are nouă caracteristici, așa că trebuie să furnizați o valoare pentru fiecare. Modelul va oferi o predicție pentru fiecare dintre ele.

În codul de mai jos, scrieți 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_tensors din obiectul 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_input
     pred_results = model.predict(input_fn=test_input_fn)

În cele din urmă, imprimați predicțiile.

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

producție

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

Toate cele trei conducte returnează aceleași șase predicții, ceea ce confirmă că alegerea între Pandas, NumPy și un set de date TensorFlow nativ este o chestiune de comoditate, nu de acuratețe.

Întrebări frecvente

Nu. TensorFlow a marcat Estimatorii și coloanele de caracteristici ca fiind complet depreciate în versiunea 2.12 și le-a eliminat în versiunea 2.16. Fixați TensorFlow 1.15 sau 2.15 pentru a rula acest cod fără modificări sau rescrieți modelul cu straturi Keras, lucru recomandat acum de echipa TensorFlow.

Încărcați fișierele CSV cu ursi panda, scalează cele nouă caracteristici cu un strat de normalizare, apoi suprapune o singură unitate Dense(1). Compilează cu un optimizator și o pierdere mean_squared_error, apoi apelează fit. O unitate densă fără activare este o regresie liniară.

Începeți în jurul valorii de 0.01 și ajustați cu factori de zece. O rată prea mică necesită mult mai multe iterații pentru a converge, în timp ce o rată prea mare face ca pierderea să oscileze. Trasați curba pierderii și păstrați cea mai mare rată care scade în continuare uniform.

scikit-learn a eliminat fișierul load_boston în versiunea 1.2 din cauza preocupărilor etice legate de o variabilă rasială modificată genetic. Acest tutorial citește fișiere CSV simple, deci linkul de descărcare funcționează în continuare, dar proiectele noi ar trebui să utilizeze în schimb seturile de date privind locuințele din California sau Ames.

Eroarea medie pătratică restabilește unitățile originale, eroarea absolută medie previne valorile aberante, iar R-pătrat raportează ponderea varianței explicate. Raportați o metrică a erorii absolute alături de R-pătrat, deoarece un R-pătrat ridicat poate ascunde în continuare erori individuale mari de predicție.

Regresia liniară prezice un număr continuu, cum ar fi prețul unei case. A clasificator liniar prezice o etichetă de clasă discretă. Ambele se potrivesc unei sume ponderate a caracteristicilor, dar clasificatorul trece suma respectivă printr-un prag de decizie.

Conductele automate evaluează caracteristicile cu regularizare Lasso, informații reciproce sau importanță permutării, apoi le elimină pe cele mai slabe. Instrumentele AutoML caută împreună opțiunile de preprocesare și modelare, astfel încât să petreceți mai puțin timp alegând manual coloanele care aparțin în feature_cols.

Copilot schițează rapid exemple de tip boilerplate, inclusiv funcții de intrare, liste de coloane de caracteristici și bucle de evaluare. Tratați fiecare sugestie ca pe o schiță, deoarece emite frecvent apeluri Estimator depreciate. Verificați fiecare simbol generat în raport cu API-ul TensorFlow curent înainte de a-l rula.

Rezumați această postare cu: