Tutoriel RNN (Recurrent Neural Network) : exemple TensorFlow

Pourquoi avons-nous besoin d’un réseau neuronal récurrent (RNN) ?

Le réseau neuronal récurrent (RNN) vous permet de modéliser des unités de mémoire pour conserver les données et modéliser les dépendances à court terme. Il est également utilisé dans la prévision de séries chronologiques pour l’identification de corrélations et de modèles de données. Il permet également de produire des résultats prédictifs pour les données séquentielles en offrant un comportement similaire à celui d'un cerveau humain.

La structure d'un réseau de neurones artificiels est relativement simple et concerne principalement la multiplication matricielle. Au cours de la première étape, les entrées sont multipliées par des poids initialement aléatoires, et le biais, transformé avec une fonction d'activation, et les valeurs de sortie sont utilisés pour faire une prédiction. Cette étape donne une idée de la distance entre le réseau et la réalité.

La métrique appliquée est la perte. Plus la fonction de perte est élevée, plus le modèle est stupide. Pour améliorer la connaissance du réseau, une certaine optimisation est nécessaire en ajustant les poids du réseau. La descente de gradient stochastique est la méthode utilisée pour modifier les valeurs des poids dans le bon sens. Une fois l’ajustement effectué, le réseau peut utiliser un autre lot de données pour tester ses nouvelles connaissances.

Heureusement, l’erreur est plus faible qu’auparavant, mais pas assez petite. L'étape d'optimisation est effectuée de manière itérative jusqu'à ce que l'erreur soit minimisée, c'est-à-dire qu'aucune information supplémentaire ne puisse être extraite.

Le problème avec ce type de modèle est qu’il n’a pas de mémoire. Cela signifie que l'entrée et la sortie sont indépendantes. En d’autres termes, le modèle ne se soucie pas de ce qui a précédé. Cela soulève des questions lorsque vous devez prédire des séries chronologiques ou des phrases, car le réseau a besoin d'informations sur les données historiques ou les mots passés.

Pour pallier ce problème, un nouveau type d'architecture a été développé : le réseau de neurones récurrents (RNN ci-après)

Qu'est-ce qu'un réseau neuronal récurrent (RNN) ?

A Réseau de neurones récurrents (RNN) est une classe de Réseau neuronal artificiel dans lequel la connexion entre différents nœuds forme un graphe orienté pour donner un comportement dynamique temporel. Il permet de modéliser des données séquentielles dérivées de réseaux à réaction. Il fonctionne de la même manière que le cerveau humain pour fournir des résultats prédictifs.

Un réseau neuronal récurrent ressemble beaucoup à un réseau neuronal traditionnel, sauf qu'un état mémoire est ajouté aux neurones. Le calcul pour inclure une mémoire est simple.

Imaginez un modèle simple avec un seul neurone alimenté par un lot de données. Dans un réseau neuronal traditionnel, le modèle produit la sortie en multipliant l'entrée par le poids et la fonction d'activation. Avec un RNN, cette sortie est renvoyée à elle-même un certain nombre de fois. Nous appelons pas de temps la durée pendant laquelle la sortie devient l'entrée de la prochaine multiplication matricielle.

Par exemple, dans l’image ci-dessous, vous pouvez voir que le réseau est composé d’un neurone. Le réseau calcule la multiplication matricielle entre l'entrée et le poids et ajoute de la non-linéarité avec la fonction d'activation. Cela devient la sortie à t-1. Cette sortie est l'entrée de la deuxième multiplication matricielle.

Ci-dessous, nous codons un simple RNN dans TensorFlow pour comprendre l'étape ainsi que la forme de la sortie.

Le réseau est composé de :

• Quatre entrées
• Six neurones
• 2 étapes

Le réseau fonctionnera comme le montre l'image ci-dessous.

Le réseau est dit « récurrent » car il effectue la même opération dans chaque case activée. Le réseau a calculé les poids des entrées et de la sortie précédente avant d'utiliser une fonction d'activation.

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

Nous pouvons construire le réseau avec un espace réservé pour les données, l'étape récurrente et le résultat.

1. Définir l'espace réservé pour les données

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

Ici:

• Aucun : Inconnu et prendra la taille du lot
• n_timesteps : nombre de fois que le réseau renverra la sortie au neurone
• n_inputs : nombre d'entrées par lot

2. Définir le réseau récurrent

Comme mentionné sur l'image ci-dessus, le réseau est composé de 6 neurones. Le réseau calculera deux produits scalaires :

• Données d'entrée avec le premier ensemble de poids (c'est-à-dire 6 : égal au nombre de neurones)
• Sortie précédente avec un deuxième ensemble de poids (soit 6 : correspondant au nombre de sorties)

