Lineárna regresia s TensorFlow (príklady)

Obsah:

Anonim

Čo je to lineárna regresia?

Lineárna regresia je prístup v štatistike na modelovanie vzťahov medzi dvoma premennými. Toto modelovanie sa vykonáva medzi skalárnou odozvou a jednou alebo viacerými vysvetľujúcimi premennými. Vzťah s jednou vysvetľujúcou premennou sa nazýva jednoduchá lineárna regresia a pre viac ako jednu vysvetľujúcu premennú sa nazýva viacnásobná lineárna regresia.

TensorFlow poskytuje nástroje na úplnú kontrolu nad výpočtami. To sa deje pomocou nízkoúrovňového API. Okrem toho je TensorFlow vybavený širokou škálou API na vykonávanie mnohých algoritmov strojového učenia. Toto je API na vysokej úrovni. TensorFlow ich nazýva odhadov

  • Nízkoúrovňové API: Budujte architektúru, optimalizáciu modelu od nuly. Pre začiatočníka je to komplikované
  • High-level API: Definujte algoritmus. Je to jednoduchšie ako priateľské. TensorFlow poskytuje nástroj na odhadovanie volaní na zostavenie, školenie, hodnotenie a predpovedanie.

V tomto výučbe budete používať iba odhady . Výpočty sú rýchlejšie a ľahšie sa implementujú. Prvá časť tutoriálu vysvetľuje, ako používať optimalizátor zostupu gradientu na trénovanie lineárnej regresie v TensorFlow. V druhej časti použijete Bostonský dátový súbor na predpovedanie ceny domu pomocou odhadcu TensorFlow.

Stiahnite si Boston DataSet

V tomto výučbe TensorFlow Regression sa dozviete:

  • Čo je to lineárna regresia?
  • Ako trénovať model lineárnej regresie
  • Ako trénovať lineárnu regresiu s TensorFlow
  • Pandy
  • Numpy riešenie
  • Riešenie Tensorflow

Ako trénovať model lineárnej regresie

Predtým, ako začneme trénovať model, pozrime sa, čo je lineárna regresia.

Predstavte si, že máte dve premenné xay a vašou úlohou je predpovedať hodnotu poznania hodnoty. Ak vykreslíte údaje, môžete vidieť pozitívny vzťah medzi vašou nezávislou premennou x a závislou premennou y.

Môžete pozorovať, že ak x = 1, y bude zhruba rovné 6 a ak x = 2, y bude okolo 8,5.

Toto nie je veľmi presná metóda a je náchylná na chyby, najmä pokiaľ ide o množinu údajov so státisícami bodov.

Lineárna regresia sa hodnotí pomocou rovnice. Premenná y je vysvetlená jednou alebo viacerými premennými. Vo vašom príklade existuje iba jedna závislá premenná. Ak musíte napísať túto rovnicu, bude to:

S:

  • je váha spojená s x
  • je zostatok alebo chyba modelu. Zahŕňa to, čo sa model nemôže naučiť z údajov

Predstavte si, že zapadáte do modelu a nájdete nasledujúce riešenie pre:

  • = 3,8
  • = 2,78

Tieto čísla môžete v rovnici nahradiť a stane sa:

y = 3,8 + 2,78x

Teraz máte lepší spôsob, ako nájsť hodnoty pre y. To znamená, že môžete nahradiť x akoukoľvek hodnotou, ktorú chcete predpovedať y. Na obrázku nižšie nahradíme x v rovnici všetkými hodnotami v množine údajov a vykreslíme výsledok.

Červená čiara predstavuje prispôsobenú hodnotu, to znamená hodnoty y pre každú hodnotu x. Na predpovedanie y nemusíte vidieť hodnotu x, pre každé x je nejaké, ktoré patrí do červenej čiary. Môžete tiež predpovedať pre hodnoty x vyššie ako 2!

