Les réseaux de mémoire à long terme - généralement appelés «LSTM» - sont un type spécial de RNN, capable d'apprendre des dépendances à long terme. Ils ont été introduits par Hochreiter & Schmidhuber (1997)

, et ont été raffinés et popularisés par de nombreuses personnes dans les travaux suivants. Ils fonctionnent extrêmement bien sur une grande variété de problèmes et sont maintenant largement utilisés.

Une unité LSTM commune est composée d'une cellule , d'une porte d'entrée , d'une porte de sortie et d'une porte d'oubli . La cellule se souvient des valeurs sur des intervalles de temps arbitraires et les trois portes régulent le flux d'informations entrant et sortant de la cellule.

Dans un LSTM, chaque pas de temps a un:

  • Oublier la porte - détermine si le passé doit être oublié ou préservé
  • Porte d'entrée - détermine quelles parties du vecteur actuel sont importantes
  • Porte de sortie - détermine quelles données doivent être sorties à l'état caché vs conservées dans l'état de cellule "tranquillement". Cela crée une version filtrée d'un état de cellule.

La capacité du LSTM à effacer, écrire et lire des informations est ce qui l'aide à atténuer, dans une certaine mesure, l'impact des gradients qui disparaissent / explosent et à conserver les informations sur de nombreuses étapes de temps (ce avec quoi les RNN vanille ont du mal).

Après l'innovation, LSTM a été largement utilisé dans de nombreux domaines. Certains d'entre eux sont-

  • Traduction de langue comme Google Translate.
  • Prédiction boursière.
  • Reconnaissance de la parole.
  • Prédiction de séries chronologiques.
  • Reconnaissance de l'écriture manuscrite et plus encore…


LSTM pour la classification de séquence 

Nous pouvons rapidement développer un petit LSTM pour le problème IMDB et obtenir une bonne précision.

Commençons par importer les classes et les fonctions requises pour ce modèle et initialiser le générateur de nombres aléatoires à une valeur constante pour nous assurer que nous pouvons facilement reproduire les résultats.

import numpy
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
# fix random seed for reproducibility
numpy.random.seed(7)

Nous devons charger le jeu de données IMDB. Nous limitons l'ensemble de données aux 5 000 premiers mots. Nous avons également divisé l'ensemble de données en ensembles de train (50%) et de test (50%).

# load the dataset but only keep the top n words, zero the rest
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)

Ensuite, nous devons tronquer et remplir les séquences d'entrée afin qu'elles aient toutes la même longueur pour la modélisation. Le modèle apprendra que les valeurs nulles ne portent aucune information donc en effet les séquences ne sont pas de la même longueur en termes de contenu, mais des vecteurs de même longueur sont nécessaires pour effectuer le calcul dans Keras.

# truncate and pad input sequences
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)

Nous pouvons maintenant définir, compiler et ajuster notre modèle LSTM.

La première couche est la couche intégrée qui utilise 32 vecteurs de longueur pour représenter chaque mot. La couche suivante est la couche LSTM avec 100 unités de mémoire (neurones intelligents). Enfin, comme il s'agit d'un problème de classification, nous utilisons une couche de sortie dense avec un seul neurone et une fonction d'activation sigmoïde pour faire 0 ou 1 prédictions pour les deux classes (bonnes et mauvaises) du problème.

Puisqu'il s'agit d'un problème de classification binaire, la perte de journal est utilisée comme fonction de perte ( binary_crossentropy dans Keras). L'algorithme d'optimisation ADAM efficace est utilisé. Le modèle ne convient que pour 2 époques car il surpasse rapidement le problème. Une grande taille de lot de 64 avis est utilisée pour espacer les mises à jour de poids.

# create the model
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=64)

Une fois ajusté, nous estimons les performances du modèle sur des critiques invisibles.

# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

Pour être complet, voici la liste complète des codes de ce réseau LSTM sur l'ensemble de données IMDB.

# LSTM for sequence classification in the IMDB dataset
import numpy
from keras.datasets import imdb
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers.embeddings import Embedding
from keras.preprocessing import sequence
# fix random seed for reproducibility
numpy.random.seed(7)
# load the dataset but only keep the top n words, zero the rest
top_words = 5000
(X_train, y_train), (X_test, y_test) = imdb.load_data(num_words=top_words)
# truncate and pad input sequences
max_review_length = 500
X_train = sequence.pad_sequences(X_train, maxlen=max_review_length)
X_test = sequence.pad_sequences(X_test, maxlen=max_review_length)
# create the model
embedding_vecor_length = 32
model = Sequential()
model.add(Embedding(top_words, embedding_vecor_length, input_length=max_review_length))
model.add(LSTM(100))
model.add(Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
print(model.summary())
model.fit(X_train, y_train, epochs=3, batch_size=64)
# Final evaluation of the model
scores = model.evaluate(X_test, y_test, verbose=0)
print("Accuracy: %.2f%%" % (scores[1]*100))

L'exécution de cet exemple produit la sortie suivante.

Epoch 1/3
16750/16750 [==============================] - 107s - loss: 0.5570 - acc: 0.7149
Epoch 2/3
16750/16750 [==============================] - 107s - loss: 0.3530 - acc: 0.8577
Epoch 3/3
16750/16750 [==============================] - 107s - loss: 0.2559 - acc: 0.9019
Accuracy: 86.79%

Vous pouvez voir que ce LSTM simple avec peu de réglage permet d'obtenir des résultats presque à la pointe de la technologie sur le problème IMDB. Surtout, il s'agit d'un modèle que vous pouvez utiliser pour appliquer des réseaux LSTM à vos propres problèmes de classification de séquence.