RNN (Recurrent Neural Network) zelfstudie: TensorFlow-voorbeeld

Waarom hebben we een terugkerend neuraal netwerk (RNN) nodig?

Met Recurrent Neural Network (RNN) kunt u geheugeneenheden modelleren om gegevens vast te houden en afhankelijkheden op de korte termijn te modelleren. Het wordt ook gebruikt bij tijdreeksvoorspellingen voor de identificatie van gegevenscorrelaties en patronen. Het helpt ook voorspellende resultaten te produceren voor sequentiële gegevens door vergelijkbaar gedrag te vertonen als het menselijk brein.

De structuur van een Kunstmatig neuraal netwerk Het is relatief eenvoudig en draait voornamelijk om matrixvermenigvuldiging. Tijdens de eerste stap worden de invoerwaarden vermenigvuldigd met aanvankelijk willekeurige gewichten en bias, getransformeerd met een activeringsfunctie, en de uitvoerwaarden worden gebruikt om een ​​voorspelling te doen. Deze stap geeft een idee van hoe ver het netwerk van de werkelijkheid verwijderd is.

De toegepaste metriek is het verlies. Hoe hoger de verliesfunctie, hoe dommer het model is. Om de kennis van het netwerk te verbeteren, is enige optimalisatie vereist door de gewichten van het net aan te passen. De stochastische gradiëntafdaling is de methode die wordt gebruikt om de waarden van de gewichten in de juiste richting te wijzigen. Zodra de aanpassing is gemaakt, kan het netwerk een andere batch gegevens gebruiken om zijn nieuwe kennis te testen.

De fout is gelukkig kleiner dan voorheen, maar nog niet klein genoeg. De optimalisatiestap wordt iteratief uitgevoerd totdat de fout geminimaliseerd is, d.w.z. er kan geen informatie meer worden geëxtraheerd.tracted.

Het probleem met dit type model is dat het geen geheugen heeft. Het betekent dat de input en output onafhankelijk zijn. Met andere woorden: het model geeft niets om wat er eerder gebeurde. Het roept enige vraag op wanneer je tijdreeksen of zinnen moet voorspellen, omdat het netwerk informatie nodig heeft over de historische gegevens of woorden uit het verleden.

Om dit probleem te overwinnen is een nieuw type architectuur ontwikkeld: Recurrent Neural Network (hierna RNN)

Wat is een terugkerend neuraal netwerk (RNN)?

Een terugkerend neuraal netwerk (RNN) is een type kunstmatig neuraal netwerk waarbij de verbindingen tussen verschillende knooppunten een gerichte graaf vormen die een dynamisch gedrag in de tijd beschrijft. Het helpt bij het modelleren van sequentiële data die afkomstig zijn van feedforward-netwerken. Het werkt op een vergelijkbare manier als het menselijk brein om voorspellende resultaten te leveren.

Een terugkerend neuraal netwerk lijkt behoorlijk op een traditioneel neuraal netwerk, behalve dat er een geheugenstatus aan de neuronen wordt toegevoegd. De berekening om een ​​geheugen op te nemen is eenvoudig.

Stel je een eenvoudig model voor met slechts één neuron dat een batch data ontvangt. In een traditioneel neuraal netwerk produceert het model de uitvoer door de invoer te vermenigvuldigen met het gewicht en de activeringsfunctie. Bij een RNN wordt deze uitvoer een aantal keren naar zichzelf teruggestuurd. We noemen dit een RNN. tijd stap De tijdsduur dat de uitvoer de invoer wordt voor de volgende matrixvermenigvuldiging.

In de onderstaande afbeelding kun je bijvoorbeeld zien dat het netwerk uit één neuron bestaat. Het netwerk berekent de vermenigvuldiging van de matrices tussen de invoer en het gewicht en voegt niet-lineariteit toe aan de activeringsfunctie. Het wordt de uitvoer op t-1. Deze uitvoer is de invoer van de tweede matrixvermenigvuldiging.

Terugkerend neuraal netwerk (RNN)

Hieronder coderen we een eenvoudige RNN in TensorFlow om de stap en ook de vorm van de uitvoer te begrijpen.

