Lineární regrese s TensorFlow (příklady)

Obsah:

Anonim

Co je lineární regrese?

Lineární regrese je přístup ve statistice pro modelování vztahů mezi dvěma proměnnými. Toto modelování se provádí mezi skalární odpovědí a jednou nebo více vysvětlujícími proměnnými. Vztah s jednou vysvětlující proměnnou se nazývá jednoduchá lineární regrese a pro více než jednu vysvětlující proměnnou se nazývá vícenásobná lineární regrese.

TensorFlow poskytuje nástroje, které mají plnou kontrolu nad výpočty. To se provádí pomocí nízkoúrovňového API. Kromě toho je TensorFlow vybaven širokou škálou API pro provádění mnoha algoritmů strojového učení. Toto je API na vysoké úrovni. TensorFlow jim říká odhady

  • Nízkoúrovňové API: Vytvoření architektury, optimalizace modelu od nuly. Pro začátečníka je to komplikované
  • High-level API: Define the algorithm. Je to přátelské pro snadnější přístup. TensorFlow poskytuje odhad nástrojů volání panelu nástrojů pro konstrukci, školení, hodnocení a predikci.

V tomto tutoriálu budete používat pouze odhady . Výpočty jsou rychlejší a lze je snáze implementovat. První část tutoriálu vysvětluje, jak používat optimalizátor sestupu gradientu k trénování lineární regrese v TensorFlow. Ve druhé části použijete bostonskou datovou sadu k předpovědi ceny domu pomocí odhadu TensorFlow.

Stáhněte si Boston DataSet

V tomto výukovém programu TensorFlow Regression se naučíte:

  • Co je lineární regrese?
  • Jak trénovat model lineární regrese
  • Jak trénovat lineární regrese pomocí TensorFlow
  • Pandy
  • Numpy řešení
  • Řešení Tensorflow

Jak trénovat model lineární regrese

Než začneme trénovat model, pojďme se podívat na to, co je lineární regrese.

Představte si, že máte dvě proměnné, xay a vaším úkolem je předpovědět hodnotu znalosti hodnoty. Pokud vykreslíte data, můžete vidět pozitivní vztah mezi vaší nezávislou proměnnou x a vaší závislou proměnnou y.

Můžete pozorovat, že pokud x = 1, y bude zhruba rovno 6 a pokud x = 2, y bude kolem 8,5.

Toto není příliš přesná metoda a náchylná k chybám, zejména u datové sady se stovkami tisíc bodů.

Lineární regrese se hodnotí pomocí rovnice. Proměnná y je vysvětlena jednou nebo více proměnnými. Ve vašem příkladu existuje pouze jedna závislá proměnná. Pokud musíte napsat tuto rovnici, bude to:

S:

  • je váha spojená s x
  • je reziduum nebo chyba modelu. Zahrnuje to, co se model nemůže z dat naučit

Představte si, že zapadáte do modelu a najdete následující řešení pro:

  • = 3,8
  • = 2,78

Tato čísla můžete v rovnici nahradit a stane se:

y = 3,8 + 2,78x

Nyní máte lepší způsob, jak najít hodnoty pro y. To znamená, že můžete nahradit x jakoukoli hodnotou, kterou chcete předpovědět y. Na obrázku níže nahradíme x v rovnici všemi hodnotami v datové sadě a vykreslíme výsledek.

Červená čára představuje přizpůsobenou hodnotu, tj. Hodnoty y pro každou hodnotu x. Abyste předpovídali y, nemusíte vidět hodnotu x, pro každé x existuje nějaké, které patří do červené čáry. Můžete také předpovídat pro hodnoty x vyšší než 2!

Pokud chcete rozšířit lineární regresi na více proměnných, můžete to udělat tak, že do modelu přidáte více proměnných. Rozdíl mezi tradiční analýzou a lineární regresí spočívá v tom, že lineární regrese zkoumá, jak bude y reagovat na každou proměnnou x samostatně.

