Kurz lineární regrese s TensorFlow [Příklady]
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í odezvou 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 pro 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 rozhraní API, která umožňují provádět mnoho strojové učení algoritmy. Toto je API na vysoké úrovni. TensorFlow je nazývá estimátory
- Nízkoúrovňové API: Sestavení architektury, optimalizace modelu od začátku. Pro začátečníka je to složité
- API na vysoké úrovni: Definujte algoritmus. Je snazší. TensorFlow poskytuje sadu nástrojů s názvem odhadce konstruovat, trénovat, vyhodnocovat a předpovídat.
V tomto tutoriálu budete používat pouze odhadci. Výpočty jsou rychlejší a snadněji implementovatelné. První část výukového programu vysvětluje, jak používat optimalizátor sestupu gradientu k trénování lineární regrese v TensorFlow. Ve druhé části použijete bostonský datový soubor k predikci ceny domu pomocí odhadu TensorFlow.
Jak trénovat lineární regresní model
Než začneme model trénovat, podívejme se, co je lineární regrese.
Představte si, že máte dvě proměnné, x a y, 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 závislou proměnnou y.
Můžete pozorovat, že pokud x=1,y se bude zhruba rovnat 6 a pokud x=2,y bude kolem 8.5.
Toto není příliš přesná metoda a náchylná k chybám, zvláště u datové sady se stovkami tisíc bodů.
Lineární regrese je vyhodnocena pomocí rovnice. Proměnná y je vysvětlena jednou nebo více kovariátami. Ve vašem příkladu existuje pouze jedna závislá proměnná. Pokud musíte napsat tuto rovnici, bude to:
S:
je zaujatost. tj. pokud x=0, y=
je váha spojená s x
je zbytková nebo chyba modelu. Zahrnuje to, co se model nemůže z dat naučit
Představte si, že pasujete na model a najdete následující řešení:
= 3.8
= 2.78
Tato čísla můžete do rovnice dosadit a vznikne:
y= 3.8 + 2.78x
Nyní máte lepší způsob, jak najít hodnoty pro y. To znamená, že x můžete nahradit jakoukoli hodnotou, kterou chcete předpovědět y. Na obrázku níže jsme nahradili x v rovnici všemi hodnotami v datové sadě a vykreslili výsledek.
Červená čára představuje přizpůsobenou hodnotu, tj. hodnoty y pro každou hodnotu x. K předpovědi y nepotřebujete vidět hodnotu x, pro každé x existuje nějaké, které patří k červené čáře. Můžete také předpovídat pro hodnoty x vyšší než 2!
Pokud chcete rozšířit lineární regresi na více kovariát, můžete do modelu přidat více proměnných. Rozdíl mezi tradiční analýzou a lineární regresí spočívá v tom, že lineární regrese se dívá na to, jak y bude reagovat pro každou proměnnou x nezávisle.
Podívejme se na příklad. Představte si, že chcete předvídat tržby v prodejně zmrzliny. Dataset obsahuje různé informace, jako je počasí (tj. déšť, slunečno, oblačno), informace o zákaznících (tj. plat, pohlaví, rodinný stav).
Tradiční analýza se pokusí předpovědět prodej tak, že řekněme vypočítá průměr pro každou proměnnou a pokusí se odhadnout prodej pro různé scénáře. Povede to ke špatným předpovědím a omezí analýzu na zvolený scénář.
Pokud používáte lineární regresi, můžete napsat tuto rovnici:
Algoritmus najde nejlepší řešení pro váhy; to znamená, že se bude snažit minimalizovat náklady (rozdíl mezi proloženou čárou a datovými body).
Jak funguje algoritmus
Algoritmus pro každý vybere náhodné číslo si
a nahraďte hodnotu x, abyste získali předpokládanou hodnotu y. Pokud má datová sada 100 pozorování, algoritmus vypočítá 100 předpokládaných hodnot.
Můžeme vypočítat chybu, poznamenal modelu, což je rozdíl mezi predikovanou hodnotou a skutečnou hodnotou. Kladná chyba znamená, že model podhodnocuje předpověď y, a záporná chyba znamená, že model nadhodnocuje předpověď y.
Vaším cílem je minimalizovat druhou mocninu chyby. Algoritmus vypočítá střední hodnotu čtvercové chyby. Tento krok se nazývá minimalizace chyby. Pro lineární regresi je Střední kvadratická chyba, nazývaný také MSE. Matematicky je to:
Kde:
jsou váhy tak
odkazuje na předpokládanou hodnotu
- y jsou skutečné hodnoty
- m je počet pozorování
Všimněte si, že znamená, že používá transpozici matic. The
je matematický zápis průměru.
Cílem je najít to nejlepší které minimalizují MSE
Pokud je průměrná chyba velká, znamená to, že model funguje špatně a váhy nejsou správně zvoleny. Chcete-li opravit hmotnosti, musíte použít optimalizátor. Tradiční optimalizátor se nazývá Gradientní sestup.
Gradientní klesání přebírá derivaci a snižuje nebo zvyšuje hmotnost. Pokud je derivace kladná, váha se sníží. Pokud je derivace 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á an opakování. Kromě toho se gradienty násobí rychlostí učení. Udává rychlost učení.
Pokud je rychlost učení příliš malá, bude algoritmu trvat velmi dlouho, než se sblíží (tj. vyžaduje mnoho iterací). Pokud je rychlost učení příliš vysoká, algoritmus nemusí nikdy konvergovat.
Z obrázku výše je vidět, že model opakuje proces asi 20x předtím, 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. Pokud chcete chybu snížit, musíte do modelu přidat více informací, jako je více proměnných nebo použít různé odhady .
Pamatujete si první rovnici
Konečné váhy jsou 3.8 a 2.78. Níže uvedené video vám ukazuje, jak gradientní klesání optimalizuje funkci ztráty, abyste našli tyto váhy
Jak trénovat lineární regresi pomocí TensorFlow
Nyní, když lépe rozumíte tomu, co se děje za kapotou, jste připraveni použít estimátor API poskytované TensorFlow k trénování vaší první lineární regrese pomocí TensorFlow.
Budete používat Boston Dataset, který obsahuje následující proměnné
zločin | kriminalita na obyvatele podle města |
---|---|
zn | podíl obytných pozemků v zónách pro pozemky o rozloze přes 25,000 XNUMX čtverečních stop. |
indus | podíl nemaloobchodní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 pracovních center v Bostonu |
daň | sazba daně z nemovitosti v plné hodnotě za 10,000 XNUMX 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 dolarech |
Vytvoříte tři různé datové sady:
dataset | cíl | formovat |
---|---|---|
Trénink | Trénujte model a získejte závaží | 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ého souboru k předpovědi hodnoty domu.
Během druhé části tutoriálu se naučíte používat TensorFlow třemi různými způsoby importu dat:
- S pandami
- S nemotorný
- Pouze TF
Všimněte si, že všechny možnosti poskytnout stejné výsledky.
Naučíte se, jak používat API na vysoké úrovni k sestavení, trénování a vyhodnocování lineárního regresního modelu TensorFlow. Pokud jste používali nízkoúrovňové API, museli jste ručně definovat:
- Ztrátová funkce
- Optimalizace: Gradientní klesání
- Násobení matic
- Graf a tenzor
To je pro začátečníka zdlouhavé a složitější.
Pandy
Pro trénování modelu musíte importovat potřebné knihovny.
import pandas as pd from sklearn import datasets import tensorflow as tf import itertools
Krok 1) Importujte data pomocí panda.
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=SLOUPCE)
test_set = pd.read_csv(“E:/boston_test.csv”, skipinitialspace=True,skiprows=1, names=SLOUPCE)
predikce_set = pd.read_csv(“E:/boston_predict.csv”, skipinitialspace=True,skiprows=1, names=SLOUPCE)
Tvar dat můžete vytisknout.
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 součástí datové sady. Musíte tedy definovat dva další seznamy. Jeden obsahující pouze funkce a jeden 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í kódu níže.
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é do správného formátu. Tensorflow poskytuje metodu pro převod spojité proměnné: tf.feature_column.numeric_column().
V předchozím kroku definujete seznam prvků, které chcete zahrnout do modelu. Nyní můžete tento seznam použít k jejich převodu na číselná data. Pokud chcete ze svého modelu vyloučit prvky, můžete před vytvořením prvku feature_cols vypustit jednu nebo více proměnných do seznamu FEATURES
Všimněte si, že budete používat Python porozumění seznamu se seznamem FEATURES pro vytvoření nového seznamu s názvem feature_cols. Pomůže vám vyhnout se devítinásobnému zápisu tf.feature_column.numeric_column(). Porozumění seznamu 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 odhadce
V tomto kroku musíte definovat odhad. Tensorflow v současné době poskytuje 6 předem sestavených odhadů, včetně 3 pro klasifikační úlohu a 3 pro regresní úlohu TensorFlow:
- Regresor
- DNRegressor
- Lineární regresor
- DNNLineaCombinedRegressor
- Klasifikátor
- DNNCklasifikátor
- LinearClassifier
- DNNLineaCombinedClassifier
V tomto tutoriálu budete používat 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 automaticky vytvoří soubor s názvem train ve vašem pracovním adresáři. Tuto cestu musíte použít pro přístup k Tensorboardu, 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': <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}
Složitá část s TensorFlow je způsob, jak nakrmit model. Tensorflow je navržen pro práci s paralelními výpočty a velmi rozsáhlou datovou sadou. Vzhledem k omezeným zdrojům stroje není možné naplnit model všemi daty najednou. K tomu musíte pokaždé vložit 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.
Pokud například 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 uvidí všechna data, dokončí jedno epocha. Epocha definuje, kolikrát chcete, aby model viděl data. Je lepší nastavit tento krok na žádný a nechat model provádět iteraci, kolikrát času.
Druhou informací, kterou je třeba přidat, je, zda chcete data před každou iterací zamíchat. Během tréninku je důležité data zamíchat, aby se model nenaučil konkrétní vzor datové sady. Pokud se model naučí podrobnosti o základním vzoru dat, bude mít potíže zobecnit předpověď pro neviditelná data. Tomu se říká přepastování. Model funguje dobře na trénovacích datech, ale nedokáže správně předpovědět neviditelná data.
Díky TensorFlow jsou tyto dva kroky snadné. Když data jdou do potrubí, ví, kolik pozorování potřebuje (dávka) a jestli má data zamíchat.
Chcete-li instruovat Tensorflow, jak nakrmit model, můžete použít pandas_input_fn. Tento objekt potřebuje 5 parametrů:
- x: data funkcí
- y: údaje štítku
- batch_size: dávka. Ve výchozím nastavení 128
- num_epoch: Počet epoch, ve výchozím nastavení 1
- shuffle: Zamíchat nebo nezamíchat data. Ve výchozím nastavení Žádná
Musíte model nakrmit mnohokrát, takže definujete 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)
Obvyklá metoda hodnocení výkonu modelu je:
- Trénujte model
- Vyhodnoťte model v jiné datové sadě
- Proveďte předpověď
Tensorflow estimator 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 vlak odhadů. Odhadce vlaků potřebuje input_fn a několik kroků. Funkci, kterou jste vytvořili výše, můžete použít k nasunutí modelu. Poté dáte modelu pokyn, aby se 1000krát opakoval. Všimněte si, že nezadáte počet epoch, necháte model 1000krát iterovat. Pokud nastavíte počet epoch na 1, model se bude opakovat 4krát: V trénovací sadě je 400 záznamů a velikost dávky je 128
- Řady 128
- Řady 128
- Řady 128
- Řady 16
Proto je snazší nastavit počet epoch na žádné a definovat počet iterací, jak je uvedeno v níže uvedeném 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 = 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.
Můžete zkontrolovat, že Tensorboard vydá následující příkaz:
activate hello-tf # For MacOS tensorboard --logdir=./train # For Windows tensorboard --logdir=train
Krok 5) Zhodnoťte svůj model
Pomocí níže uvedeného kódu můžete vyhodnotit vhodnost vašeho modelu na testovací sadě:
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: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
Ztrátu si 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, abyste získali představu o tom, jak velká je chyba.
training_set['medv'].describe()
Výstup
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
Z výše uvedené souhrnné statistiky víte, že průměrná cena za dům je 22 tisíc, přičemž minimální cena je 9 tisíc a maximální 50 tisíc. Model dělá typickou chybu 3 XNUMX dolarů.
Krok 6) Proveďte předpověď
Nakonec můžete pomocí odhadu TensorFlow předpovědět hodnotu 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-1000 INFO:tensorflow:Running local_init_op. INFO:tensorflow:Done running local_init_op. Predictions: [array([32.297546], dtype=float32), array([18.96125], dtype=float32), array([27.270979], dtype=float32), array([29.299236], dtype=float32), array([16.436684], dtype=float32), array([21.460876], dtype=float32)]
Model 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 tutoriálu hlubokého učení se pokusíte porazit lineární model
Numpy řešení
Tato část vysvětluje, jak trénovat model pomocí numpy estimátoru pro vkládání dat. Metoda je stejná až na to, ž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
predikce_set_n = pd.read_csv(“E:/boston_predict.csv”).hodnoty
Krok 1) Importujte data
Nejprve musíte odlišit proměnné funkce 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
Pomocí funkce můžete oddělit štítek od funkcí datové sady vlaku/vyhodnocení
X_train, y_train = prepare_data(training_set_n) X_test, y_test = prepare_data(test_set_n)
Je třeba vyloučit poslední sloupec prediktivní datové sady, 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 sestavit následovně:
feature_columns = [ tf.feature_column.numeric_column('x', shape=X_train.shape[1:])]
Odhad je definován jako dříve, vy určíte sloupce prvků a kam se má 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': <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}
Můžete použít numpy estimapor pro vložení dat do modelu a poté model trénovat. Všimněte si, že funkci input_fn definujeme dříve, 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 = 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>
Pro vyhodnocení modelu replikujete stejný krok s jiným odhadem
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: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}
Nakonec můžete vypočítat předpověď. Mělo by to být podobné jako u pand.
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-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)]
Ř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 Jupyter zápisníkChcete-li spustit tuto relaci, musíte restartovat a vyčistit jádro.
TensorFlow vytvořil skvělý nástroj pro předávání dat do potrubí. V této části si sami vytvoříte funkci input_fn.
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énovací 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 ze souboru csv definovat sloupce, které chcete použít. Využijeme všechny. Poté musíte deklarovat typ proměnné, o kterou se jedná.
Proměnné s plovoucí cenou jsou definovány pomocí [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:
- Importujte data
- Vytvořte iterátor
- Spotřebujte data
Níže je uveden celkový kód pro definování funkce. Kód bude vysvětlen poté
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
** Importujte data**
U souboru csv čte metoda datové sady vždy jeden řádek. 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 čtete data a vylučujete hlavičku v kanálu. Chcete-li napájet model, musíte oddělit funkce od štítku. Metoda použitá k aplikaci jakékoli transformace na data je mapa.
Tato metoda volá funkci, kterou vytvoříte, abyste dali pokyn, jak transformovat data. Stručně řečeno, musíte data předat v TextLineObjekt datové sady, vylučte hlavičku a použijte transformaci, která je instruována vysvětlením function.Code
- 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, která bude instruovat objekt mapy. Tuto funkci můžete zavolat parse_csv.
Tato funkce analyzuje soubor csv metodou tf.decode_csv a deklaruje vlastnosti a štítek. Prvky mohou být deklarovány jako slovník nebo n-tice. Používáte slovníkovou metodu, protože je pohodlnější. Vysvětlení kódu
- tf.decode_csv(value, record_defaults= RECORDS_ALL): metoda decode_csv používá výstup TextLineDatová sada pro čtení souboru csv. record_defaults dává TensorFlow pokyn o typu sloupců.
- dict(zip(_CSV_COLUMNS, sloupce)): Naplní 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é feature a vytvořit proměnnou label
Datová sada potřebuje další prvky, aby mohla iterativně krmit tenzory. Ve skutečnosti musíte přidat opakování metody, abyste umožnili datové množině pokračovat neomezeně a napájet model. Pokud metodu nepřidáte, model se bude iterovat pouze jednou a poté vyvolá chybu, protože do potrubí se nepřidávají žádná další data.
Poté můžete řídit velikost dávky pomocí metody dávky. To znamená, že sdělíte datové sadě, kolik dat chcete předat v kanálu 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 pro vrácení prvků v datové sadě.
Nejjednodušší způsob vytvoření operátoru je pomocí metody make_one_shot_iterator.
Poté můžete vytvořit funkce a štítky z iterátoru.
Krok 4) Spotřebujte data
Můžete zkontrolovat, co se stane s funkcí input_fn. Chcete-li spotřebovat data, musíte funkci zavolat v relaci. Zkusíte s velikostí dávky rovnou 1.
Všimněte si, že vytiskne 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 různou 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 prvku
Čí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 je potřeba zkombinovat 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í estimátoru 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': <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}
Musíte použít funkci lambda, abyste umožnili zapsat argument do funkce inpu_fn. Pokud nepoužíváte a funkce 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 = 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>
Vhodnost vašeho modelu na testovací sadě můžete vyhodnotit pomocí kódu níže:
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: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
Posledním krokem je predikce hodnoty na základě hodnoty , matic funkcí. Můžete si napsat slovník s hodnotami, které chcete předpovídat. Váš model má 9 funkcí, takže pro každou musíte zadat hodnotu. Model poskytne předpověď pro každou z nich.
V níže uvedeném kódu jste napsali hodnoty jednotlivých funkcí obsažených 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 předpovědi vytisknete.
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-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)})
Shrnutí
Chcete-li trénovat modelku, musíte:
- Definujte vlastnosti: Nezávislé proměnné: X
- Definujte štítek: Závislá proměnná: y
- Sestavte vlak/zkušební soupravu
- Definujte počáteční hmotnost
- Definujte ztrátovou funkci: MSE
- Optimalizujte model: Gradientní klesání
- Definovat:
- Míra učení
- Počet epoch
- Objem várky
V tomto tutoriálu jste se naučili používat vysokoúrovňové API pro lineární regresní odhad TensorFlow. Musíte definovat:
- Sloupce funkcí. Pokud je spojitý: tf.feature_column.numeric_column(). Seznam můžete naplnit s porozuměním seznamu python
- Odhad: tf.estimator.LinearRegressor(feature_columns, model_dir)
- Funkce pro import dat, velikosti dávky a epochy: input_fn()
Poté jste připraveni trénovat, vyhodnocovat a předpovídat pomocí train(), vyhodnotit() a predikovat()