Ak chcete rozšíriť lineárnu regresiu na viac premenných, môžete to urobiť tak, že do modelu pridáte ďalšie premenné. Rozdiel medzi tradičnou analýzou a lineárnou regresiou spočíva v lineárnej regresii, ktorá sleduje, ako bude y reagovať na každú premennú x nezávisle od seba.

Pozrime sa na príklad. Predstavte si, že chcete predpovedať predaj zmrzlinárne. Dátový súbor obsahuje rôzne informácie, ako napríklad počasie (tj daždivé, slnečné, oblačné počasie), informácie o zákazníkoch (tj. Plat, pohlavie, rodinný stav).

Tradičná analýza sa pokúsi predpovedať predaj povedzme výpočtom priemeru pre každú premennú a pokúsi sa odhadnúť predaj pre rôzne scenáre. Povedie to k zlým predpovediam a analýza sa obmedzí na zvolený scenár.

Ak použijete lineárnu regresiu, môžete napísať túto rovnicu:

Algoritmus nájde najlepšie riešenie pre váhy; to znamená, že sa pokúsi minimalizovať náklady (rozdiel medzi namontovanou linkou a dátovými bodmi).

Ako funguje algoritmus

Algoritmus vyberie náhodné číslo pre každé a nahradiť hodnotu x dostať predpovedanej hodnoty y. Ak má množina údajov 100 pozorovaní, algoritmus vypočíta 100 predpokladaných hodnôt.

Môžeme vypočítať chybu zaznamenanú v modeli, ktorá predstavuje rozdiel medzi predpokladanou a skutočnou hodnotou. Kladná chyba znamená, že model podhodnocuje predpoveď y, a záporná chyba znamená, že model nadhodnocuje predpoveď y.

Vaším cieľom je minimalizovať druhú mocninu chyby. Algoritmus počíta strednú mocninu chyby. Tento krok sa nazýva minimalizácia chyby. Pre lineárnu regresiu je stredná štvorcová chyba , ktorá sa tiež nazýva MSE. Matematicky to je:

Kde:

  • odkazuje na predpokladanú hodnotu
  • y sú skutočné hodnoty
  • m je počet pozorovaní

To je matematický zápis priemeru.

Cieľom je nájsť to najlepšie, čo minimalizuje MSE

Ak je priemerná chyba veľká, znamená to, že model podáva zlý výkon a váhy nie sú vybrané správne. Na opravu váh je potrebné použiť optimalizátor. Tradičný optimalizátor sa volá Gradient Descent .

Gradientový zostup vezme deriváciu a zníži alebo zvýši váhu. Ak je derivát pozitívny, váha sa zníži. Ak je derivát záporný, váha sa zvyšuje. Model aktualizuje váhy a prepočíta chybu. Tento proces sa opakuje, kým sa chyba už nezmení. Každý proces sa nazýva iterácia . Okrem toho sú prechody násobené rýchlosťou učenia. Udáva rýchlosť učenia.

Ak je rýchlosť učenia príliš malá, konvergovanie algoritmu bude trvať veľmi dlho (vyžaduje veľa iterácií). Ak je rýchlosť učenia príliš vysoká, algoritmus sa nemusí nikdy spojiť.

Ako je zrejmé z obrázku vyššie, model opakuje postup asi 20-krát predtým, aby našiel stabilnú hodnotu váh, čím dosahuje najnižšiu chybu.

Upozorňujeme , že chyba sa nerovná nule, ale stabilizuje sa okolo 5. Znamená to, že model robí typickú chybu 5. Ak chcete chybu znížiť, musíte do modelu pridať viac informácií, napríklad viac premenných alebo použiť rôzne odhady.

Pamätáte si prvú rovnicu

Konečné hmotnosti sú 3,8 a 2,78. Video nižšie ukazuje, ako gradientný zostup optimalizuje stratovú funkciu na nájdenie týchto váh