Het netwerk bestaat uit:

• Vier ingangen
• Zes neuronen
• 2-voudige stappen

Het netwerk zal verlopen zoals weergegeven in de onderstaande afbeelding.

Het netwerk wordt 'recurrent' genoemd omdat het dezelfde bewerking uitvoert in elk activeer vierkant. Het netwerk berekende de gewichten van de invoer en de vorige uitvoer voordat een activeringsfunctie werd gebruikt.

Versie-opmerking: De code in deze handleiding is gericht op de TensorFlow 1.x grafiek-API. Op TensorFlow 2.x werkt hetzelfde script nog steeds. import tensorflow.compat.v1 as tf plus tf.disable_v2_behavior(), omdat placeholders, sessies en de rnn_cell-module zich nu onder bevinden tf.compat.v1Het idiomatische 2.x-equivalent is 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
    ])

We kunnen het netwerk bouwen met een tijdelijke aanduiding voor de gegevens, de terugkerende fase en de uitvoer.

Definieer de tijdelijke aanduiding voor de gegevens

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

Hier:

• Geen: Onbekend en zal de grootte van de batch aannemen
• n_timesteps: Aantal keren dat het netwerk de uitvoer terugstuurt naar het neuron
• n_inputs: Aantal invoer per batch

Definieer het terugkerende netwerk

Zoals vermeld in de afbeelding hierboven, bestaat het netwerk uit 6 neuronen. Het netwerk berekent een tweepuntsproduct:

• Voer gegevens in met de eerste set gewichten (dwz 6: gelijk aan het aantal neuronen)
• Vorige uitvoer met een tweede set gewichten (d.w.z. 6: overeenkomend met het aantal uitvoer)

Merk op dat tijdens de eerste feedforward de waarden van de vorige uitvoer gelijk zijn aan nullen, omdat we geen enkele waarde beschikbaar hebben.

Het object om een ​​RNN te bouwen is tf.contrib.rnn.BasicRNNCell met het argument num_units om het aantal invoer te definiëren

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

Nu het netwerk is gedefinieerd, kunt u de uitgangen en statussen berekenen

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

Dit object gebruikt een interne lus om de matrices het juiste aantal keren te vermenigvuldigen.

Merk op dat de terugkerende neuron een functie is van alle inputs van de voorgaande tijdstappen. Zo bouwt het netwerk zijn eigen geheugen op. De informatie van de vorige tijd kan zich voortplanten naar toekomstige tijdstappen. Dat is de magie van een terugkerend neuraal netwerk.

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

Ter verduidelijking print u de waarden van de vorige toestand. De bovenstaande uitvoer toont de uitvoer van de laatste toestand. Print nu alle uitvoer; u zult zien dat de toestanden de vorige uitvoer van elke reeks zijn. Dat wil zeggen, de vorige uitvoer bevat informatie over de hele reeks.

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)

De onderstaande geannoteerde weergave splitst dezelfde afgedrukte tensor batch voor batch op.

De uitvoer heeft de vorm van (3, 2, 6):

• 3: Aantal batches
• 2: Nummer van de tijdstap
• 6: Aantal neuronen

De optimalisatie van een recurrent neuraal netwerk is identiek aan een traditioneel neuraal netwerk. U zult in meer detail zien hoe u optimalisatie kunt coderen in het volgende deel van deze Recurrent Neural Network-tutorial.

Toepassingen van RNN

RNN heeft meerdere toepassingen, vooral als het gaat om het voorspellen van de toekomst. In de financiële sector kan RNN nuttig zijn bij het voorspellen van aandelenkoersen of het teken van de richting van de aandelenmarkt (positief of negatief).

RNN is nuttig voor een autonome auto, omdat het een auto-ongeluk kan vermijden door te anticiperen op het traject van het voertuig.

RNN wordt veel gebruikt bij tekstanalyse, ondertiteling van afbeeldingen, sentimentanalyse en automatische vertaling. Je kunt bijvoorbeeld een filmrecensie gebruiken om inzicht te krijgen in het gevoel dat de toeschouwer ervaart na het bekijken van de film. Het automatiseren van deze taak is erg handig als de filmmaatschappij niet genoeg tijd heeft om de recensies te beoordelen, labelen, consolideren en analyseren. De machine kan het werk met een hogere nauwkeurigheid doen.