Notez que, lors du premier feedforward, les valeurs de la sortie précédente sont égales à des zéros car nous n'avons aucune valeur disponible.

L'objet pour construire un RNN est tf.contrib.rnn.BasicRNNCell avec l'argument num_units pour définir le nombre d'entrées

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

Maintenant que le réseau est défini, vous pouvez calculer les sorties et les états

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

Cet objet utilise une boucle interne pour multiplier les matrices le nombre de fois approprié.

Notez que le neurone récurrent est fonction de toutes les entrées des pas de temps précédents. C'est ainsi que le réseau construit sa propre mémoire. Les informations du moment précédent peuvent se propager dans le futur. C'est la magie du réseau neuronal récurrent

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

À des fins explicatives, vous imprimez les valeurs de l’état précédent. La sortie imprimée ci-dessus montre la sortie du dernier état. Imprimez maintenant toute la sortie, vous pouvez remarquer que les états sont la sortie précédente de chaque lot. Autrement dit, la sortie précédente contient les informations sur la séquence entière.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)

La sortie a la forme de (3, 2, 6) :

• 3 : Nombre de lots
• 2 : Numéro du pas de temps
• 6 : Nombre de neurones

L'optimisation d'un réseau de neurones récurrent est identique à un réseau de neurones traditionnel. Vous verrez plus en détail comment coder l'optimisation dans la prochaine partie de ce tutoriel sur les réseaux de neurones récurrents.

Applications du RNN

RNN a de multiples utilisations, notamment lorsqu’il s’agit de prédire l’avenir. Dans le secteur financier, RNN peut être utile pour prédire les cours des actions ou le signe de la direction du marché boursier (c'est-à-dire positive ou négative).

Le RNN est utile pour une voiture autonome car il permet d’éviter un accident de voiture en anticipant la trajectoire du véhicule.

RNN est largement utilisé dans l’analyse de texte, le sous-titrage d’images, l’analyse des sentiments et la traduction automatique. Par exemple, on peut utiliser une critique de film pour comprendre le sentiment ressenti par le spectateur après avoir regardé le film. L'automatisation de cette tâche est très utile lorsque la société cinématographique ne dispose pas de suffisamment de temps pour réviser, étiqueter, consolider et analyser les critiques. La machine peut effectuer le travail avec un niveau de précision plus élevé.

Limites du RNN

En théorie, RNN est censé transporter les informations plusieurs fois. Cependant, il est assez difficile de propager toutes ces informations lorsque le pas de temps est trop long. Lorsqu’un réseau comporte trop de couches profondes, il devient impossible à entraîner. Ce problème s'appelle : problème de gradient en voie de disparition. Si vous vous en souvenez, le réseau neuronal met à jour le poids à l'aide de l'algorithme de descente de gradient. Les gradients diminuent à mesure que le réseau descend vers les couches inférieures.

En conclusion, les pentes restent constantes, ce qui signifie qu’il n’y a aucune marge d’amélioration. Le modèle apprend d'un changement de gradient ; ce changement affecte la production du réseau. Cependant, si la différence de gradient est trop petite (c'est-à-dire que les poids changent un peu), le réseau ne peut rien apprendre et donc la sortie. Par conséquent, un réseau confronté à un problème de gradient nul ne peut pas converger vers une bonne solution.

Amélioration LSTM

Pour surmonter le problème potentiel de disparition du gradient auquel est confronté le RNN, trois chercheurs, Hochreiter, Schmidhuber et Bengio, ont amélioré le RNN avec une architecture appelée Mémoire à long terme (LSTM). En bref, LSMT fournit au réseau des informations passées pertinentes sur des époques plus récentes. La machine utilise une meilleure architecture pour sélectionner et transporter les informations ultérieurement.

L'architecture LSTM est disponible dans TensorFlow, tf.contrib.rnn.LSTMCell. LSTM sort du cadre du didacticiel. Vous pouvez vous référer au fonctionnaire Documentation pour plus d'informations

RNN en séries chronologiques

Dans ce didacticiel TensorFlow RNN, vous utiliserez un RNN avec des données de séries chronologiques. Les séries chronologiques dépendent du temps précédent, ce qui signifie que les valeurs passées incluent des informations pertinentes dont le réseau peut tirer des leçons. L'idée derrière la prévision des séries chronologiques est d'estimer la valeur future d'une série, par exemple le cours de l'action, la température, le PIB, etc.

La préparation des données pour Keras RNN et les séries chronologiques peut être un peu délicate. Tout d'abord, l'objectif est de prédire la prochaine valeur de la série, ce qui signifie que vous utiliserez les informations passées pour estimer la valeur à t + 1. L'étiquette est égale à la séquence d'entrée et décalée d'une période en avant. Deuxièmement, le nombre d'entrées est fixé à 1, c'est-à-dire une observation par fois. Enfin, le pas de temps est égal à la séquence de la valeur numérique. Par exemple, si vous définissez le pas de temps sur 10, la séquence d'entrée sera renvoyée dix fois consécutives.