Ako trénovať lineárnu regresiu s TensorFlow

Teraz, keď lepšie rozumiete tomu, čo sa deje za kapotou, ste pripravení použiť odhadovacie API poskytované TensorFlow na trénovanie vašej prvej lineárnej regresie pomocou TensorFlow.

Použijete dataset z Bostonu, ktorý obsahuje nasledujúce premenné

krimpovať miera kriminality na obyvateľa podľa mesta
zn podiel obytných pozemkov rozdelených na zóny s veľkosťou nad 25 000 štvorcových stôp
priemysel podiel maloobchodných akrov na jedno mesto.
nox koncentrácia oxidov dusnatých
rm priemerný počet izieb na byt
Vek podiel jednotiek obývaných vlastníkmi postavených pred rokom 1940
dis vážené vzdialenosti do piatich bostonských zamestnaneckých centier
daň sadzba dane z nehnuteľností v plnej hodnote na 10 000 dolárov
ptratio pomer žiakov a učiteľov podľa mesta
medv Stredná hodnota domov obývaných vlastníkmi v tisícoch dolárov

Vytvoríte tri rôzne súbory údajov:

množina údajov cieľ tvar
Školenie Trénujte model a získajte váhy 400, 10
Vyhodnotenie Vyhodnoťte výkonnosť modelu na základe nevidených údajov 100, 10
Predvídať Použite model na predpovedanie domácej hodnoty na nových dátach 6, 10

Cieľom je využiť vlastnosti súboru údajov na predpovedanie hodnoty domu.

Počas druhej časti tutoriálu sa naučíte, ako používať TensorFlow tromi rôznymi spôsobmi importu údajov:

  • S pandami
  • S Numpy
  • Iba TF

Upozorňujeme, že všetky možnosti poskytujú rovnaké výsledky.

Naučíte sa, ako používať API na vysokej úrovni na zostavenie, školenie a hodnotenie lineárneho regresného modelu TensorFlow. Ak ste používali nízkoúrovňové API, museli ste ručne definovať:

  • Stratová funkcia
  • Optimalizovať: Zostupný zostup
  • Násobenie matíc
  • Graf a tenzor

To je pre začiatočníkov zdĺhavé a komplikovanejšie.

Pandy

Ak chcete trénovať model, musíte importovať potrebné knižnice.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Krok 1) Importujte údaje pomocou programu panda.

Definujete názvy stĺpcov a uložíte ich do COLUMNS. Na import údajov môžete použiť pd.read_csv ().

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

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

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

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

Môžete vytlačiť tvar údajov.

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

Výkon

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

Upozorňujeme, že štítok, tj. Váš y, je zahrnutý v množine údajov. Musíte si teda definovať ďalšie dva zoznamy. Jeden obsahujúci iba funkcie a druhý iba s názvom štítku. Tieto dva zoznamy povedia vášmu odhadcovi, aké sú funkcie v množine údajov a aký názov stĺpca je menovka

Vykonáva sa to pomocou nižšie uvedeného kódu.

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

Krok 2) Konvertujte údaje

Musíte previesť numerické premenné v správnom formáte. Tensorflow poskytuje metódu na prevod spojitej premennej: tf.feature_column.numeric_column ().

V predchádzajúcom kroku definujete zoznam prvku, ktorý chcete zahrnúť do modelu. Tento zoznam teraz môžete použiť na ich prevod na číselné údaje. Ak chcete vo svojom modeli vylúčiť prvky, môžete pred zostavením feature_cols pustiť jednu alebo viac premenných do zoznamu VLASTNOSTI.

Upozorňujeme, že na vytvorenie nového zoznamu s názvom feature_cols použijete so zoznamom VLASTNOSTI zoznam Python. Pomáha vám vyhnúť sa deviatim zápisom tf.feature_column.numeric_column (). Zoznamové porozumenie je rýchlejší a čistejší spôsob vytvárania nových zoznamov

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