Beperkingen van RNN

In theorie wordt RNN verondersteld de informatie actueel te houden. Het is echter een behoorlijke uitdaging om al deze informatie te verspreiden als de tijdstap te lang is. Wanneer een netwerk te veel diepe lagen heeft, wordt het ontrainbaar. Dit probleem heet: verdwijnend gradiëntprobleem. Weet je nog, het neurale netwerk werkt het gewicht bij met behulp van het gradiënt-afdalingsalgoritme. De gradiënten worden kleiner naarmate het netwerk zich naar lagere lagen verplaatst.

Kortom, de gradiënten blijven constant, wat betekent dat er geen ruimte is voor verbetering. Het model leert van een verandering in de gradiënt; deze verandering beïnvloedt de uitvoer van het netwerk. Als het verschil in de gradiënt echter te klein is (d.w.z. de gewichten veranderen weinig), kan het netwerk niets leren en dus ook de uitvoer niet. Daarom kan een netwerk dat te maken heeft met een verdwijnende gradiënt niet convergeren naar een goede oplossing.

Verbetering LSTM

Om het potentiële probleem van de verdwijnende gradiënt bij RNN's te overwinnen, hebben drie onderzoekers, Hochreiter, Schmidhuber en Bengio, de RNN verbeterd met een architectuur genaamd Long Short-Term Memory (LSTM). Kort gezegd voorziet LSTM het netwerk van relevante informatie uit het verleden naar recentere tijden. De machine gebruikt een betere architectuur om informatie te selecteren en terug te transporteren naar latere tijden.

De LSTM-architectuur is beschikbaar in TensorFlow, tf.contrib.rnn.LSTMCell. LSTM valt buiten het bestek van deze handleiding. Raadpleeg de officiële documentatie voor meer informatie. documentatie voor meer informatie

In TensorFlow 2.x wordt die cel bereikt als tf.compat.v1.nn.rnn_cell.LSTMCell, terwijl nieuwe code normaal gesproken gebruikmaakt van tf.keras.layers.LSTM of de lichtere gated tf.keras.layers.GRU, wat een vergelijkbare nauwkeurigheid oplevert met minder parameters.

RNN in tijdreeksen

In deze TensorFlow RNN-tutorial leer je hoe je een RNN gebruikt met tijdreeksgegevens. Tijdreeksen zijn afhankelijk van eerdere tijden, wat betekent dat waarden uit het verleden relevante informatie bevatten waar het netwerk van kan leren. Het idee achter tijdreeksvoorspelling is om de toekomstige waarde van een reeks te schatten, bijvoorbeeld een aandelenkoers, temperatuur, bbp, enzovoort.

De gegevensvoorbereiding voor Keras RNN en tijdreeksen kan een beetje lastig zijn. Allereerst is het doel om de volgende waarde van de reeks te voorspellen, wat betekent dat u de informatie uit het verleden gebruikt om de waarde op t + 1 te schatten. Het label is gelijk aan de invoerreeks en één periode vooruitgeschoven. Ten tweede wordt het aantal invoer ingesteld op 1, d.w.z. één observatie per keer. Ten slotte is de tijdstap gelijk aan de reeks van de numerieke waarde. Als u bijvoorbeeld de tijdstap instelt op 10, retourneert de invoerreeks tien opeenvolgende keren.

Kijk naar de onderstaande grafiek. We hebben de tijdreeksgegevens aan de linkerkant weergegeven en een fictieve invoerreeks aan de rechterkant. U maakt een functie om voor elke dag van januari 2001 tot december 2016 een gegevensset met willekeurige waarde te retourneren

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

uitgang

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

Het rechterdeel van de grafiek toont alle reeksen. Deze begon in 2001 en eindigt in 2019. Het heeft geen zin om alle gegevens in het netwerk te stoppen; in plaats daarvan moet je een batch gegevens creëren met een lengte gelijk aan de tijdstap. Deze batch is de X-variabele. De Y-variabele is hetzelfde als X, maar dan verschoven met één periode (je wilt dus t+1 voorspellen).

