Série chronologique - Modèle LSTM

Maintenant, nous sommes familiers avec la modélisation statistique sur des séries chronologiques, mais l'apprentissage automatique est à la mode en ce moment, il est donc essentiel de se familiariser avec certains modèles d'apprentissage automatique. Nous commencerons par le modèle le plus populaire dans le domaine des séries temporelles - le modèle de mémoire à long court terme.

LSTM est une classe de réseau neuronal récurrent. Donc, avant de pouvoir passer au LSTM, il est essentiel de comprendre les réseaux de neurones et les réseaux de neurones récurrents.

Les réseaux de neurones

Un réseau de neurones artificiels est une structure en couches de neurones connectés, inspirée des réseaux de neurones biologiques. Ce n'est pas un algorithme mais des combinaisons de divers algorithmes qui nous permettent d'effectuer des opérations complexes sur des données.

Réseaux de neurones récurrents

C'est une classe de réseaux neuronaux conçus pour traiter les données temporelles. Les neurones de RNN ont un état / mémoire cellulaire, et l'entrée est traitée en fonction de cet état interne, qui est obtenu à l'aide de boucles dans le réseau neuronal. Il existe des modules récurrents de couches «tanh» dans les RNN qui leur permettent de conserver des informations. Cependant, pas avant longtemps, c'est pourquoi nous avons besoin de modèles LSTM.

LSTM

Il s'agit d'un type particulier de réseau neuronal récurrent capable d'apprendre les dépendances à long terme dans les données. Ceci est réalisé parce que le module récurrent du modèle a une combinaison de quatre couches interagissant les unes avec les autres.

L'image ci-dessus représente quatre couches de réseau neuronal dans des cases jaunes, des opérateurs point par point dans des cercles verts, une entrée dans des cercles jaunes et un état de cellule dans des cercles bleus. Un module LSTM a un état de cellule et trois portes qui leur donnent le pouvoir d'apprendre, de désapprendre ou de conserver de manière sélective des informations de chacune des unités. L'état des cellules dans LSTM aide les informations à circuler à travers les unités sans être modifiées en n'autorisant que quelques interactions linéaires. Chaque unité a une entrée, une sortie et une porte d'oubli qui peut ajouter ou supprimer les informations à l'état de la cellule. La porte Oublier décide quelles informations de l'état de cellule précédent doivent être oubliées pour lesquelles elle utilise une fonction sigmoïde. La porte d'entrée contrôle le flux d'informations vers l'état actuel de la cellule en utilisant une opération de multiplication ponctuelle de «sigmoïde» et «tanh» respectivement. Enfin, la porte de sortie décide quelles informations doivent être transmises au prochain état caché

Maintenant que nous avons compris le fonctionnement interne du modèle LSTM, implémentons-le. Pour comprendre l'implémentation de LSTM, nous allons commencer par un exemple simple - une ligne droite. Voyons si LSTM peut apprendre la relation d'une ligne droite et la prédire.

Commençons par créer l'ensemble de données représentant une ligne droite.

Dans [402]:

x = numpy.arange (1,500,1)
y = 0.4 * x + 30
plt.plot(x,y)

Sortie [402]:

[<matplotlib.lines.Line2D at 0x1eab9d3ee10>]

Dans [403]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

Maintenant que les données ont été créées et divisées en train et test. Convertissons les données de la série chronologique sous la forme de données d'apprentissage supervisé en fonction de la valeur de la période de rétrospective, qui est essentiellement le nombre de retards qui semblent prédire la valeur au temps «t».

Donc une série chronologique comme celle-ci -

time variable_x
t1  x1
t2  x2
 :   :
 :   :
T   xT

Lorsque la période d'analyse est 1, est convertie en

x1   x2
x2   x3
 :    :
 :    :
xT-1 xT

Dans [404]:

def create_dataset(n_X, look_back):
   dataX, dataY = [], []
   for i in range(len(n_X)-look_back):
      a = n_X[i:(i+look_back), ]
      dataX.append(a)
      dataY.append(n_X[i + look_back, ])
   return numpy.array(dataX), numpy.array(dataY)

Dans [405]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)

trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

Nous allons maintenant former notre modèle.

De petits lots de données d'entraînement sont affichés sur le réseau, une exécution de lorsque les données d'entraînement entières sont affichées au modèle par lots et l'erreur est calculée est appelée une époque. Les époques doivent être exécutées jusqu'à ce que l'erreur diminue.

Dans [ ]:

from keras.models import Sequential
from keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(256, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(128,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic1.h5')

Dans [407]:

model.load_weights('LSTMBasic1.h5')
predict = model.predict(testx)

Voyons maintenant à quoi ressemblent nos prédictions.

Dans [408]:

plt.plot(testx.reshape(398,2)[:,0:1], testx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Sortie [408]:

[<matplotlib.lines.Line2D at 0x1eac792f048>]

Maintenant, nous devrions essayer de modéliser une onde sinusoïdale ou cosinusoïdale de la même manière. Vous pouvez exécuter le code ci-dessous et jouer avec les paramètres du modèle pour voir comment les résultats changent.

Dans [409]:

x = numpy.arange (1,500,1)
y = numpy.sin(x)
plt.plot(x,y)

Sortie [409]:

[<matplotlib.lines.Line2D at 0x1eac7a0b3c8>]

Dans [410]:

trainx, testx = x[0:int(0.8*(len(x)))], x[int(0.8*(len(x))):]
trainy, testy = y[0:int(0.8*(len(y)))], y[int(0.8*(len(y))):]
train = numpy.array(list(zip(trainx,trainy)))
test = numpy.array(list(zip(trainx,trainy)))

Dans [411]:

look_back = 1
trainx,trainy = create_dataset(train, look_back)
testx,testy = create_dataset(test, look_back)
trainx = numpy.reshape(trainx, (trainx.shape[0], 1, 2))
testx = numpy.reshape(testx, (testx.shape[0], 1, 2))

Dans [ ]:

model = Sequential()
model.add(LSTM(512, return_sequences = True, input_shape = (trainx.shape[1], 2)))
model.add(LSTM(256,input_shape = (trainx.shape[1], 2)))
model.add(Dense(2))
model.compile(loss = 'mean_squared_error', optimizer = 'adam')
model.fit(trainx, trainy, epochs = 2000, batch_size = 10, verbose = 2, shuffle = False)
model.save_weights('LSTMBasic2.h5')

Dans [413]:

model.load_weights('LSTMBasic2.h5')
predict = model.predict(testx)

Dans [415]:

plt.plot(trainx.reshape(398,2)[:,0:1], trainx.reshape(398,2)[:,1:2])
plt.plot(predict[:,0:1], predict[:,1:2])

Sortie [415]:

[<matplotlib.lines.Line2D at 0x1eac7a1f550>]

Vous êtes maintenant prêt à passer à n'importe quel ensemble de données.