RNN (Recurrent Neural Network) oktatóanyag: TensorFlow példa

Miért van szükségünk ismétlődő neurális hálózatra (RNN)?

Az ismétlődő neurális hálózat (RNN) lehetővé teszi a memóriaegységek modellezését az adatok tartósítására és a rövid távú függőségek modellezésére. Idősoros előrejelzésben is használják adatkorrelációk és minták azonosítására. Az emberi agyhoz hasonló viselkedéssel segíti a szekvenciális adatok prediktív eredményét is.

A szerkezet egy Mesterséges neurális hálózat viszonylag egyszerű, és főként a mátrixok szorzásáról szól. Az első lépésben a bemeneteket kezdetben véletlenszerű súlyokkal és torzítással szorozzák meg, egy aktivációs függvénnyel transzformálják, és a kimeneti értékeket felhasználják egy predikció elkészítéséhez. Ez a lépés képet ad arról, hogy a hálózat milyen messze van a valóságtól.

Az alkalmazott mérőszám a veszteség. Minél nagyobb a veszteségfüggvény, annál hülyébb a modell. A hálózat ismeretének javításához némi optimalizálás szükséges a háló súlyainak beállításával. A sztochasztikus gradiens süllyedés az a módszer, amellyel a súlyok értékét a jobb irányba változtatjuk. A kiigazítás után a hálózat egy újabb adatköteget használhat az új tudás tesztelésére.

A hiba szerencsére kisebb, mint korábban, de mégsem elég kicsi. Az optimalizálási lépést iteratívan hajtjuk végre, amíg a hiba minimalizálódik, azaz több információ már nem kinyerhető.tracted.

Az ilyen típusú modellekkel az a probléma, hogy nincs benne memória. Ez azt jelenti, hogy a bemenet és a kimenet független. Más szóval, a modell nem törődik azzal, ami korábban volt. Felvet néhány kérdést, ha idősorokat vagy mondatokat kell megjósolni, mivel a hálózatnak információval kell rendelkeznie a múltbeli adatokról vagy múltbeli szavakról.

A probléma megoldására egy új típusú architektúrát fejlesztettek ki: Recurrent Neural Network (RNN a továbbiakban)

Mi az a visszatérő neurális hálózat (RNN)?

A rekurrens neurális hálózat (RNN) a mesterséges neurális hálózatok egy olyan osztálya, amelyben a különböző csomópontok közötti kapcsolat irányított gráfot alkot, amely időbeli dinamikus viselkedést biztosít. Segít modellezni az előrecsatolt hálózatokból származó szekvenciális adatokat. Az emberi agyhoz hasonlóan működik, hogy prediktív eredményeket biztosítson.

Az ismétlődő neurális hálózat nagyon hasonlít egy hagyományos neurális hálózathoz, kivéve, hogy a neuronokhoz memóriaállapotot adnak. A memória számítása egyszerű.

Képzeljünk el egy egyszerű modellt, amelyben csak egyetlen neuron táplálkozik egy adathalmazzal. Egy hagyományos neurális hálózatban a modell a bemenet súllyal és aktivációs függvénnyel való szorzásával állítja elő a kimenetet. Egy RNN esetében ez a kimenet bizonyos számú alkalommal kerül visszaküldésre önmagához. Ezt hívjuk időlépés az az időtartam, amely alatt a kimenet a következő mátrixszorzás bemenetévé válik.

Például az alábbi képen láthatja, hogy a hálózat egy neuronból áll. A hálózat kiszámítja a mátrixok szorzatát a bemenet és a súly között, és nemlinearitást ad hozzá az aktiváló függvénnyel. Ez lesz a t-1 kimenete. Ez a kimenet a második mátrixszorzás bemenete.

Ismétlődő neurális hálózat (RNN)

Az alábbiakban egy egyszerű RNN-t kódolunk a TensorFlow-ban, hogy megértsük a lépést és a kimenet alakját.

A hálózat a következőkből áll:

• Négy bemenet
• Hat neuron
• 2-szeres lépések

A hálózat az alábbi képen látható módon fog működni.

A hálózatot „visszatérőnek” nevezik, mert ugyanazt a műveletet hajtja végre minden aktiválási négyzetben. A hálózat kiszámította a bemenetek és az előző kimenet súlyát, mielőtt aktiváló funkciót használt volna.

