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.

Stáhněte si Boston DataSet

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.

Trénujte model lineární regrese

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:

Trénujte model lineární regrese

S:

  • Lineární regrese s TensorFlow je zaujatost. tj. pokud x=0, y=Trénujte model lineární regrese
  • Trénujte model lineární regrese je váha spojená s x
  • Trénujte model lineární regrese 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í:

  • Trénujte model lineární regrese = 3.8
  • Trénujte model lineární regrese = 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.

Trénujte model lineární regrese

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

Trénujte model lineární regrese

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

Práce s algoritmem

Algoritmus pro každý vybere náhodné číslo Lineární regrese s TensorFlow si Práce s algoritmem 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 Práce s algoritmem 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.

Práce s algoritmem

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:

Práce s algoritmem

Kde:

  • Práce s algoritmem jsou váhy tak Práce s algoritmem odkazuje na předpokládanou hodnotu
  • y jsou skutečné hodnoty
  • m je počet pozorování

Všimněte si, že Práce s algoritmem znamená, že používá transpozici matic. The Práce s algoritmem je matematický zápis průměru.

Cílem je najít to nejlepší Práce s algoritmem 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.

Práce s algoritmem

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

Práce s algoritmem

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:

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

  1. Řady 128
  2. Řady 128
  3. Řady 128
  4. Ř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:

  1. Importujte data
  2. Vytvořte iterátor
  3. 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:

  1. Sloupce funkcí. Pokud je spojitý: tf.feature_column.numeric_column(). Seznam můžete naplnit s porozuměním seznamu python
  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, vyhodnocovat a předpovídat pomocí train(), vyhodnotit() a predikovat()