Regardez le graphique ci-dessous, nous avons représenté les données de la série chronologique à gauche et une séquence d'entrée fictive à droite. Vous créez une fonction pour renvoyer un ensemble de données avec une valeur aléatoire pour chaque jour de janvier 2001 à décembre 2016.

# To plot pretty figures
%matplotlib inline
import matplotlib
import matplotlib.pyplot as plt
import pandas as pd
def create_ts(start = '2001', n = 201, freq = 'M'):
    rng = pd.date_range(start=start, periods=n, freq=freq)
    ts = pd.Series(np.random.uniform(-18, 18, size=len(rng)), rng).cumsum()
    return ts
ts= create_ts(start = '2001', n = 192, freq = 'M')
ts.tail(5)

Sortie

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

La partie droite du graphique montre toutes les séries. Cela a commencé en 2001 et se termine en 2019. Cela n'a aucun sens d'alimenter toutes les données du réseau, vous devez plutôt créer un lot de données d'une longueur égale au pas de temps. Ce lot sera la variable X. La variable Y est la même que X mais décalée d'une période (c'est-à-dire que vous souhaitez prévoir t+1).

Les deux vecteurs ont la même longueur. Vous pouvez le voir dans la partie droite du graphique ci-dessus. La ligne représente les dix valeurs de l'entrée X, tandis que les points rouges sont les dix valeurs de l'étiquette, Y. Notez que l'étiquette commence une période avant X et se termine une période après.

Créer un RNN pour prédire des séries temporelles dans TensorFlow

Maintenant, dans cette formation RNN, il est temps de créer votre premier RNN pour prédire la série ci-dessus. Vous devez spécifier certains hyperparamètres (les paramètres du modèle, c'est-à-dire le nombre de neurones, etc.) pour le modèle :

• Nombre d'entrée : 1
• Pas de temps (fenêtres en séries temporelles) : 10
• Nombre de neurones : 120
• Nombre de sortie : 1

Votre réseau apprendra à partir d’une séquence de 10 jours et contiendra 120 neurones récurrents. Vous alimentez le modèle avec une seule entrée, c'est-à-dire un jour. N'hésitez pas à modifier les valeurs pour voir si le modèle s'est amélioré.

Avant de construire le modèle, vous devez diviser l'ensemble de données en une ensemble de trains et un ensemble de test. L'ensemble de données complet contient 222 points de données ; vous utiliserez les 201 premiers points pour entraîner le modèle et les 21 derniers points pour tester votre modèle.

Après avoir défini un ensemble d'entraînement et de test, vous devez créer un objet contenant les lots. Dans ces lots, vous avez des valeurs X et des valeurs Y. N'oubliez pas que les valeurs X sont décalées d'une période. Vous utilisez donc les 200 premières observations et le pas de temps est égal à 10. L'objet X_batches doit contenir 20 lots de taille 10*1. L'objet y_batches a la même forme que l'objet X_batches mais avec une période en avance.

Étape 1) Créer le train et tester

Tout d'abord, vous convertissez la série en un numpy tableau; Ensuite, vous définissez les fenêtres (c'est-à-dire le nombre de fois où le réseau apprendra), le nombre d'entrées, de sorties et la taille de la rame, comme indiqué dans l'exemple TensorFlow RNN ci-dessous.

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

Après cela, vous divisez simplement le tableau en deux ensembles de données.

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

Étape 2) Créez la fonction pour renvoyer X_batches et y_batches

Pour faciliter les choses, vous pouvez créer une fonction qui renvoie deux tableaux différents, un pour X_batches et un pour y_batches.

Écrivons une fonction RNN TensorFlow pour construire les lots.

A noter que les lots X sont décalés d'une période (on prend la valeur t-1). La sortie de la fonction doit avoir trois dimensions. Les premières dimensions sont égales au nombre de lots, la seconde à la taille des fenêtres et la dernière au nombre d'entrées.

La partie la plus délicate consiste à sélectionner correctement les points de données. Pour les points de données X, vous choisissez les observations de t = 1 à t = 200, tandis que pour le point de données Y, vous renvoyez les observations de t = 2 à 201. Une fois que vous avez les points de données corrects, il est simple de remodeler les séries.