Verzió megjegyzés: Az ebben az oktatóanyagban található kód a TensorFlow 1.x gráf API-t célozza meg. A TensorFlow 2.x-en ugyanaz a szkript továbbra is lefut a következő verzió után is. import tensorflow.compat.v1 as tf plusz tf.disable_v2_behavior(), mivel a helyőrzők, munkamenetek és az rnn_cell modul mostantól a tf.compat.v1A 2.x nyelvtani megfelelője a következő: 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
    ])

A hálózatot az adatok, az ismétlődő szakasz és a kimenet helyőrzőjével építhetjük fel.

Határozza meg az adatok helyőrzőjét

X = tf.placeholder(tf.float32, [None, n_timesteps, n_inputs])

Itt:

• Nincs: Ismeretlen, és a köteg méretét veszi fel
• n_timesteps: Ahányszor a hálózat visszaküldi a kimenetet a neuronnak
• n_inputs: A kötegenkénti bemenetek száma

Határozza meg az ismétlődő hálózatot

Ahogy a fenti képen is említettük, a hálózat 6 neuronból áll. A hálózat kétpontos szorzatot számít ki:

• Bemeneti adatok az első súlykészlettel (azaz 6: egyenlő a neuronok számával)
• Előző kimenet egy második súlyozási készlettel (azaz 6: a kimenetek számának megfelelően)

Ne feledje, hogy az első előrecsatolás során az előző kimenet értékei nullákkal egyenlőek, mert nincs elérhető értékünk.

Az RNN létrehozásának objektuma a tf.contrib.rnn.BasicRNNCell a num_units argumentumával a bemenetek számának meghatározásához

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=n_neurons)

Most, hogy a hálózat definiálva van, kiszámíthatja a kimeneteket és az állapotokat

outputs, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)

Ez az objektum egy belső hurkot használ a mátrixok megfelelő számú szorzására.

Megjegyzendő, hogy a rekurrens neuron az előző időlépések összes bemenetének függvénye. Így építi fel a hálózat a saját memóriáját. Az előző időpontból származó információ terjedhet a jövőben. Ez a rekurrens neurális hálózat varázsa.

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

Szemléltetésképpen kinyomtatjuk az előző állapot értékeit. A fent kinyomtatott kimenet az utolsó állapot kimenetét mutatja. Most nyomtassa ki az összes kimenetet, látható, hogy az állapotok az egyes kötegek előző kimenetei. Vagyis az előző kimenet tartalmazza a teljes sorozatra vonatkozó információkat.

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)

Az alábbi, jegyzetekkel ellátott nézet ugyanazt a nyomtatott tenzort bontja le kötegenként.

A kimenet alakja (3, 2, 6):

• 3: A tételek száma
• 2: Az időlépés száma
• 6: Neuronok száma

Az ismétlődő neurális hálózat optimalizálása megegyezik a hagyományos neurális hálózatéval. A Recurrent Neural Network oktatóanyag következő részében részletesebben megtudhatja, hogyan kell kódolni az optimalizálást.

Az RNN alkalmazásai

Az RNN-nek többféle felhasználása is van, különösen a jövő előrejelzésében. A pénzügyi szektorban az RNN hasznos lehet a részvényárfolyamok vagy a tőzsdei irány (azaz pozitív vagy negatív) előrejelzésében.

Az RNN hasznos az autonóm autók számára, mivel a jármű röppályájának előrejelzésével elkerülheti az autóbaleseteket.

Az RNN-t széles körben használják szövegelemzésben, képaláírásban, hangulatelemzésben és gépi fordításban. Használhat például egy filmkritikát, hogy megértse, milyen érzést észlel a néző a film megtekintése után. A feladat automatizálása nagyon hasznos, ha a filmgyártó cégnek nincs elég ideje a vélemények áttekintésére, címkézésére, összevonására és elemzésére. A gép nagyobb pontossággal tudja elvégezni a munkát.

Az RNN korlátai