Beide vectoren hebben dezelfde lengte. Je kunt het zien in het rechtergedeelte van de bovenstaande grafiek. De lijn vertegenwoordigt de tien waarden van de X-invoer, terwijl de rode stippen de tien waarden zijn van het label Y. Merk op dat het label één periode vóór X begint en één periode later eindigt.

Bouw een RNN om tijdreeksen in TensorFlow te voorspellen

In deze RNN-training is het nu tijd om je eerste RNN te bouwen om de bovenstaande reeksen te voorspellen. U moet enkele hyperparameters (de parameters van het model, dat wil zeggen het aantal neuronen, enz.) voor het model specificeren:

• Aantal ingangen: 1
• Tijdstap (vensters in tijdreeks): 10
• Aantal neuronen: 120
• Aantal uitgangen: 1

Je netwerk leert van een reeks van 10 dagen en bevat 120 terugkerende neuronen. Je voert het model één invoer in, namelijk één dag. Je kunt de waarden gerust aanpassen om te zien of het model verbetert.

Voordat je het model bouwt, moet je de dataset opsplitsen in een trainingsset en een testset. De volledige dataset bevat 222 datapunten; je gebruikt de eerste 201 punten om het model te trainen en de laatste 21 punten om je model te testen.

Nadat je een trainings- en testset hebt gedefinieerd, moet je een object maken dat de batches bevat. Deze batches bevatten X-waarden en Y-waarden. Houd er rekening mee dat de X-waarden één periode vertraagd zijn. Daarom gebruik je de eerste 200 waarnemingen en is de tijdstap gelijk aan 10. Het object X_batches moet 20 batches van grootte 10*1 bevatten. Het object y_batches heeft dezelfde vorm als het object X_batches, maar met één periode vooruit.

Stap 1) Maak de trein en test

Allereerst converteer je de reeks naar a NumPy array; vervolgens definieert u de vensters (d.w.z. het aantal keer dat het netwerk zal leren), het aantal invoer, uitvoer en de grootte van de treinset zoals getoond in het onderstaande TensorFlow RNN-voorbeeld.

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

Daarna splitst u de array eenvoudig in twee datasets.

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

Stap 2) Maak de functie om X_batches en y_batches te retourneren

Om het eenvoudiger te maken, kunt u een functie maken die twee verschillende arrays retourneert, één voor X_batches en één voor y_batches.

Laten we een RNN TensorFlow-functie schrijven om de batches samen te stellen.

Let op dat de X batches één periode achterlopen (we nemen waarde t-1). De output van de functie moet drie dimensies hebben. De eerste dimensies zijn gelijk aan het aantal batches, de tweede aan de grootte van de vensters en de laatste aan het aantal inputs.

Het lastige is om de datapunten correct te selecteren. Voor de X-gegevenspunten kiest u de waarnemingen van t = 1 tot t = 200, terwijl u voor het Y-gegevenspunt de waarnemingen retourneert van t = 2 tot 201. Zodra u over de juiste gegevenspunten beschikt, is het eenvoudig om deze opnieuw vorm te geven de series.

Om het object met de batches te construeren, moet u de dataset opsplitsen in tien batches van gelijke lengte (dwz 20). U kunt de reshape-methode gebruiken en -1 doorgeven, zodat de serie vergelijkbaar is met de batchgrootte. De waarde 20 is het aantal waarnemingen per batch en 1 is het aantal input.

U moet dezelfde stap uitvoeren, maar dan voor het label.

Houd er rekening mee dat u de gegevens moet verschuiven met het aantal keren dat u wilt voorspellen. Als u bijvoorbeeld één dag vooruit wilt voorspellen, verschuift u de reeks met 1. Als u twee dagen vooruit wilt voorspellen, verschuift u de gegevens met 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

Nu de functie is gedefinieerd, kunt u deze aanroepen om de batches te maken, zoals weergegeven in het onderstaande RNN-voorbeeld.

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

