Výukový program RNN (Recurrent Neural Network): Příklad TensorFlow
Evelyn Clarkeová
Proč potřebujeme rekurentní neuronovou síť (RNN)?
Rekurentní neuronová síť (RNN) vám umožňuje modelovat paměťové jednotky pro zachování dat a modelovat krátkodobé závislosti. Používá se také v prognózování časových řad pro identifikaci datových korelací a vzorů. Pomáhá také vytvářet prediktivní výsledky pro sekvenční data tím, že poskytuje podobné chování jako lidský mozek.
Struktura umělé neuronové sítě je poměrně jednoduchá a spočívá hlavně v násobení matic. Během prvního kroku jsou vstupy vynásobeny původně náhodnými váhami a vychýlení, transformované aktivační funkcí a výstupní hodnoty jsou použity k předpovědi. Tento krok poskytuje představu o tom, jak daleko je síť od reality.
Použitou metrikou je ztráta. Čím vyšší je ztrátová funkce, tím je model hloupější. Pro zlepšení znalostí sítě je nutná určitá optimalizace úpravou vah sítě. Stochastický gradient klesání je metoda používaná ke změně hodnot vah ve směru doprava. Jakmile je úprava provedena, může síť použít další dávku dat k testování svých nových znalostí.
Chyba je naštěstí nižší než dříve, ale ne dostatečně malá. Optimalizační krok se provádí iterativně, dokud není chyba minimalizována, tj. nelze extrahovat žádné další informace.
Problémem tohoto typu modelu je, že nemá žádnou paměť. To znamená, že vstup a výstup jsou nezávislé. Jinými slovy, model se nestará o to, co bylo předtím. Vyvolává to určitou otázku, když potřebujete předpovídat časové řady nebo věty, protože síť potřebuje mít informace o historických datech nebo minulých slovech.
K překonání tohoto problému byl vyvinut nový typ architektury: Recurrent Neural Network (dále RNN)
Co je to rekurentní neuronová síť (RNN)?
A Rekurentní neuronová síť (RNN) je třída Umělá neuronová síť ve kterém spojení mezi různými uzly tvoří směrovaný graf, který dává časové dynamické chování. Pomáhá modelovat sekvenční data, která jsou odvozena z dopředných sítí. Funguje podobně jako lidský mozek a poskytuje prediktivní výsledky.
Rekurentní neuronová síť vypadá docela podobně jako tradiční neuronová síť, kromě toho, že k neuronům je přidán stav paměti. Výpočet pro zahrnutí paměti je jednoduchý.
Představte si jednoduchý model s pouze jedním neuronem napájeným dávkou dat. V tradiční neuronové síti model vytváří výstup vynásobením vstupu váhou a aktivační funkcí. U RNN je tento výstup poslán zpět sobě samému kolikrát. voláme časový krok doba, po kterou se výstup stane vstupem dalšího násobení matice.
Například na obrázku níže můžete vidět, že síť se skládá z jednoho neuronu. Síť vypočítá násobení matic mezi vstupem a váhou a přidá nelinearitu s aktivační funkcí. Stane se výstupem v t-1. Tento výstup je vstupem druhého násobení matice.
Níže kódujeme jednoduchý RNN v TensorFlow, abychom pochopili krok a také tvar výstupu.
Síť se skládá z:
- Čtyři vstupy
- Šest neuronů
- 2-násobné kroky
Síť bude probíhat tak, jak je znázorněno na obrázku níže.
Síť se nazývá 'rekurentní', protože provádí stejnou operaci v každém aktivačním čtverci. Síť před použitím aktivační funkce vypočítala váhy vstupů a předchozího výstupu.
import numpy as np
import tensorflow as tf
n_inputs = 4
n_neurons = 6
n_timesteps = 2
The data is a sequence of a number from 0 to 9 and divided into three batches of data.
## Data
X_batch = np.array([
[[0, 1, 2, 5], [9, 8, 7, 4]], # Batch 1
[[3, 4, 5, 2], [0, 0, 0, 0]], # Batch 2
[[6, 7, 8, 5], [6, 5, 4, 2]], # Batch 3
])
Můžeme vytvořit síť se zástupným symbolem pro data, rekurentní stupeň a výstup.
- Definujte zástupný symbol pro data
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
Zde:
- Žádný: Neznámý a bude mít velikost dávky
- n_timesteps: Kolikrát síť pošle výstup zpět neuronu
- n_inputs: Počet vstupů na dávku
- Definujte opakující se síť
Jak je uvedeno na obrázku výše, síť se skládá ze 6 neuronů. Síť vypočítá součin dvou teček:
- Vstupní data s první sadou vah (tj. 6: rovno počtu neuronů)
- Předchozí výstup s druhou sadou vah (tj. 6: odpovídající počtu výstupů)
Všimněte si, že během prvního dopředného kanálu se hodnoty předchozího výstupu rovnají nulám, protože nemáme k dispozici žádnou hodnotu.
Objekt pro vytvoření RNN je tf.contrib.rnn.BasicRNNCell s argumentem num_units pro definování počtu vstupů
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
Nyní, když je síť definována, můžete vypočítat výstupy a stavy
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
Tento objekt používá vnitřní smyčku k vynásobení matic odpovídajícím počtem opakování.
Všimněte si, že rekurentní neuron je funkcí všech vstupů z předchozích časových kroků. Takto si síť buduje vlastní paměť. Informace z předchozího času se mohou šířit v budoucím čase. To je kouzlo rekurentní neuronové sítě
## Define the shape of the tensor
X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])
## Define the network
basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)
outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
init = tf.global_variables_initializer()
init = tf.global_variables_initializer()
with tf.Session() as sess:
init.run()
outputs_val = outputs.eval(feed_dict={X: X_batch})
print(states.eval(feed_dict={X: X_batch}))
[[ 0.38941205 -0.9980438 0.99750966 0.7892596 0.9978241 0.9999997 ]
[ 0.61096436 0.7255889 0.82977575 -0.88226104 0.29261455 -0.15597084]
[ 0.62091285 -0.87023467 0.99729395 -0.58261937 0.9811445 0.99969864]]
Pro účely vysvětlení vytisknete hodnoty předchozího stavu. Výstup vytištěný výše ukazuje výstup z posledního stavu. Nyní vytiskněte celý výstup, můžete si všimnout, že stavy jsou předchozím výstupem každé dávky. To znamená, že předchozí výstup obsahuje informace o celé sekvenci.e
print(outputs_val)
print(outputs_val.shape)
[[[-0.75934666 -0.99537754 0.9735819 -0.9722234 -0.14234993
-0.9984044 ]
[ 0.99975264 -0.9983206 0.9999993 -1. -0.9997506
-1. ]]
[[ 0.97486496 -0.98773265 0.9969686 -0.99950117 -0.7092863
-0.99998885]
[ 0.9326837 0.2673438 0.2808514 -0.7535883 -0.43337247
0.5700631 ]]
[[ 0.99628735 -0.9998728 0.99999213 -0.99999976 -0.9884324
-1. ]
[ 0.99962527 -0.9467421 0.9997403 -0.99999714 -0.99929446
-0.9999795 ]]]
(3, 2, 6)
Výstup má tvar (3, 2, 6):
- 3: Počet šarží
- 2: Číslo časového kroku
- 6: Počet neuronů
Optimalizace rekurentní neuronové sítě je totožná s tradiční neuronovou sítí. Podrobněji uvidíte, jak optimalizovat kód v další části tohoto tutoriálu Recurrent Neuron Network.
Aplikace RNN
RNN má mnohostranné využití, zejména pokud jde o předpovídání budoucnosti. Ve finančním průmyslu může být RNN užitečné při předpovídání cen akcií nebo znamení směru akciového trhu (tj. kladného nebo záporného).
RNN je užitečné pro autonomní auto, protože se může vyhnout dopravní nehodě tím, že předvídá trajektorii vozidla.
RNN je široce používán v textové analýze, popisování obrázků, analýze sentimentu a strojovém překladu. Například filmovou recenzi lze použít k pochopení pocitu, který divák po zhlédnutí filmu vnímal. Automatizace tohoto úkolu je velmi užitečná, když filmová společnost nemá dostatek času na přezkoumání, označení, konsolidaci a analýzu recenzí. Stroj může dělat práci s vyšší úrovní přesnosti.
Omezení RNN
Teoreticky má RNN přenášet informace až do nekonečna. Je však poměrně náročné šířit všechny tyto informace, když je časový krok příliš dlouhý. Když má síť příliš mnoho hlubokých vrstev, stává se netrénovatelnou. Tento problém se nazývá: mizející problém s gradientem. Pokud si pamatujete, neuronová síť aktualizuje váhu pomocí gradientu sestupného algoritmu. Gradienty se zmenšují, když síť postupuje dolů do nižších vrstev.
Závěrem lze říci, že gradienty zůstávají konstantní, což znamená, že není prostor pro zlepšení. Model se učí ze změny gradientu; tato změna ovlivní výkon sítě. Pokud je však rozdíl v gradientu příliš malý (tj. váhy se trochu změní), síť se nemůže nic naučit a tím i výstup. Proto síť čelící problému mizejícího gradientu nemůže konvergovat k dobrému řešení.
Vylepšení LSTM
K překonání potenciálního problému mizejícího gradientu, kterému čelí RNN, tři výzkumníci, Hochreiter, Schmidhuber a Bengio, vylepšili RNN architekturou nazvanou Long Short-Term Memory (LSTM). Stručně řečeno, LSMT poskytuje síti relevantní minulé informace do novější doby. Stroj používá lepší architekturu k výběru a přenosu informací zpět do pozdější doby.
Architektura LSTM je dostupná v TensorFlow, tf.contrib.rnn.LSTMCell. LSTM je mimo rozsah výukového programu. Můžete se obrátit na úředníka dokumentace další informace
RNN v časové řadě
V tomto tutoriálu TensorFlow RNN budete používat RNN s daty časové řady. Časové řady jsou závislé na předchozím čase, což znamená, že minulé hodnoty zahrnují relevantní informace, ze kterých se síť může učit. Myšlenkou predikce časové řady je odhadnout budoucí hodnotu řady, řekněme cenu akcií, teplotu, HDP a tak dále.
Příprava dat pro Keras RNN a časové řady může být trochu složitější. Za prvé, cílem je předpovědět další hodnotu řady, což znamená, že použijete minulé informace k odhadu hodnoty v t + 1. Označení se rovná vstupní sekvenci a je posunuto o jednu periodu dopředu. Za druhé, počet vstupů je nastaven na 1, tj. jedno pozorování za čas. Nakonec se časový krok rovná posloupnosti číselné hodnoty. Pokud například nastavíte časový krok na 10, vstupní sekvence se vrátí desetkrát za sebou.
Podívejte se na graf níže, nalevo jsme znázornili data časové řady a napravo fiktivní vstupní sekvenci. Vytvoříte funkci pro vrácení datové sady s náhodnou hodnotou pro každý den od ledna 2001 do prosince 2016
# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
def create_ts(start = '2001', n = 201, freq = 'M'):
rng = pd.date_range(start=start, periods=n, freq=freq)
ts = pd.Series(np.random.uniform(-18, 18, size=len(rng)), rng).cumsum()
return ts
ts= create_ts(start = '2001', n = 192, freq = 'M')
ts.tail(5)
Výstup
2016-08-31 -93.459631 2016-09-30 -95.264791 2016-10-31 -95.551935 2016-11-30 -105.879611 2016-12-31 -123.729319 Freq: M, dtype: float64
ts = create_ts(start = '2001', n = 222)
# Left
plt.figure(figsize=(11,4))
plt.subplot(121)
plt.plot(ts.index, ts)
plt.plot(ts.index[90:100], ts[90:100], "b-", linewidth=3, label="A training instance")
plt.title("A time series (generated)", fontsize=14)
# Right
plt.subplot(122)
plt.title("A training instance", fontsize=14)
plt.plot(ts.index[90:100], ts[90:100], "b-", markersize=8, label="instance")
plt.plot(ts.index[91:101], ts[91:101], "bo", markersize=10, label="target", markerfacecolor='red')
plt.legend(loc="upper left")
plt.xlabel("Time")
plt.show()
V pravé části grafu jsou zobrazeny všechny řady. Začalo to v roce 2001 a skončí v roce 2019 Nemá smysl dodávat všechna data v síti, místo toho musíte vytvořit dávku dat o délce rovné časovému kroku. Tato dávka bude proměnná X. Proměnná Y je stejná jako X, ale je posunuta o jedno období (tj. chcete předpovídat t+1).
Oba vektory mají stejnou délku. Můžete to vidět v pravé části výše uvedeného grafu. Řádek představuje deset hodnot vstupu X, zatímco červené tečky představují deset hodnot štítku Y. Všimněte si, že štítek začíná jednu tečku před X a končí jednu tečku poté.
Vytvořte RNN pro předpovídání časových řad v TensorFlow
Nyní v tomto tréninku RNN je čas postavit si svůj první RNN, abyste mohli předpovídat sérii výše. Musíte zadat některé hyperparametry (parametry modelu, tj. počet neuronů atd.) pro model:
- Počet vstupů: 1
- Časový krok (okna v časové řadě): 10
- Počet neuronů: 120
- Počet výstupů: 1
Vaše síť se bude učit ze sekvence 10 dnů a bude obsahovat 120 opakujících se neuronů. Nakrmíte model jedním vstupem, tj. jeden den. Neváhejte změnit hodnoty, abyste viděli, zda se model zlepšil.
Před vytvořením modelu musíte rozdělit datovou sadu na vlakovou a testovací sadu. Úplný datový soubor má 222 datových bodů; prvních 201 bodů použijete k trénování modelu a posledních 21 bodů k otestování modelu.
Poté, co definujete vlakovou a testovací sadu, musíte vytvořit objekt obsahující dávky. V těchto dávkách máte hodnoty X a hodnoty Y. Pamatujte, že hodnoty X jsou zpožděné o jednu periodu. Proto použijete prvních 200 pozorování a časový krok je roven 10. Objekt X_batches by měl obsahovat 20 dávek o velikosti 10*1. y_batches má stejný tvar jako objekt X_batches, ale s jednou tečkou dopředu.
Krok 1) Vytvořte vlak a vyzkoušejte
Nejprve převedete řadu na a otupělý pole; poté definujete okna (tj. počet časů, kdy se síť bude učit), počet vstupů, výstupů a velikost vlakové soupravy, jak je znázorněno v příkladu TensorFlow RNN níže.
series = np.array(ts) n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Poté pole jednoduše rozdělíte na dvě datové sady.
## Split data train = series[:size_train] test = series[size_train:] print(train.shape, test.shape) (201,) (21,)
Krok 2) Vytvořte funkci, která vrátí X_batches a y_batches
Aby to bylo jednodušší, můžete vytvořit funkci, která vrací dvě různá pole, jedno pro X_batches a druhé pro y_batches.
Pojďme napsat funkci RNN TensorFlow pro konstrukci dávek.
Všimněte si, že dávky X jsou zpožděny o jednu periodu (bereme hodnotu t-1). Výstup funkce by měl mít tři rozměry. První rozměr se rovná počtu dávek, druhý rozměru oken a poslední počet vstupů.
Ošemetná část je správně vybrat datové body. Pro datové body X zvolíte pozorování od t = 1 do t = 200, zatímco pro datový bod Y vrátíte pozorování od t = 2 do 201. Jakmile máte správné datové body, je snadné je přetvořit série.
Chcete-li vytvořit objekt s dávkami, musíte datovou sadu rozdělit do deseti dávek stejné délky (tj. 20). Můžete použít metodu reshape a předat -1, aby série byla podobná velikosti dávky. Hodnota 20 je počet pozorování na dávku a 1 je počet vstupů.
Musíte udělat stejný krok, ale pro štítek.
Všimněte si, že je třeba posunout data na tolikrát, kolikrát chcete prognózovat. Pokud například chcete předpovídat jeden čas dopředu, posunete řadu o 1. Pokud chcete předpovídat dva dny, posuňte data o 2.
x_data = train[:size_train-1]: Select all the training instance minus one day
X_batches = x_data.reshape(-1, windows, input): create the right shape for the batch e.g (10, 20, 1)
def create_batches(df, windows, input, output):
## Create X
x_data = train[:size_train-1] # Select the data
X_batches = x_data.reshape(-1, windows, input) # Reshape the data
## Create y
y_data = train[n_output:size_train]
y_batches = y_data.reshape(-1, windows, output)
return X_batches, y_batches
Nyní, když je funkce definována, můžete ji zavolat k vytvoření dávek, jak je znázorněno v níže uvedeném příkladu RNN.
X_batches, y_batches = create_batches(df = train,
windows = n_windows,
input = n_input,
output = n_output)
Tvar můžete vytisknout, abyste se ujistili, že rozměry jsou správné.
print(X_batches.shape, y_batches.shape) (10, 20, 1) (10, 20, 1)
Musíte vytvořit testovací sadu pouze s jednou dávkou dat a 20 pozorováními.
Všimněte si, že předpovídáte dny po dnech, to znamená, že druhá předpokládaná hodnota bude založena na skutečné hodnotě prvního dne (t+1) testovací datové sady. Ve skutečnosti bude známa skutečná hodnota.
Pokud chcete předpovídat t+2 (tj. dva dny dopředu), musíte použít předpovídanou hodnotu t+1; pokud budete předpovídat t+3 (tři dny dopředu), musíte použít předpovídanou hodnotu t+1 a t+2. Dává to smysl, že je obtížné přesně předpovědět t+n dní dopředu.
X_test, y_test = create_batches(df = test, windows = 20,input = 1, output = 1) print(X_test.shape, y_test.shape) (10, 20, 1) (10, 20, 1)
Dobře, velikost vaší dávky je připravena, můžete vytvořit architekturu RNN. Pamatujte, že máte 120 opakujících se neuronů.
Krok 3) Sestavte model
Chcete-li vytvořit model, musíte definovat tři části:
- Proměnná s tenzory
- RNN
- Ztráta a optimalizace
Krok 3.1) Proměnné
Je třeba zadat proměnné X a y s příslušným tvarem. Tento krok je triviální. Tenzor má stejný rozměr jako objekty X_batches a y_batches.
Například tenzor X je zástupný symbol (podívejte se na tutoriál Úvod do tenzorový tok pro osvěžení mysli ohledně deklarace proměnné) má tři rozměry:
- Poznámka: velikost šarže
- n_windows: Délka oken. tj. kolikrát se model dívá dozadu
- n_input: Číslo vstupu
Výsledek je:
tf.placeholder(tf.float32, [None, n_windows, n_input])
## 1. Construct the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output])
Krok 3.2) Vytvořte RNN
Ve druhé části tohoto příkladu RNN TensorFlow musíte definovat architekturu sítě. Stejně jako dříve použijete objekt BasicRNNCell a dynamic_rnn z estimátoru TensorFlow.
## 2. create the model basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)
Další část je trochu složitější, ale umožňuje rychlejší výpočet. Musíte transformovat výstup běhu na hustou vrstvu a poté ji znovu převést, aby měla stejný rozměr jako vstup.
stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Krok 3.3) Vytvořte ztrátu a optimalizaci
Optimalizace modelu závisí na úloze, kterou provádíte. V předchozím tutoriálu na CNN, vaším cílem bylo klasifikovat obrázky, v tomto tutoriálu RNN je cíl mírně odlišný. Jste požádáni, abyste provedli předpověď pro spojitou proměnnou ve srovnání s třídou.
Tento rozdíl je důležitý, protože změní problém optimalizace. Optimalizačním problémem pro spojitou proměnnou je minimalizace střední kvadratické chyby. Chcete-li vytvořit tyto metriky v TF, můžete použít:
- tf.reduce_sum(tf.square(výstupy – y))
Zbývající kód RNN je stejný jako dříve; používáte optimalizátor Adam ke snížení ztráty (tj. MSE):
- tf.train.AdamOptimizer(learning_rate=learning_rate)
- optimalizátor.minimalizovat (ztráta)
To je vše, můžete vše zabalit dohromady a váš model je připraven k tréninku.
tf.reset_default_graph() r_neuron = 120 ## 1. Construct the tensors X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output]) ## 2. create the model basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output]) ## 3. Loss + optimization learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss) init = tf.global_variables_initializer()
Budete trénovat model pomocí 1500 epoch a tisknout ztrátu každých 150 iterací. Jakmile je model trénován, vyhodnotíte model na testovací sadě a vytvoříte objekt obsahující předpovědi, jak je znázorněno v níže uvedeném příkladu rekurentní neuronové sítě.
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test})
0 MSE: 502893.34
150 MSE: 13839.129
300 MSE: 3964.835
450 MSE: 2619.885
600 MSE: 2418.772
750 MSE: 2110.5923
900 MSE: 1887.9644
1050 MSE: 1747.1377
1200 MSE: 1556.3398
1350 MSE: 1384.6113
Konečně v tomto tutoriálu RNN Deep Learning můžete vykreslit skutečnou hodnotu série s předpokládanou hodnotou. Pokud je váš model opraven, předpokládané hodnoty by měly být umístěny nad skutečné hodnoty.
Jak vidíte, model má co zlepšovat. Je na vás, abyste změnili hyperparametry, jako jsou okna, velikost dávky počtu rekurentních neuronů.
plt.title("Forecast vs Actual", fontsize=14)
plt.plot(pd.Series(np.ravel(y_test)), "bo", markersize=8, label="Actual", color='green')
plt.plot(pd.Series(np.ravel(y_pred)), "r.", markersize=8, label="Forecast", color='red')
plt.legend(loc="lower left")
plt.xlabel("Time")
plt.show()
Shrnutí
Rekurentní neuronová síť je robustní architektura pro práci s časovými řadami nebo textovou analýzou. Výstupem předchozího stavu je zpětná vazba pro zachování paměti sítě v průběhu času nebo sekvence slov.
V TensorFlow můžete použít následující kódy k trénování rekurentní neuronové sítě TensorFlow pro časové řady:
Parametry modelu
n_windows = 20 n_input = 1 n_output = 1 size_train = 201
Definujte model
X = tf.placeholder(tf.float32, [None, n_windows, n_input]) y = tf.placeholder(tf.float32, [None, n_windows, n_output]) basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu) rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32) stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron]) stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output) outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])
Vytvořte optimalizaci
learning_rate = 0.001 loss = tf.reduce_sum(tf.square(outputs - y)) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate) training_op = optimizer.minimize(loss)
Trénujte model
init = tf.global_variables_initializer()
iteration = 1500
with tf.Session() as sess:
init.run()
for iters in range(iteration):
sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
if iters % 150 == 0:
mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
print(iters, "\tMSE:", mse)
y_pred = sess.run(outputs, feed_dict={X: X_test})