Podívejme se na příklad. Představte si, že chcete předpovědět prodejny zmrzliny. Datová sada obsahuje různé informace, jako je počasí (tj. Deštivé, slunečné, zatažené), informace o zákaznících (tj. Plat, pohlaví, rodinný stav).

Tradiční analýza se pokusí předpovědět prodej řekněme výpočtem průměru pro každou proměnnou a pokusí se odhadnout prodej pro různé scénáře. To povede ke špatným předpovědím a omezí analýzu na vybraný scénář.

Pokud použijete lineární regrese, můžete napsat tuto rovnici:

Algoritmus najde nejlepší řešení pro váhy; to znamená, že se pokusí minimalizovat náklady (rozdíl mezi namontovanou linkou a datovými body).

Jak algoritmus funguje

Algoritmus vybere náhodné číslo pro každé a nahradit hodnotu x dostat předpovězené hodnoty y. Pokud má datová sada 100 pozorování, algoritmus vypočítá 100 předpovězených hodnot.

Můžeme vypočítat chybu uvedenou v modelu, což je rozdíl mezi predikovanou hodnotou a skutečnou hodnotou. Pozitivní chyba znamená, že model podhodnocuje predikci y a záporná chyba znamená, že model nadhodnocuje predikci y.

Vaším cílem je minimalizovat druhou mocninu chyby. Algoritmus vypočítá průměr čtvercové chyby. Tento krok se nazývá minimalizace chyby. Pro lineární regrese je střední kvadratická chyba , nazývaná také MSE. Matematicky to je:

Kde:

  • odkazuje na předpokládanou hodnotu
  • y jsou skutečné hodnoty
  • m je počet pozorování

To je matematický zápis průměru.

Cílem je najít to nejlepší, co minimalizuje MSE

Pokud je průměrná chyba velká, znamená to, že model funguje špatně a váhy nejsou zvoleny správně. K opravě vah musíte použít optimalizátor. Tradiční optimalizátor se nazývá Gradient Descent .

Sestup gradientu vezme derivaci a sníží nebo zvýší váhu. Pokud je derivát kladný, váha se sníží. Pokud je derivát záporný, váha se zvyšuje. Model aktualizuje váhy a přepočítá chybu. Tento proces se opakuje, dokud se chyba již nezmění. Každý proces se nazývá iterace . Kromě toho jsou přechody vynásobeny rychlostí učení. Udává rychlost učení.

Pokud je rychlost učení příliš malá, bude konvergování algoritmu trvat velmi dlouho (tj. Vyžaduje spoustu iterací). Pokud je rychlost učení příliš vysoká, algoritmus se nemusí nikdy sblížit.

Jak vidíte na obrázku výše, model proces opakuje asi 20krát, aby našel stabilní hodnotu pro váhy, čímž dosáhl nejnižší chyby.

Všimněte si , že chyba se nerovná nule, ale stabilizuje se kolem 5. To znamená, že model dělá typickou chybu 5. Chcete-li chybu snížit, musíte do modelu přidat další informace, například více proměnných nebo použít různé odhady.

Pamatujete si první rovnici

Konečné hmotnosti jsou 3,8 a 2,78. Video níže ukazuje, jak sestup gradientu optimalizuje funkci ztráty k nalezení těchto vah

Jak trénovat lineární regrese pomocí TensorFlow

Nyní, když lépe rozumíte tomu, co se děje za kapotou, jste připraveni použít odhadovací API poskytované TensorFlow k trénování vaší první lineární regrese pomocí TensorFlow.

Budete používat datovou sadu Boston, která obsahuje následující proměnné

krim kriminalita na obyvatele podle měst
zn podíl obytných pozemků zónovaných na pozemcích nad 25 000 čtverečních stop
průmysl podíl neprodejných obchodních akrů na město.
nox koncentrace oxidů dusnatých
rm průměrný počet pokojů na byt
stáří podíl vlastnických jednotek postavených před rokem 1940
dis vážené vzdálenosti do pěti bostonských center zaměstnanosti
daň plnohodnotná sazba daně z nemovitosti na 10 000 dolarů
ptratio poměr žáků a učitelů podle města
medv Střední hodnota domů obývaných vlastníky v tisících dolarů