U kunt de vorm afdrukken om er zeker van te zijn dat de afmetingen correct zijn.

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

U moet de testset maken met slechts één batch gegevens en twintig observaties.

Houd er rekening mee dat als u dagen na dagen voorspelt, dit betekent dat de tweede voorspelde waarde gebaseerd zal zijn op de werkelijke waarde van de eerste dag (t+1) van de testgegevensset. In feite zal de werkelijke waarde bekend zijn.

Als je t+2 wilt voorspellen (dus twee dagen vooruit), moet je de voorspelde waarde t+1 gebruiken; als je t+3 gaat voorspellen (drie dagen vooruit), moet je de voorspelde waarde t+1 en t+2 gebruiken. Het is logisch dat het moeilijk is om t+n dagen vooruit nauwkeurig te voorspellen.

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)

Oké, je batchgrootte is klaar, je kunt de RNN-architectuur bouwen. Vergeet niet dat je 120 terugkerende neuronen hebt.

Stap 3) Bouw het model

Om het model te maken, moet u drie onderdelen definiëren:

1. De variabele met de tensoren
2. De RNN
3. Het verlies en de optimalisatie

Stap 3.1) Variabelen

U moet de X- en y-variabelen met de juiste vorm opgeven. Deze stap is triviaal. De tensor heeft dezelfde dimensie als de objecten X_batches en y_batches.

De tensor X is bijvoorbeeld een placeholder (zie de handleiding op Inleiding tot TensorFlow om je gedachten over het declareren van variabelen op te frissen) heeft drie dimensies:

• Let op: omvang van de batch
• n_windows: Lengte van de vensters, oftewel het aantal keren dat het model achteruit kijkt.
• n_input: Aantal invoer

Het resultaat is:

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

Stap 3.2) Creëer de RNN

In het tweede deel van dit RNN TensorFlow-voorbeeld moet u de architectuur van het netwerk definiëren. Zoals eerder gebruikt u het object BasicRNNCell en dynamic_rnn van TensorFlow estimator.

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

Het volgende deel is iets lastiger, maar maakt een snellere berekening mogelijk. U moet de run-uitvoer transformeren naar een dichte laag en deze vervolgens opnieuw converteren om dezelfde dimensie te krijgen als de invoer.

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

Stap 3.3) Creëer het verlies en de optimalisatie

De modeloptimalisatie hangt af van de taak die u uitvoert. In de vorige tutorial over CNNIn de vorige tutorial was het je doel om afbeeldingen te classificeren, maar in deze RNN-tutorial is het doel iets anders. Je wordt gevraagd om een ​​voorspelling te doen op basis van een continue variabele in plaats van een klasse.

Dit verschil is belangrijk omdat het het optimalisatieprobleem zal veranderen. Het optimalisatieprobleem voor een continue variabele is het minimaliseren van de gemiddelde kwadratische fout. Om deze statistieken in TF samen te stellen, kunt u het volgende gebruiken:

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

De rest van de RNN-code is hetzelfde als voorheen; u gebruikt een Adam-optimalisatieprogramma om het verlies te verminderen (dwz MSE):

tf.train.AdamOptimizer(learning_rate=learning_rate)

optimizer.minimize(verlies)

Dat is alles, u kunt alles inpakken en uw model is klaar om te trainen.

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

Je traint het model met behulp van 1500 tijdperken en drukt het verlies elke 150 iteraties af. Zodra het model is getraind, evalueert u het model op de testset en maakt u een object met de voorspellingen, zoals weergegeven in het onderstaande Recurrent Neural Network-voorbeeld.

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

Eindelijk kunt u in deze RNN Deep Learning-tutorial de werkelijke waarde van de reeks uitzetten met de voorspelde waarde. Als uw model wordt gecorrigeerd, moeten de voorspelde waarden bovenop de werkelijke waarden worden geplaatst.

Zoals je ziet, is er nog ruimte voor verbetering in het model. Je kunt de hyperparameters aanpassen, zoals de venstergrootte, de batchgrootte of het aantal terugkerende neuronen.

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

Voorspelling versus werkelijkheid

Veelgestelde vragen