Krok 3) Definujte odhad

V tomto kroku musíte definovať odhadovač. Tensorflow v súčasnosti poskytuje 6 vopred pripravených odhadov, z toho 3 pre úlohu klasifikácie a 3 pre regresnú úlohu TensorFlow:

  • Regresor
    • DNN Regresor
    • Lineárny regresor
    • DNNLineaCombinedRegressor
  • Klasifikátor
    • DNNClassifier
    • Lineárny klasifikátor
    • DNNLineaCombinedClassifier

V tomto tutoriále budete používať lineárny regresor. Pre prístup k tejto funkcii musíte použiť tf.estimator.

Funkcia vyžaduje dva argumenty:

  • feature_columns: Obsahuje premenné, ktoré sa majú zahrnúť do modelu
  • model_dir: cesta na uloženie grafu, uloženie parametrov modelu atď

Tensorflow vo vašom pracovnom adresári automaticky vytvorí súbor s názvom vlak. Túto cestu musíte použiť na prístup k Tensorboard, ako je to znázornené v nasledujúcom príklade regresie TensorFlow.

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

Výkon

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}

Zložitou časťou s TensorFlow je spôsob napájania modelu. Tensorflow je navrhnutý na prácu s paralelnými výpočtami a veľmi veľkým súborom údajov. Z dôvodu obmedzenia zdrojov stroja je nemožné vložiť model všetkými údajmi naraz. Z tohto dôvodu musíte zakaždým vložiť dávku údajov. Upozorňujeme, že hovoríme o obrovskom súbore údajov s miliónmi alebo viac záznamami. Ak nepridáte dávku, skončí sa chybou pamäte.

Ak napríklad vaše údaje obsahujú 100 pozorovaní a vy definujete veľkosť dávky 10, znamená to, že model uvidí 10 pozorovaní pre každú iteráciu (10 * 10).

Keď model vidí všetky údaje, dokončí jednu epochu . Epocha definuje, koľkokrát chcete, aby model videl údaje. Je lepšie tento krok nastaviť na žiadny a nechať model vykonať iteráciu viackrát.

Druhá informácia, ktorú je potrebné pridať, je, ak chcete zamiešať údaje pred každou iteráciou. Počas školenia je dôležité zamiešať údaje tak, aby sa model nenaučil konkrétny vzor množiny údajov. Ak sa model dozvie podrobnosti základného modelu údajov, bude mať ťažkosti s generalizáciou predikcie pre neviditeľné údaje. Tomu sa hovorí overfitting . Model podáva údaje o tréningu dobre, ale nedokáže správne predvídať neviditeľné údaje.

Vďaka TensorFlow sú tieto dva kroky ľahké. Keď údaje idú do potrubia, vie, koľko pozorovaní potrebuje (dávku) a či musí údaje zamiešať.

Ak chcete inštruovať Tensorflow, ako kŕmiť model, môžete použiť pandas_input_fn. Tento objekt vyžaduje 5 parametrov:

  • x: údaje o vlastnostiach
  • y: údaje na štítku
  • batch_size: dávka. Predvolene 128
  • num_epoch: Počet epoch, predvolene 1
  • zamiešať: Zamiešať alebo nevymiešať dáta. Predvolene žiadne

Model musíte viackrát nakŕmiť, aby ste definovali funkciu na zopakovanie tohto procesu. celá táto funkcia 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)

Obvyklou metódou na vyhodnotenie výkonu modelu je:

  • Trénujte model
  • Vyhodnoťte model v inej množine údajov
  • Urobte predpoveď

Odhadovač Tensorflow poskytuje tri rôzne funkcie na ľahké vykonávanie týchto troch krokov.

Krok 4) : Trénujte model