Vytvoříte tři různé datové sady:

datová sada objektivní tvar
Výcvik Trénujte model a získejte váhy 400, 10
Hodnocení Vyhodnoťte výkon modelu na neviditelných datech 100, 10
Předpovědět Použijte model k předpovědi hodnoty domu na nových datech 6, 10

Cílem je využít vlastnosti datové sady k předpovědi hodnoty domu.

Během druhé části tutoriálu se naučíte, jak používat TensorFlow třemi různými způsoby importu dat:

  • S pandami
  • S Numpy
  • Pouze TF

Všimněte si, že všechny možnosti poskytují stejné výsledky.

Naučíte se, jak používat rozhraní API na vysoké úrovni k sestavení, trénování a vyhodnocení lineárního regresního modelu TensorFlow. Pokud jste používali nízkoúrovňové API, museli jste ručně definovat:

  • Funkce ztráty
  • Optimalizace: sestupný sklon
  • Násobení matic
  • Graf a tenzor

To je pro začátečníka zdlouhavé a komplikovanější.

Pandy

Abyste mohli trénovat model, musíte importovat potřebné knihovny.

import pandas as pdfrom sklearn import datasetsimport tensorflow as tfimport itertools

Krok 1) Importujte data pomocí pandy.

Definujete názvy sloupců a uložíte je do COLUMNS. K importu dat můžete použít 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 vytisknout tvar dat.

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

Výstup

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

Všimněte si, že štítek, tj. Vaše y, je zahrnut v datové sadě. Musíte tedy definovat další dva seznamy. Jeden obsahující pouze funkce a druhý pouze s názvem štítku. Tyto dva seznamy řeknou vašemu odhadci, jaké jsou funkce v datové sadě a jaký název sloupce je štítek

To se provádí pomocí níže uvedeného kódu.

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

Krok 2) Převeďte data

Musíte převést číselné proměnné ve správném formátu. Tensorflow poskytuje metodu pro převod spojité proměnné: tf.feature_column.numeric_column ().

V předchozím kroku definujete seznam prvku, který chcete zahrnout do modelu. Nyní můžete pomocí tohoto seznamu převést na číselná data. Pokud chcete ve svém modelu vyloučit prvky, můžete před vytvořením feature_cols v seznamu FUNKCE zrušit jednu nebo více proměnných.

Všimněte si, že k vytvoření nového seznamu s názvem feature_cols použijete porozumění seznamu Pythonu se seznamem FUNKCE. Pomůže vám vyhnout se devítinásobnému psaní tf.feature_column.numeric_column (). Seznam s porozuměním je rychlejší a čistší způsob vytváření nových seznamů

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

Krok 3) Definujte odhad

V tomto kroku musíte definovat odhad. Tensorflow v současné době poskytuje 6 předpřipravených odhadů, z toho 3 pro úkol klasifikace a 3 pro regresní úkol TensorFlow:

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

V tomto kurzu použijete lineární regresor. Pro přístup k této funkci musíte použít tf.estimator.

Funkce potřebuje dva argumenty:

  • feature_columns: Obsahuje proměnné, které mají být zahrnuty do modelu
  • model_dir: cesta k uložení grafu, uložení parametrů modelu atd

Tensorflow ve vašem pracovním adresáři automaticky vytvoří soubor s názvem train. Tuto cestu musíte použít pro přístup k Tensorboard, jak je znázorněno v níže uvedeném příkladu regrese TensorFlow.

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

Výstup

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}

Složitá část s TensorFlow je způsob krmení modelu. Tensorflow je navržen pro práci s paralelním výpočtem a velmi velkou datovou sadou. Kvůli omezení zdrojů stroje není možné krmit model se všemi daty najednou. K tomu musíte pokaždé krmit dávku dat. Všimněte si, že mluvíme o obrovském datovém souboru s miliony nebo více záznamy. Pokud nepřidáte dávku, skončíte s chybou paměti.