Elméletileg az RNN-nek el kell vinnie az információkat időkig. Azonban meglehetősen nehéz mindezt az információt terjeszteni, ha az időlépés túl hosszú. Ha egy hálózatnak túl sok mély rétege van, képtelenné válik. Ezt a problémát úgy hívják: eltűnő gradiens probléma. Ha emlékszel, a neurális hálózat frissíti a súlyt a gradiens süllyedés algoritmusával. A színátmenetek kisebbek lesznek, amikor a hálózat az alacsonyabb rétegek felé halad.

Összefoglalva, a gradiensek állandóak maradnak, ami azt jelenti, hogy nincs lehetőség a fejlesztésre. A modell tanul a gradiens változásából; ez a változás befolyásolja a hálózat kimenetét. Ha azonban a gradiens különbsége túl kicsi (azaz a súlyok kicsit változnak), a hálózat nem tud semmit tanulni, és így a kimenet sem. Ezért egy eltűnő gradiens problémával szembesülő hálózat nem tud egy jó megoldás felé konvergálni.

LSTM fejlesztés

Az RNN által tapasztalt eltűnő gradiens problémájának leküzdésére három kutató, Hochreiter, Schmidhuber és Bengio továbbfejlesztette az RNN-t egy hosszú rövid távú memória (LSTM) architektúrával. Röviden, az LSTM releváns múltbeli információkat szolgáltat a hálózatnak a közelmúltig. A gép egy jobb architektúrát használ az információk kiválasztására és későbbi időpontra való visszavezetésére.

Az LSTM architektúra elérhető a TensorFlow-ban, tf.contrib.rnn.LSTMCell címen. Az LSTM nem tartozik a bemutató keretei közé. További információért tekintse meg a hivatalos dokumentáció További információ

A TensorFlow 2.x-en ezt a cellát a következőképpen érjük el: tf.compat.v1.nn.rnn_cell.LSTMCell, míg az új kód általában a következőt használja: tf.keras.layers.LSTM vagy a könnyebben záródó tf.keras.layers.GRU, amely kevesebb paraméterrel ér el hasonló pontosságot.

RNN idősorokban

Ebben a TensorFlow RNN oktatóanyagban idősoros adatokkal rendelkező RNN-t fogsz használni. Az idősorok az előző időponttól függenek, ami azt jelenti, hogy a múltbeli értékek releváns információkat tartalmaznak, amelyekből a hálózat tanulhat. Az idősor-előrejelzés mögött az a gondolat áll, hogy megbecsüljük egy sorozat jövőbeli értékét, mondjuk a részvényárfolyamot, a hőmérsékletet, a GDP-t stb.

A Keras RNN és ​​az idősorok adatainak előkészítése kissé bonyolult lehet. Mindenekelőtt a sorozat következő értékének megjóslása a cél, vagyis a múltbeli információkat fogja használni a t + 1 érték becslésére. A címke megegyezik a bemeneti sorozattal, és egy periódussal előre van tolva. Másodszor, a bemenetek száma 1-re van állítva, azaz időnként egy megfigyelés. Végül az időlépés megegyezik a számérték sorozatával. Például, ha az időlépést 10-re állítja, a beviteli sorozat tíz egymást követő alkalommal tér vissza.

Nézze meg az alábbi grafikont, a bal oldalon az idősorok adatait, a jobb oldalon pedig egy fiktív bemeneti sorozatot ábrázoltunk. Létrehoz egy függvényt, amely 2001 januárja és 2016 decembere között minden napra véletlen értékű adatkészletet ad vissza.

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

teljesítmény

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

A grafikon jobb oldala az összes idősort mutatja. 2001-től indult és 2019-ig tart. Nincs értelme az összes adatot betáplálni a hálózatba, ehelyett egy olyan adathalmazt kell létrehozni, amelynek hossza megegyezik az időlépéssel. Ez a köteg lesz az X változó. Az Y változó megegyezik X-szel, de egy periódussal el van tolva (azaz a t+1-et szeretné előrejelezni).

Mindkét vektor azonos hosszúságú. A fenti grafikon jobb oldalán láthatja. A vonal az X bemenet tíz értékét jelöli, míg a piros pontok az Y címke tíz értékét jelentik. Vegye figyelembe, hogy a címke egy ponttal X előtt kezdődik és egy ponttal utána ér véget.