Na vyhodnotenie modelu môžete použiť odhadovací vlak. Odhadca vlaku potrebuje vstup_fn a niekoľko krokov. Na kŕmenie modelu môžete použiť funkciu, ktorú ste vytvorili vyššie. Potom dáte modelu pokyn, aby iteroval 1000-krát. Upozorňujeme, že nezadáte počet epoch, model necháte iterovať 1000-krát. Ak nastavíte počet epoch na 1, model bude iterovať štyrikrát: V tréningovej sade je 400 záznamov a veľkosť dávky je 128.

  1. 128 riadkov
  2. 128 riadkov
  3. 128 riadkov
  4. 16 riadkov

Preto je jednoduchšie nastaviť počet epoch na žiadny a definovať počet iterácií, ako je uvedené v th pod príkladom klasifikácie TensorFlow.

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

Výkon

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.

Môžete skontrolovať, či Tensorboard bude mať nasledujúci príkaz:

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

Krok 5) Vyhodnoťte svoj model

Vyhodenie vášho modelu na testovacej súprave môžete vyhodnotiť pomocou kódu uvedeného nižšie:

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

Výkon

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

Stratu môžete vytlačiť pomocou nižšie uvedeného kódu:

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

Výkon

Loss: 3215.895996

Strata modelu je 3 515. Môžete skontrolovať súhrnnú štatistiku a získať predstavu o tom, aká veľká je chyba.

training_set['medv'].describe()

Výkon

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

Z vyššie uvedenej súhrnnej štatistiky viete, že priemerná cena domu je 22 tisíc, minimálna cena 9 tisíc a najviac 50 tisíc. Model robí typickú chybu 3 000 dolárov.

Krok 6) Vytvorte predpoveď

Na záver môžete použiť odhadovač TensorFlow predpovedať na odhad hodnoty 6 bostonských domov.

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

Ak chcete vytlačiť odhadované hodnoty produktu, môžete použiť tento kód:

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

Výkon

INFO:tensorflow:Calling model_fn.INFO:tensorflow:Done calling model_fn.INFO:tensorflow:Graph was finalized.INFO:tensorflow:Restoring parameters from train/model.ckpt-1000INFO:tensorflow:Running local_init_op.INFO:tensorflow:Done running local_init_op.Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]

Model predpovedá nasledujúce hodnoty:

House

Predikcia

1

32,29

2

18,96

3

27,27

4

29,29

5

16,43

7

21,46

Upozorňujeme, že nepoznáme skutočnú hodnotu. V tutoriáli hlbokého učenia sa pokúsite poraziť lineárny model

Numpy riešenie

Táto časť vysvetľuje, ako trénovať model pomocou numpy odhadcu na načítanie údajov. Metóda je rovnaká okrem toho, ktorú použijete numpy_input_fn estimator.

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

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

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

Krok 1) Importujte údaje

Najskôr je potrebné odlíšiť premenné funkcií od štítku. Musíte to urobiť pre údaje o tréningu a vyhodnotenie. Je rýchlejšie definovať funkciu rozdelenia údajov.

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

Pomocou tejto funkcie môžete štítok oddeliť od funkcií súboru údajov o vlaku / vyhodnotiť

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

Musíte vylúčiť posledný stĺpec množiny predikčných údajov, pretože obsahuje iba NaN

x_predict = prediction_set_n[:, :-2]

Potvrďte tvar poľa. Upozorňujeme, že štítok by nemal mať rozmer, to znamená (400,).

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

Výkon

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

Stĺpce prvkov môžete vytvoriť nasledovne:

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

Odhad je definovaný ako predtým, dávate pokyny stĺpcom funkcií a kam graf uložiť.

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

Výkon

INFO:tensorflow:Using default config.INFO:tensorflow:Using config: {'_model_dir': 'train1', '_tf_random_seed': None, '_save_summary_steps': 100, '_save_checkpoints_steps': None, '_save_checkpoints_secs': 600, '_session_config': None, '_keep_checkpoint_max': 5, '_keep_checkpoint_every_n_hours': 10000, '_log_step_count_steps': 100, '_train_distribute': None, '_service': None, '_cluster_spec': , '_task_type': 'worker', '_task_id': 0, '_global_id_in_cluster': 0, '_master': '', '_evaluation_master': '', '_is_chief': True, '_num_ps_replicas': 0, '_num_worker_replicas': 1}

