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 is relatief eenvoudig en gaat vooral over matrixvermenigvuldiging. Tijdens de eerste stap worden de inputs vermenigvuldigd met aanvankelijk willekeurige gewichten, en bias, getransformeerd met een activeringsfunctie, en worden de outputwaarden gebruikt om een ​​voorspelling te doen. Deze stap geeft een idee van hoe ver het netwerk verwijderd is van de realiteit.

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

De fout is gelukkig kleiner dan voorheen, maar toch niet klein genoeg. De optimalisatiestap wordt iteratief uitgevoerd totdat de fout geminimaliseerd is, dat wil zeggen dat er geen informatie meer kan worden geëxtraheerd.

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 op te lossen, is een nieuw type archiis ontwikkeld: Recurrent Neuraal netwerk (RNN hierna)

Wat is een terugkerend neuraal netwerk (RNN)?

A Terugkerend neuraal netwerk (RNN) is een klasse van Kunstmatig neuraal netwerk waarin de verbinding tussen verschillende knooppunten een gerichte grafiek vormt om een ​​temporeel dynamisch gedrag te geven. Het helpt bij het modelleren van sequentiële gegevens die zijn afgeleid van feedforward-netwerken. Het werkt op dezelfde manier als menselijke hersenen 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 waarin slechts één neuron wordt gevoed door een reeks gegevens. In een traditioneel neuraal net produceert het model de output door de input te vermenigvuldigen met het gewicht en de activeringsfunctie. Met een RNN wordt deze uitvoer een aantal keren naar zichzelf teruggestuurd. Wij bellen tijd stap de hoeveelheid tijd dat de uitvoer de invoer wordt van de volgende matricevermenigvuldiging.

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

Terugkerend neuraal netwerk (RNN)

Het netwerk wordt 'recurrent' genoemd omdat het hetzelfde presteert operain elk activeringsveld. Het netwerk berekende de gewichten van de invoer en de vorige uitvoer voordat een activeringsfunctie werd gebruikt.

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.

  1. 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
  1. 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 (dwz 6: komt overeen 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 het terugkerende neuron een functie is van alle input van de voorgaande tijdstappen. Dit is hoe het netwerk zijn eigen geheugen opbouwt. De informatie van de vorige keer kan zich in de toekomst verspreiden. Dit 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]]

Voor verklarende doeleinden drukt u de waarden van de vorige staat af. De hierboven afgedrukte uitvoer toont de uitvoer van de laatste status. Druk nu alle uitvoer af. U kunt zien dat de statussen de vorige uitvoer van elke batch zijn. Dat wil zeggen dat de vorige uitvoer de informatie over de gehele reeks bevat

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)

Terugkerend neuraal netwerk (RNN)

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 heeft invloed op de output van het netwerk. Als het verschil in de gradiënt echter te klein is (dat wil zeggen, de gewichten veranderen een beetje), kan het netwerk niets leren, en dus ook de output. Daarom kan een netwerk dat wordt geconfronteerd met een verdwijnend gradiëntprobleem niet convergeren naar een goede oplossing.

Verbetering LSTM

Om het potentiële probleem van de verdwijnende gradiënt waarmee RNN wordt geconfronteerd te overwinnen, hebben drie onderzoekers, Hochreiter, Schmidhuber en Bengio, de RNN verbeterd met een architechniek die het Lange Korte Termijn Geheugen (LSTM) wordt genoemd. Kortom, LSMT levert het netwerk relevante informatie uit het verleden tot recentere tijden. De machine gebruikt een betere architectuur om informatie te selecteren en naar terug te voeren later tijd.

LSTM architecture is beschikbaar in TensorFlow, tf.contrib.rnn.LSTMCell. LSTM valt buiten het bestek van de tutorial. U kunt de ambtenaar raadplegen documentatie voor meer informatie

RNN in tijdreeksen

In deze TensorFlow RNN-tutorial gebruikt u een RNN met tijdreeksgegevens. Tijdreeksen zijn afhankelijk van de vorige tijd, wat betekent dat waarden uit het verleden relevante informatie bevatten waar het netwerk van kan leren. Het idee achter het voorspellen van tijdreeksen is het schatten van de toekomstige waarde van een reeks, bijvoorbeeld de aandelenkoers, de temperatuur, het 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 zult gebruiken om de waarde op t + 1 te schatten. Het label is gelijk aan de invoerreeks en shiftéén periode vooruit. Ten tweede wordt het aantal invoer ingesteld op 1, dat wil zeggen één waarneming per keer. Tenslotte is de tijdstap gelijk aan de volgorde van de numerieke waarde. Als u bijvoorbeeld de tijdstap instelt op 10, keert de invoerreeks tien keer achter elkaar terug.

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