Hozzon létre egy RNN-t az idősorok előrejelzéséhez a TensorFlow-ban

Most ebben az RNN képzésben itt az ideje, hogy megépítse az első RNN-t a fenti sorozat előrejelzéséhez. A modellhez meg kell adni néhány hiperparamétert (a modell paramétereit, azaz a neuronok számát stb.):

• Bemenetek száma: 1
• Időlépés (ablakok az idősorokban): 10
• Neuronok száma: 120
• Kimenetek száma: 1

A hálózatod egy 10 napos sorozatból fog tanulni, és 120 visszatérő neuront tartalmaz. A modellt egyetlen bemenettel táplálod, azaz egy nappal. Nyugodtan módosítsd az értékeket, hogy lásd, javult-e a modell.

A modell felépítése előtt fel kell osztani az adathalmazt egy sorozathalmazra és egy teszthalmazra. A teljes adathalmaz 222 adatpontot tartalmaz; az első 201 pontot a modell betanítására, a fennmaradó 21 pontot pedig a modell tesztelésére fogod használni.

Miután definiált egy vonatot és egy teszthalmazt, létre kell hoznia egy objektumot, amely a kötegeket tartalmazza. Ezekben a kötegekben X és Y értékek vannak. Ne feledje, hogy az X értékek egy periódussal késleltetettek. Ezért az első 200 megfigyelést használja, és az időlépés egyenlő 10-zel. Az X_batches objektumnak 20 darab, 10*1 méretű köteget kell tartalmaznia. Az y_batches alakja megegyezik az X_batches objektum alakjával, de egy periódussal előrébb van.

Step 1) Hozd létre a vonatot és teszteld

Először is konvertálja a sorozatot a numpy sor; majd meghatározza az ablakokat (azaz hány időből tanul a hálózat), a bemenetek, a kimenetek számát és a vonatkészlet méretét, ahogy az alábbi TensorFlow RNN példában látható.

series = np.array(ts)
n_windows = 20   
n_input =  1
n_output = 1
size_train = 201

Ezt követően egyszerűen fel kell osztani a tömböt két adatkészletre.

## Split data
train = series[:size_train]
test = series[size_train:]
print(train.shape, test.shape)
(201,) (21,)

Step 2) Hozzon létre egy függvényt az X_batches és y_batches visszaadásához

Az egyszerűség érdekében létrehozhat egy függvényt, amely két különböző tömböt ad vissza, egyet az X_batches és egyet az y_batches számára.

Írjunk egy RNN TensorFlow függvényt a kötegek összeállításához.

Vegye figyelembe, hogy az X kötegek egy periódussal késtek (t-1 értéket veszünk). A függvény kimenetének háromdimenziósnak kell lennie. Az első méret megegyezik a kötegek számával, a második az ablakok méretével, az utolsó pedig a bemenetek számával.

A trükkös rész az adatpontok helyes kiválasztása. Az X adatpontoknál a megfigyeléseket t = 1 és t = 200 között választja ki, míg az Y adatpontnál a megfigyeléseket t = 2-től 201-ig adja vissza. Ha megvannak a megfelelő adatpontok, egyszerű az átformálás. a sorozat.

Az objektum kötegekkel való létrehozásához fel kell osztania az adatkészletet tíz egyenlő hosszúságú kötegre (azaz 20-ra). Használhatja az átformálás módszerét, és átadhatja a -1-et, hogy a sorozat hasonló legyen a köteg méretéhez. A 20-as érték a kötegenkénti megfigyelések száma, az 1 pedig a bemenetek száma.

Ugyanezt a lépést kell végrehajtania, csak a címkénél.

Vegye figyelembe, hogy az adatokat annyiszor kell eltolni, ahányszor előre szeretné jelezni. Például, ha egy időpontot előre szeretne jelezni, akkor 1-gyel kell eltolni az adatsort. Ha két napra szeretne előrejelezni, akkor 2-vel kell eltolni az adatokat.

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

Most, hogy a függvény definiálva van, meghívhatja a kötegek létrehozásához az alábbi RNN-példa szerint.

X_batches, y_batches = create_batches(df = train,
                                      windows = n_windows,
                                      input = n_input,
                                      output = n_output)