Numpy estimapor môžete použiť na dodanie údajov do modelu a potom model trénovať. Upozorňujeme, že predtým sme definovali funkciu input_fn, aby sme uľahčili čitateľnosť.

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

Výkon

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

Rovnaký krok replikujete s iným odhadcom, aby ste vyhodnotili 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)

Výkon

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}

Nakoniec môžete vypočítať predpoveď. Malo by to byť podobné ako s pandami.

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

Výkon

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

Riešenie Tensorflow

Posledná časť je venovaná riešeniu TensorFlow. Táto metóda je o niečo komplikovanejšia ako tá druhá.

Upozorňujeme, že ak používate notebook Jupyter, musíte na spustenie tejto relácie reštartovať a vyčistiť jadro.

TensorFlow vytvoril vynikajúci nástroj na prenos údajov do potrubia. V tejto časti si sami zostavíte funkciu input_fn.

Krok 1) Definujte cestu a formát údajov

Najskôr deklarujete dve premenné s cestou k súboru csv. Pamätajte, že máte dva súbory, jeden pre tréningovú sadu a jeden pre testovaciu sadu.

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

Potom musíte definovať stĺpce, ktoré chcete použiť zo súboru CSV. Využijeme všetky. Potom musíte deklarovať typ premennej, o ktorú sa jedná.

Premenná typu floats je definovaná ako [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]]

Krok 2) Definujte funkciu input_fn

Funkciu je možné rozdeliť na tri časti:

  1. Importujte údaje
  2. Vytvorte iterátor
  3. Spotrebujte dáta

Ďalej je uvedený celkový kód na definovanie funkcie. Kód bude vysvetlený neskôr

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

** Import údajov **

V prípade súboru CSV číta metóda množiny údajov jeden riadok po druhom. Ak chcete zostaviť množinu údajov, musíte použiť objekt TextLineDataset. Vaša množina údajov má hlavičku, takže na preskočenie prvého riadku musíte použiť skip (1). V tomto okamihu iba načítate údaje a vylúčite hlavičku v potrubí. Ak chcete vložiť model, musíte oddeliť funkcie od štítka. Metóda použitá na uplatnenie akejkoľvek transformácie na údaje je mapa.

Táto metóda volá funkciu, ktorú vytvoríte, aby ste poučili, ako transformovať údaje. Stručne povedané, musíte odovzdať údaje v objekte TextLineDataset, vylúčiť hlavičku a použiť transformáciu, ktorá je zadaná funkciou. Vysvetlenie kódu

  • tf.data.TextLineDataset (data_file): Tento riadok načítal súbor CSV
  • .skip (1): preskočiť hlavičku
  • .map (parse_csv)): analýza záznamov na tenzory Musíte definovať funkciu, ktorá bude inštruovať objekt mapy. Túto funkciu môžete nazvať parse_csv.

Táto funkcia analyzuje súbor csv metódou tf.decode_csv a deklaruje funkcie a štítok. Funkcie je možné deklarovať ako slovník alebo n-ticu. Používate metódu slovníka, pretože je to pohodlnejšie. Vysvetlenie kódu

  • tf.decode_csv (hodnota, record_defaults = RECORDS_ALL): metóda decode_csv používa výstup súboru TextLineDataset na načítanie súboru csv. record_defaults informuje TensorFlow o type stĺpcov.
  • dict (zip (_CSV_COLUMNS, stĺpce)): Naplňte slovník všetkými stĺpcami extrahovanými počas tohto spracovania údajov
  • features.pop ('median_house_value'): Vylúčte cieľovú premennú z premennej feature a vytvorte premennú label