Například pokud vaše data obsahují 100 pozorování a definujete velikost dávky 10, znamená to, že model uvidí 10 pozorování pro každou iteraci (10 * 10).

Když model viděl všechna data, dokončí jednu epochu . Epocha definuje, kolikrát chcete, aby model viděl data. Je lepší nastavit tento krok na žádný a nechat model provést iterační počet časů.

Druhou informací, kterou je třeba přidat, je, pokud chcete zamíchat data před každou iterací. Během školení je důležité zamíchat data tak, aby se model nenaučil konkrétní vzor datové sady. Pokud se model naučí podrobnosti základního vzoru dat, bude mít potíže s generalizací predikce pro neviditelná data. Tomu se říká overfitting . Model funguje dobře na tréninkových datech, ale nedokáže správně předvídat neviditelná data.

Díky TensorFlow jsou tyto dva kroky snadné. Když data přejdou do kanálu, ví, kolik pozorování potřebuje (dávkově) a jestli má zamíchat data.

Chcete-li instruovat Tensorflow, jak krmit model, můžete použít pandas_input_fn. Tento objekt potřebuje 5 parametrů:

  • x: data funkcí
  • y: data štítku
  • batch_size: batch. Ve výchozím nastavení 128
  • num_epoch: Počet epoch, standardně 1
  • shuffle: Shuffle nebo ne data. Ve výchozím nastavení žádný

Model musíte krmit mnohokrát, abyste definovali funkci pro opakování tohoto procesu. celá tato funkce 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 metodou pro vyhodnocení výkonu modelu je:

  • Trénujte model
  • Vyhodnoťte model v jiné datové sadě
  • Udělejte předpověď

Odhadovač Tensorflow poskytuje tři různé funkce pro snadné provedení těchto tří kroků.

Krok 4) : Trénujte model

K vyhodnocení modelu můžete použít odhadovací vláček. Odhad vlaku potřebuje input_fn a řadu kroků. K vytvoření modelu můžete použít funkci, kterou jste vytvořili výše. Poté dáte modelu pokyn k iteraci 1000krát. Všimněte si, že neurčíte počet epoch, necháte model 1000 iterovat. Pokud nastavíte počet epoch na 1, model bude iterovat 4krát: V tréninkové sadě je 400 záznamů a velikost dávky je 128

  1. 128 řádků
  2. 128 řádků
  3. 128 řádků
  4. 16 řádků

Proto je snazší nastavit počet epoch na žádný a definovat počet iterací, jak je uvedeno v th níže příkladu klasifikace TensorFlow.

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

Výstup

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 zkontrolovat, že Tensorboard bude mít následující příkaz:

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

Krok 5) Vyhodnoťte svůj model

Vyhodnocení vašeho modelu na testovací sadě můžete vyhodnotit pomocí níže uvedeného kódu:

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

Výstup

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

Ztrátu můžete vytisknout pomocí níže uvedeného kódu:

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

Výstup

Loss: 3215.895996

Model má ztrátu 3215. Můžete zkontrolovat souhrnnou statistiku a získat představu o tom, jak velká je chyba.

training_set['medv'].describe()

Výstup

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

Z výše uvedené souhrnné statistiky víte, že průměrná cena domu je 22 tisíc, s minimální cenou 9 tisíc a maximálně 50 tisíc. Model dělá typickou chybu 3k dolarů.

Krok 6) Proveďte předpověď

Nakonec můžete použít odhadovač TensorFlow předpovědět k odhadu hodnoty 6 bostonských domů.

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

Chcete-li vytisknout odhadované hodnoty, můžete použít tento kód:

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

Výstup

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 předpovídá následující hodnoty:

Dům

Předpověď

1

32,29

2

18,96

3

27.27

4

29,29

5

16,43

7

21,46