Pour construire l'objet avec les lots, vous devez diviser l'ensemble de données en dix lots de longueur égale (c'est-à-dire 20). Vous pouvez utiliser la méthode reshape et transmettre -1 pour que la série soit similaire à la taille du lot. La valeur 20 est le nombre d'observations par lot et 1 est le nombre d'entrées.

Vous devez faire la même étape mais pour l’étiquette.

Notez que vous devez décaler les données du nombre de fois que vous souhaitez prévoir. Par exemple, si vous souhaitez prévoir une période à l'avance, vous décalez la série de 1. Si vous souhaitez prévoir deux jours, décalez les données de 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

Maintenant que la fonction est définie, vous pouvez l'appeler pour créer les lots comme indiqué dans l'exemple RNN ci-dessous.

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

Vous pouvez imprimer la forme pour vous assurer que les dimensions sont correctes.

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

Vous devez créer l'ensemble de test avec un seul lot de données et 20 observations.

Notez que si vous prévoyez jours après jours, cela signifie que la deuxième valeur prédite sera basée sur la valeur réelle du premier jour (t+1) de l'ensemble de données de test. En fait, la vraie valeur sera connue.

Si vous souhaitez prévoir t+2 (c'est-à-dire deux jours à l'avance), vous devez utiliser la valeur prédite t+1 ; si vous souhaitez prédire t+3 (trois jours à l'avance), vous devez utiliser les valeurs prédites t+1 et t+2. Il est logique qu’il soit difficile de prédire avec précision t+n jours à l’avance.

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)

Très bien, la taille de votre lot est prête, vous pouvez créer l'architecture RNN. N'oubliez pas que vous disposez de 120 neurones récurrents.

Étape 3) Construisez le modèle

Pour créer le modèle, vous devez définir trois parties :

1. La variable avec les tenseurs
2. Le RNN
3. La perte et l'optimisation

Étape 3.1) Variables

Vous devez spécifier les variables X et y avec la forme appropriée. Cette étape est triviale. Le tenseur a la même dimension que les objets X_batches et y_batches.

Par exemple, le tenseur X est un espace réservé (consultez le tutoriel sur Introduction à Tensorflow pour vous rafraîchir l'esprit sur la déclaration des variables) a trois dimensions :

• Remarque : taille du lot
• n_windows : Longueur des fenêtres. c'est-à-dire le nombre de fois où le modèle regarde en arrière
• n_input : nombre d'entrées

Le résultat est:

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

Étape 3.2) Créer le RNN

Dans la deuxième partie de cet exemple RNN TensorFlow, vous devez définir l'architecture du réseau. Comme auparavant, vous utilisez les objets BasicRNNCell et Dynamic_rnn de l'estimateur TensorFlow.

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

La partie suivante est un peu plus délicate mais permet un calcul plus rapide. Vous devez transformer la sortie de l'exécution en une couche dense, puis la convertir à nouveau pour avoir la même dimension que l'entrée.

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

Étape 3.3) Créer la perte et l'optimisation

L'optimisation du modèle dépend de la tâche que vous effectuez. Dans le tutoriel précédent sur CNN, votre objectif était de classer les images, dans ce tutoriel RNN, l'objectif est légèrement différent. Il vous est demandé de faire une prédiction sur une variable continue par rapport à une classe.

Cette différence est importante car elle va changer le problème d'optimisation. Le problème d'optimisation pour une variable continue est de minimiser l'erreur quadratique moyenne. Pour construire ces métriques dans TF, vous pouvez utiliser :

• tf.reduce_sum(tf.square(sorties – y))

Le reste du code RNN est le même qu’avant ; vous utilisez un optimiseur Adam pour réduire la perte (c'est-à-dire MSE) :

• tf.train.AdamOptimizer(learning_rate=learning_rate)
• optimiseur.minimiser (perte)

Voilà, vous pouvez tout emballer et votre modèle est prêt à s'entraîner.

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

Vous entraînerez le modèle en utilisant 1500 150 époques et imprimerez la perte toutes les itérations. Une fois le modèle entraîné, vous évaluez le modèle sur l'ensemble de test et créez un objet contenant les prédictions, comme indiqué dans l'exemple de réseau neuronal récurrent ci-dessous.

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

Enfin, dans ce didacticiel RNN Deep Learning, vous pouvez tracer la valeur réelle de la série avec la valeur prédite. Si votre modèle est corrigé, les valeurs prédites doivent être placées au-dessus des valeurs réelles.

Comme vous pouvez le constater, le modèle peut encore être amélioré. A vous de modifier les hyperparamètres comme les fenêtres, la taille du lot du nombre de neurones récurrents.

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

Résumé

Un réseau de neurones récurrent est une architecture robuste pour traiter des séries chronologiques ou des analyses de texte. La sortie de l'état précédent est un retour pour préserver la mémoire du réseau au fil du temps ou d'une séquence de mots.

Dans TensorFlow, vous pouvez utiliser les codes suivants pour entraîner un réseau neuronal récurrent TensorFlow pour les séries temporelles :

Paramètres du modèle

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

Définir le modèle

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

Construire l'optimisation

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)                                          

Former le modèle

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