Výukový program RNN (Recurrent Neural Network): Příklad TensorFlow
Evelyn Clarkeová
⚡ Chytré shrnutí
Rekurentní neuronové sítě přidávají k běžným neuronům paměťový stav a každý výstup vracejí zpět jako další vstup, aby se model mohl učit z daného pořadí. Tento návod vytváří jednu v TensorFlow a předpovídá časovou řadu.
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 an Umělá neuronová síť je relativně jednoduchý a spočívá hlavně v násobení matic. V prvním kroku jsou vstupy vynásobeny původně náhodnými váhami a zkreslením, transformovány aktivační funkcí a výstupní hodnoty jsou použity k vytvoření predikce. 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. dokud nelze získat další informace.tracted.
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)?
Rekurentní neuronová síť (RNN) je třída umělé neuronové sítě, ve které spojení mezi různými uzly tvoří orientovaný graf, který poskytuje časově dynamické chování. Pomáhá modelovat sekvenční data odvozená 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, který přijímá dávku 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 několikrát odeslán zpět k sobě samé. Voláme časový krok doba, po kterou se výstup stává vstupem pro další násobení matic.
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.
Rekurentní neuronová síť (RNN)
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.
Poznámka k verzi: Kód v tomto tutoriálu je zaměřen na grafické API TensorFlow 1.x. Na TensorFlow 2.x stejný skript stále běží i po import tensorflow.compat.v1 as tf Plus tf.disable_v2_behavior(), protože zástupné symboly, relace a modul rnn_cell nyní žijí pod tf.compat.v1Idiomatický ekvivalent 2.x je tf.keras.layers.SimpleRNN.
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 minulé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í vypíšete hodnoty předchozího stavu. Výstup vytištěný výše ukazuje výstup z posledního stavu. Nyní vypište všechny výstupy, všimněte si, že stavy jsou předchozím výstupem každé dávky. To znamená, že předchozí výstup obsahuje informace o celé sekvenci.
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)
Níže uvedený anotovaný pohled rozděluje stejný vytištěný tenzor dávku po dávce.
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 ovlivňuje výstup 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 pádem ani výstup. Síť, která čelí problému mizivého gradientu, proto nemůže konvergovat k dobrému řešení.
Vylepšení LSTM
Aby se překonal potenciální problém s mizivým gradientem, 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, LSTM poskytuje síti relevantní minulé informace až do nedávnější doby. Stroj používá lepší architekturu pro výběr a přenos informací zpět do pozdější doby.
Architektura LSTM je k dispozici v TensorFlow, tf.contrib.rnn.LSTMCell. LSTM není předmětem tohoto tutoriálu. Můžete se podívat na oficiální... dokumentace další informace
V TensorFlow 2.x je tato buňka dosažena jako tf.compat.v1.nn.rnn_cell.LSTMCell, zatímco nový kód obvykle používá tf.keras.layers.LSTM nebo lehčí bránu tf.keras.layers.GRU, který dosahuje srovnatelné přesnosti s menším počtem parametrů.
RNN v časové řadě
V tomto tutoriálu o TensorFlow RNN budete používat RNN s časovými řadami. Časové řady jsou závislé na minulém čase, což znamená, že minulé hodnoty zahrnují relevantní informace, ze kterých se síť může učit. Myšlenkou predikce časových řad je odhadnout budoucí hodnotu řady, například ceny akcií, teploty, 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()
Pravá část grafu zobrazuje všechny série. Začínala rokem 2001 a končila rokem 2019. Nemá smysl vkládat všechna data do sítě, místo toho je třeba 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 posunutá o jedno období (tj. chcete předpovědět 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 rekurentních neuronů. Modelu dodáváte jeden vstup, tj. jeden den. Nebojte se změnit hodnoty a uvidíte, zda se model zlepšil.
Před konstrukcí modelu je třeba rozdělit datovou sadu na trénovací a testovací sadu. Celá datová sada má 222 datových bodů; prvních 201 bodů použijete k trénování modelu a posledních 21 bodů k testování modelu.
Po definování sady vlaků a testů je třeba vytvořit objekt obsahující dávky. V těchto dávkách máte hodnoty X a hodnoty Y. Nezapomeňte, že hodnoty X jsou zpožděny 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. Objekt y_batches má stejný tvar jako objekt X_batches, ale s jednou periodou napřed.
Krok 1) Vytvořte vlak a vyzkoušejte
Nejprve převedete řadu na a nemotorný 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 o tolik, kolikrát chcete předpovědět. Například, pokud chcete předpovědět o jeden den dopředu, posunete řadu o 1. Pokud chcete předpovědět o dva dny, posunete 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 (viz tutoriál na Úvod do TensorFlow pro osvěžení mysli ohledně deklarace proměnné) má tři rozměry:
- Poznámka: velikost šarže
- n_windows: Délka oken, tj. počet pohledů modelu zpět
- 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 téma CNN, vaším cílem bylo klasifikovat obrázky, v tomto tutoriálu o RNN je cíl mírně odlišný. Jste požádáni o predikci spojité proměnné v porovná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á prostor pro vylepšení. Je na vás, abyste změnili hyperparametry, jako jsou okna, velikost dávky nebo počet 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()
Předpověď vs skutečnost
