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 mesterséges neurális hálózat felépítése viszonylag egyszerű, és főként mátrixszorzásról szól. Az első lépésben a bemeneteket kezdetben véletlenszerű súllyal szorozzuk meg, és a torzítást aktiváló függvénnyel transzformáljuk, és a kimeneti értékeket felhasználjuk az előrejelzéshez. 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, mégsem elég kicsi. Az optimalizálási lépés iteratív módon történik, amíg a hiba minimalizálódik, azaz nem lehet több információt kinyerni.

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 Ismétlődő neurális hálózat (RNN) osztálya Mesterséges neurális hálózat amelyben a különböző csomópontok közötti kapcsolat irányított gráfot képez, hogy időbeli dinamikus viselkedést adjon. Segít modellezni a szekvenciális adatokat, amelyek előrecsatolt hálózatokból származnak. Az emberi agyhoz hasonlóan működik, hogy előrejelző eredményeket adjon.

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 egy neuron táplál egy köteg adatot. A hagyományos neurális hálóban a modell úgy állítja elő a kimenetet, hogy a bemenetet megszorozza a súllyal és az aktiválási függvénnyel. Egy RNN esetén ez a kimenet annyi ideig kerül visszaküldésre önmagának. Hívjuk időlépés az az idő, ameddig 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.

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.

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.

1. 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

2. 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úlyké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.

Vegye figyelembe, hogy a visszatérő neuron az előző időlépések összes bemenetének függvénye. A hálózat így építi fel saját memóriáját. Az előző időpontból származó információ továbbterjedhet a jövőben is. Ez a visszatérő 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]]

Magyarázat céljából kinyomtatja az előző állapot értékeit. A fent nyomtatott kimenet az utolsó állapot kimenetét mutatja. Most nyomtassa ki az összes kimenetet, és észreveheti, hogy az állapotok az egyes kötegek előző kimenetei. Vagyis az előző kimenet tartalmazza a teljes sorozatra vonatkozó információkat.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)

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 hely a javításra. A modell a gradiens változásából tanul; ez a változás hatással van a hálózat kimenetére. Ha azonban a gradiens különbsége túl kicsi (azaz a súlyok egy kicsit változnak), a hálózat nem tud semmit megtanulni, így a kimenet sem. Ezért egy eltűnő gradiens problémával szembesülő hálózat nem tud jó megoldás felé konvergálni.

LSTM fejlesztés

Az RNN eltűnő gradiens potenciális problémájának megoldására három kutató, Hochreiter, Schmidhuber és Bengio az RNN-t a Long Short-Term Memory (LSTM) nevű architektúrával javította. Röviden, az LSMT releváns múltbeli információkat nyújt a hálózatnak az újabb időkre vonatkozóan. A gép jobb architektúrát használ az információk kiválasztására és későbbi időre való átvitelére.

Az LSTM architektúra a TensorFlow tf.contrib.rnn.LSTMCellben érhető el. Az LSTM nem tartozik az oktatóanyag hatókörébe. Lehet hivatkozni a tisztviselőre dokumentáció További információ

RNN idősorokban

Ebben a TensorFlow RNN oktatóanyagban egy RNN-t fog használni idősoros adatokkal. Az idősorok az előző időtő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 meghúzódó ötlet egy sorozat jövőbeli értékének becslése, mondjuk a részvényárfolyam, a hőmérséklet, a GDP és így tovább.

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 oldali része az összes sorozatot mutatja. 2001-től kezdődött és 2019-ben fejeződik be. Nincs értelme az összes adatot betáplálni a hálózaton, ehelyett létre kell hoznia egy köteget, amelynek hossza megegyezik az időlépéssel. Ez a köteg lesz az X változó. Az Y változó ugyanaz, mint az X, de egy periódussal eltolva (azaz t+1-et kíván előre jelezni).

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ózat 10 napos sorozatból tanul, és 120 visszatérő neuront tartalmaz. Egy bemenettel, azaz egy nappal táplálja a modellt. Nyugodtan változtassa meg az értékeket, hogy megnézze, javult-e a modell.

A modell elkészítése előtt fel kell osztania az adatkészletet egy vonatkészletre és egy tesztkészletre. A teljes adatkészlet 222 adatpontot tartalmaz; az első 201 pontot a modell betanítására, az utolsó 21 pontot pedig a modell tesztelésére fogja használni.

Miután meghatározta a vonat- és tesztkészletet, létre kell hoznia egy objektumot, amely tartalmazza a kötegeket. Ebben a kötegben 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 10. Az X_batches objektumnak 20 10*1 méretű köteget kell tartalmaznia. Az y_batches ugyanolyan alakú, mint az X_batches objektum, de egy ponttal előtte van.

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

Először is konvertálja a sorozatot a számtalan 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 eltolnia, ahányszor előre jelezni szeretné. Ha például egy időt szeretne előre jelezni, akkor 1-gyel tolja el a sorozatot. Ha két napot szeretne előre jelezni, akkor 2-vel tolja el 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ő (Nézze meg az oktatóanyagot a Bevezetés a tenzor áramlás 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 hányszor néz vissza a modell
• 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 Ön által végrehajtott feladattól függ. Az előző oktatóanyagban a CNN, az Ön célja a képek osztályozása volt, ebben az RNN oktatóanyagban a cél kissé eltérő. Megkérjük, hogy készítsen előrejelzést egy folytonos változóra 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 hova fejlődni. Rajtad múlik, hogy módosítsd a hiperparamétereket, például az ablakokat, az ismétlődő neuronok számának kötegméreté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()

Összegzésként

Az ismétlődő neurális hálózat robusztus architektúra az idősorok vagy szövegelemzések kezelésére. Az előző állapot kimenete visszacsatolás a hálózat memóriájának időbeli vagy szósorozatbeli megőrzése érdekében.

A TensorFlow-ban a következő kódokat használhatja a TensorFlow ismétlődő neurális hálózatok idősorokhoz való betanításához:

A modell paraméterei

n_windows = 20   
n_input =  1
n_output = 1
size_train = 201

Határozza meg a modellt

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

Készítse el az optimalizációt

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)                                          

Tanítsd meg a modellt

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