Sada údajov potrebuje ďalšie prvky, aby iteračne napájala tenzory. Musíte skutočne pridať opakovanie metódy, aby ste umožnili množine údajov pokračovať v podávaní modelu pomocou modelu dat. Ak metódu nepridáte, model bude iterovať iba raz a potom spôsobí chybu, pretože sa do kanálu neprenášajú ďalšie údaje.

Potom môžete veľkosť dávky ovládať dávkovou metódou. Znamená to, že množine údajov poviete, koľko údajov chcete v potrubí odovzdať pre každú iteráciu. Ak nastavíte veľkú veľkosť dávky, model bude pomalý.

Krok 3) Vytvorte iterátor

Teraz ste pripravení na druhý krok: vytvorte iterátor, ktorý vráti prvky v množine údajov.

Najjednoduchší spôsob vytvorenia operátora je pomocou metódy make_one_shot_iterator.

Potom môžete z iterátora vytvárať prvky a štítky.

Krok 4) Spotrebujte údaje

Môžete skontrolovať, čo sa stane s funkciou input_fn. Aby ste dáta spotrebovali, musíte zavolať funkciu v relácii. Skúšate s veľkosťou dávky rovnou 1.

Upozorňujeme, že vytlačí funkcie v slovníku a štítok ako pole.

Zobrazí sa prvý riadok súboru CSV. Tento kód sa môžete pokúsiť spustiť mnohokrát s rôznou veľkosťou dávky.

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)

Výkon

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

Krok 4) Definujte stĺpec funkcií

Číselné stĺpce musíte definovať takto:

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

Upozorňujeme, že musíte kombinovať všetky premenné do vedra

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

Krok 5) Zostavte model

Model môžete trénovať pomocou odhadcu LinearRegressor.

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

Výkon

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}

Musíte použiť funkciu lambda, aby ste umožnili zápis argumentu do funkcie inpu_fn. Ak nepoužívate funkciu lambda, nemôžete trénovať model.

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

Výkon

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

Vyhodenie vášho modelu na testovacej súprave môžete vyhodnotiť pomocou kódu uvedeného nižšie:

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

Výkon

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

Posledným krokom je predikcia hodnoty matíc funkcií na základe hodnoty matíc. Môžete napísať slovník s hodnotami, ktoré chcete predvídať. Váš model má 9 funkcií, takže pre každú musíte uviesť hodnotu. Model poskytne predikciu pre každú z nich.

V nižšie uvedenom kóde ste napísali hodnoty jednotlivých funkcií, ktoré sú obsiahnuté v súbore df_predict csv.

Musíte napísať novú funkciu input_fn, pretože v množine údajov nie je žiadny štítok. Môžete použiť API from_tensor z datasetu.

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)

Nakoniec vytlačíte predpovede.

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

Výkon

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

Zhrnutie

Ak chcete trénovať model, musíte:

  • Definujte vlastnosti: Nezávislé premenné: X
  • Definujte štítok: Závislá premenná: r
  • Postavte vlak / testovaciu súpravu
  • Definujte počiatočnú hmotnosť
  • Definujte stratovú funkciu: MSE
  • Optimalizujte model: Zostupný klesanie
  • Definovať:
    • Miera učenia
    • Počet epoch
    • Veľkosť šarže

V tomto tutoriáli ste sa naučili, ako používať rozhranie API na vysokej úrovni pre odhad lineárnej regresie TensorFlow. Musíte definovať:

  1. Stĺpce funkcií. Ak je priebežné: tf.feature_column.numeric_column (). Zoznam môžete vyplniť porozumením zoznamu pythónov
  2. Odhad: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Funkcia na import údajov, veľkosti dávky a epochy: input_fn ()

Potom ste pripravení trénovať, hodnotiť a predpovedať pomocou programu train (), evalu () a predpovedať ()