Všimněte si, že neznáme skutečnou hodnotu. V kurzu hlubokého učení se pokusíte porazit lineární model

Numpy řešení

Tato část vysvětluje, jak trénovat model pomocí numpy odhadce pro vkládání dat. Metoda je stejná, kromě toho, že 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 data

Nejprve musíte odlišit proměnné funkcí od štítku. Musíte to udělat pro tréninková data a vyhodnocení. Je rychlejší definovat funkci pro rozdělení dat.

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

Tuto funkci můžete použít k rozdělení štítku od funkcí vlaku / vyhodnocení datové sady

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

Musíte vyloučit poslední sloupec datové sady predikce, protože obsahuje pouze NaN

x_predict = prediction_set_n[:, :-2]

Potvrďte tvar pole. Všimněte si, že štítek by neměl mít rozměr, to znamená (400,).

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

Výstup

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

Sloupce prvků můžete vytvořit následujícím způsobem:

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

Odhad je definován jako dříve, dáváte pokyny sloupcům funkcí a kam graf uložit.

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

Výstup

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žít k přenosu dat do modelu a poté trénovat model. Všimněte si, že předtím jsme definovali funkci input_fn, abychom usnadnili čitelnost.

# 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ýstup

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

Stejný krok replikujete pomocí jiného odhadu, abyste mohli svůj model vyhodnotit

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ýstup

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}

Nakonec můžete předpověď vypočítat. Mělo by to být podobné jako 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ýstup

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

Řešení Tensorflow

Poslední část je věnována řešení TensorFlow. Tato metoda je o něco složitější než ta druhá.

Všimněte si, že pokud používáte notebook Jupyter, musíte pro spuštění této relace restartovat a vyčistit jádro.

TensorFlow vytvořil skvělý nástroj pro předávání dat do kanálu. V této části vytvoříte funkci input_fn sami.

Krok 1) Definujte cestu a formát dat

Nejprve deklarujete dvě proměnné s cestou k souboru CSV. Všimněte si, že máte dva soubory, jeden pro tréninkovou sadu a jeden pro testovací sadu.

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

Poté musíte v souboru CSV definovat sloupce, které chcete použít. Využijeme vše. Poté musíte deklarovat typ proměnné, o kterou se jedná.

Plovoucí proměnná je definována jako [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 funkci input_fn

Funkci lze rozdělit na tři části:

  1. Importujte data
  2. Vytvořte iterátor
  3. Spotřebujte data

Níže je uveden celkový kód k definování funkce. Kód bude vysvětlen poté

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

** Importujte data **

U souboru CSV čte metoda datové sady jeden řádek najednou. Chcete-li sestavit datovou sadu, musíte použít objekt TextLineDataset. Vaše datová sada má záhlaví, takže k přeskočení prvního řádku musíte použít skip (1). V tomto okamžiku pouze načtete data a vyloučíte záhlaví v kanálu. Chcete-li model nakrmit, musíte oddělit funkce od štítku. Metoda použitá k použití jakékoli transformace na data je mapa.

Tato metoda volá funkci, kterou vytvoříte, abyste instruovali, jak transformovat data. Stručně řečeno, musíte předat data v objektu TextLineDataset, vyloučit záhlaví a použít transformaci, která je instruována funkcí.

  • tf.data.TextLineDataset (data_file): Tento řádek čte soubor CSV
  • .skip (1): přeskočit záhlaví
  • .map (parse_csv)): analyzovat záznamy do tenzorů Musíte definovat funkci pro instruování objektu mapy. Tuto funkci můžete zavolat parse_csv.

Tato funkce analyzuje soubor csv metodou tf.decode_csv a deklaruje funkce a štítek. Funkce lze deklarovat jako slovník nebo n-tici. Používáte metodu slovníku, protože je to pohodlnější. Vysvětlení kódu

  • tf.decode_csv (value, record_defaults = RECORDS_ALL): metoda decode_csv používá výstup TextLineDataset ke čtení souboru csv. record_defaults instruuje TensorFlow o typu sloupců.
  • dict (zip (_CSV_COLUMNS, sloupce)): Naplňte slovník všemi sloupci extrahovanými během tohoto zpracování dat
  • features.pop ('median_house_value'): Vyloučit cílovou proměnnou z proměnné funkce a vytvořit proměnnou štítku