Kinyomtathatja az alakzatot, hogy megbizonyosodjon a méretek helyességéről.

print(X_batches.shape, y_batches.shape)
(10, 20, 1) (10, 20, 1)

Csak egy köteg adatot és 20 megfigyelést tartalmazó tesztkészletet kell létrehoznia.

Vegye figyelembe, hogy napról napra előrejelezve azt jelenti, hogy a második előre jelzett érték a tesztadatkészlet első napjának valós értékén (t+1) fog alapulni. Valójában a valódi érték is ismert lesz.

Ha t+2-re (azaz két nappal előre) akar előre jelezni, akkor a t+1 előrejelzett értéket kell használnia; ha t+3-at (három nappal előre) akar megjósolni, akkor a t+1 és t+2 előrejelzett értéket kell használnia. Érthető, hogy t+n napra előre nehéz pontosan megjósolni.

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)

Rendben, a kötegméret készen áll, megépítheti az RNN architektúrát. Ne feledje, 120 visszatérő idegsejtje van.

Step 3) Építsd meg a modellt

A modell létrehozásához három részt kell meghatároznia:

1. A változó a tenzorokkal
2. Az RNN
3. A veszteség és az optimalizálás

Step 3.1) Változók

Meg kell adni az X és y változókat a megfelelő alakzattal. Ez a lépés triviális. A tenzor mérete megegyezik az X_batches és y_batches objektumokkal.

Például az X tenzor egy helyőrző (lásd a bemutatót a Bevezetés a TensorFlow-ba hogy felfrissítse gondolatait a változók deklarációjával kapcsolatban) három dimenziója van:

• Megjegyzés: a tétel mérete
• n_windows: Az ablakok hossza, azaz ahányszor a modell visszafelé néz.
• n_input: Bemenetek száma

Az eredmény:

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

Step 3.2) Hozza létre az RNN-t

Az RNN TensorFlow példa második részében meg kell határoznia a hálózat architektúráját. A korábbiakhoz hasonlóan a BasicRNNCell és a dynamic_rnn objektumot használja a TensorFlow becslőből.

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

A következő rész egy kicsit bonyolultabb, de gyorsabb számítást tesz lehetővé. Átalakítania kell a futtatási kimenetet sűrű réteggé, majd újra konvertálnia kell a bemenettel megegyező méretűre.

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

Step 3.3) Hozzon létre veszteséget és optimalizálást

A modell optimalizálása az elvégzendő feladattól függ. Az előző oktatóanyagban a következőről olvashat: CNN, a célod a képek osztályozása volt, ebben az RNN oktatóanyagban a cél kissé eltér. Arra kérnek, hogy egy folytonos változóra tegyel egy predikciót egy osztályhoz képest.

Ez a különbség azért fontos, mert megváltoztatja az optimalizálási problémát. A folytonos változó optimalizálási problémája az átlagos négyzetes hiba minimalizálása. Ezeknek a mérőszámoknak a TF-ben való összeállításához a következőket használhatja:

tf.reduce_sum(tf.square(kimenetek – y))

Az RNN kód fennmaradó része ugyanaz, mint korábban; Adam optimalizálót használ a veszteség csökkentésére (azaz MSE):

tf.train.AdamOptimizer(learning_rate=learning_rate)

optimizer.minimize(loss)

Ez az, mindent összepakolhatsz, és a modelled készen áll az edzésre.

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

A modellt 1500 epochával betanítja, és 150 iterációnként kinyomtatja a veszteséget. A modell betanítása után kiértékeli a modellt a tesztkészleten, és létrehoz egy objektumot, amely tartalmazza az előrejelzéseket, az alábbi példa szerint: Ismétlődő neurális hálózat.

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

Végre ebben az RNN Deep Learning oktatóanyagban ábrázolhatja a sorozat tényleges értékét az előrejelzett értékkel. Ha a modellt kijavítják, akkor az előrejelzett értékeket a tényleges értékek fölé kell helyezni.

Amint látható, a modellen van még mit fejleszteni. Rajtad múlik, hogy megváltoztatod-e a hiperparamétereket, például az ablakokat, a köteg méretét vagy a visszatérő neuronok számát.

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

Előrejelzés vs tényleges

GYIK