RNN in tijdreeksen

Het rechterdeel van de grafiek toont alle reeksen. Het begon in 2001 en eindigt in 2019. Het heeft geen zin om alle gegevens in het netwerk in te voeren; in plaats daarvan moet u een batch gegevens creëren met een lengte gelijk aan de tijdstap. Deze batch zal de X-variabele zijn. De Y-variabele is hetzelfde als X, maar shiftmet één periode (dat wil zeggen: u wilt 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
  • Tijd stap (windows in tijdreeksen): 10
  • Aantal neuronen: 120
  • Aantal uitgangen: 1

Je netwerk leert van een reeks van 10 dagen en bevat 120 terugkerende neuronen. U voedt het model met één invoer, dat wil zeggen één dag. U kunt de waarden gerust wijzigen om te zien of het model is verbeterd.

Voordat u het model gaat construeren, moet u de dataset opsplitsen in een treinset en een testset. De volledige dataset bevat 222 datapunten; u gebruikt de eerste 201 punten om het model te trainen en de laatste 21 punten om uw model te testen.

Nadat u een trein en testset hebt gedefinieerd, moet u een object maken dat de batches bevat. In deze batches heb je 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 X_batches-object moet 20 batches van grootte 10*1 bevatten. Het y_batches heeft dezelfde vorm als het X_batches-object, maar met één periode vooruit.

Stap 1) Maak de trein en test

Allereerst converteer je de reeks naar a numpy reeks; dan definieer je de windows (dwz het aantal keren dat het netwerk zal leren), het aantal input, output en de grootte van de treinset, zoals weergegeven in het TensorFlow RNN-voorbeeld hieronder.

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.

Merk op dat de X-batches één periode achterlopen (we nemen de waarde t-1). De uitvoer van de functie moet drie dimensies hebben. De eerste dimensie is gelijk aan het aantal batches, de tweede de grootte van de windows en als laatste het aantal invoer.

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 dit nodig is shift de gegevens tot het aantal keren dat u een voorspelling wilt doen. Als je bijvoorbeeld één keer vooruit wilt voorspellen, dan doe je dat shift de reeks met 1. Als u twee dagen wilt voorspellen, dan shift de gegevens door 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 bouwen archistructuur. 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 tijdelijke aanduiding (bekijk de tutorial over Inleiding tot tensorstroom 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 windows. dat wil zeggen, 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 archistructuur van het netwerk. Net als voorheen gebruikt u het object BasicRNNCell en dynamic_rnn uit de TensorFlow-schatter.

## 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 is afhankelijk van de taak die u uitvoert. In de vorige tutorial over CNN, het was je doel om afbeeldingen te classificeren. In deze RNN-tutorial is het doel iets anders. U wordt gevraagd een voorspelling te doen over een continue variabele die wordt vergeleken met 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 u kunt zien, is er ruimte voor verbetering in het model. Het is aan jou om de hyperparameters zoals de windows, de batchgrootte van 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

Voorspelling versus werkelijkheid

Samengevat

Een terugkerend neuraal netwerk is robuust architechniek om met tijdreeksen of tekstanalyse om te gaan. De uitvoer van de vorige toestand is feedback om het geheugen van het netwerk in de loop van de tijd of de reeks woorden te behouden.

In TensorFlow kunt u het volgende gebruikenwing codes om een ​​TensorFlow Recurrent Neural Network te trainen voor tijdreeksen:

Parameters van het model

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

Definieer het model

X = tf.placeholder(tf.float32, [None, n_windows, n_input])   
y = tf.placeholder(tf.float32, [None, n_windows, n_output])

basic_cell = tf.contrib.rnn.BasicRNNCell(num_units=r_neuron, activation=tf.nn.relu)   
rnn_output, states = tf.nn.dynamic_rnn(basic_cell, X, dtype=tf.float32)              

stacked_rnn_output = tf.reshape(rnn_output, [-1, r_neuron])          
stacked_outputs = tf.layers.dense(stacked_rnn_output, n_output)       
outputs = tf.reshape(stacked_outputs, [-1, n_windows, n_output])

Construeer de optimalisatie

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)                                          

Train het model

init = tf.global_variables_initializer() 
iteration = 1500 

with tf.Session() as sess:
    init.run()
    for iters in range(iteration):
        sess.run(training_op, feed_dict={X: X_batches, y: y_batches})
        if iters % 150 == 0:
            mse = loss.eval(feed_dict={X: X_batches, y: y_batches})
            print(iters, "\tMSE:", mse)
    
    y_pred = sess.run(outputs, feed_dict={X: X_test})