Datová sada potřebuje další prvky k iterativnímu napájení tenzorů. Ve skutečnosti musíte přidat metodu opakování, abyste umožnili datové sadě pokračovat neomezeně dlouho, aby se model podal. Pokud metodu nepřidáte, model bude iterovat pouze jednou a poté vyvolá chybu, protože v kanálu nejsou přiváděna žádná další data.

Poté můžete pomocí dávky nastavit velikost dávky. To znamená, že řeknete datové sadě, kolik dat chcete předat v potrubí pro každou iteraci. Pokud nastavíte velkou velikost dávky, model bude pomalý.

Krok 3) Vytvořte iterátor

Nyní jste připraveni na druhý krok: vytvořte iterátor, který vrátí prvky v datové sadě.

Nejjednodušší způsob vytvoření operátoru je pomocí metody make_one_shot_iterator.

Poté můžete z iterátoru vytvořit prvky a popisky.

Krok 4) Spotřebujte data

Můžete zkontrolovat, co se stane s funkcí input_fn. Chcete-li data spotřebovat, musíte funkci zavolat v relaci. Pokusíte se s velikostí dávky rovnou 1.

Všimněte si, že tiskne funkce ve slovníku a štítek jako pole.

Zobrazí se první řádek souboru CSV. Tento kód můžete zkusit spustit mnohokrát s jinou velikostí 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ýstup

({'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 sloupec prvků

Číselné sloupce musíte definovat následovně:

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

Všimněte si, že musíte kombinovat všechny proměnné v kbelíku

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

Krok 5) Sestavte model

Model můžete trénovat pomocí odhadu LinearRegressor.

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

Výstup

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žít funkci lambda, aby bylo možné zapsat argument ve funkci inpu_fn. Pokud nepoužíváte funkci lambda, nemůžete model trénovat.

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

Výstup

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

Vhodnost vašeho modelu na testovací sadě můžete vyhodnotit pomocí níže uvedeného kódu:

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ýstup

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 krokem je předpovídání hodnoty matic funkcí na základě jejich hodnoty. Můžete napsat slovník s hodnotami, které chcete předvídat. Váš model má 9 funkcí, takže pro každou z nich musíte uvést hodnotu. Model poskytne předpověď pro každý z nich.

V níže uvedeném kódu jste napsali hodnoty jednotlivých funkcí, které jsou obsaženy v souboru csv df_predict.

Musíte napsat novou funkci input_fn, protože v datové sadě není žádný štítek. Můžete použít API from_tensor z datové sady.

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)

Nakonec vytisknete předpovědi.

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

Výstup

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

souhrn

Chcete-li trénovat model, musíte:

  • Definujte funkce: Nezávislé proměnné: X
  • Definujte štítek: Závislá proměnná: y
  • Postavte vlak / testovací soupravu
  • Definujte počáteční hmotnost
  • Definujte funkci ztráty: MSE
  • Optimalizujte model: Sestupný sklon
  • Definovat:
    • Míra učení
    • Počet epoch
    • Objem várky

V tomto kurzu jste se naučili, jak používat rozhraní API na vysoké úrovni pro odhad lineární regrese TensorFlow. Musíte definovat:

  1. Sloupce prvků. Pokud je průběžné: tf.feature_column.numeric_column (). Seznam můžete naplnit porozuměním seznamu pythonu
  2. Odhad: tf.estimator.LinearRegressor (feature_columns, model_dir)
  3. Funkce pro import dat, velikosti dávky a epochy: input_fn ()

Poté jste připraveni trénovat, hodnotit a předpovídat pomocí train (), evalu () a predikovat ()