Quelle est la différence entre un LSTM bidirectionnel et un LSTM ?

Question

Quelqu'un peut-il m'expliquer cela ? Je sais que les LSTM bidirectionnels ont un passage vers l'avant et vers l'arrière, mais quel en est l'avantage par rapport à un LSTM unidirectionnel ?

À quoi chacun d'eux est-il mieux adapté ?

Answer 1

Le LSTM, dans son essence, préserve les informations des entrées qui l'ont déjà traversé en utilisant l'état caché.

Le LSTM unidirectionnel ne préserve que l'information du passé parce que les seules entrées qu'il a vues sont celles du passé.

L'utilisation de l'approche bidirectionnelle permet d'exécuter vos entrées de deux manières, l'une du passé vers le futur et l'autre du futur vers le passé. Ce qui différencie cette approche de l'approche unidirectionnelle, c'est que dans le LSTM qui fonctionne à l'envers, vous conservez les informations du passé et du futur. futur et en utilisant les deux états cachés combinés, vous êtes capable à tout moment de préserver l'information de le passé et l'avenir .

La question de savoir à quoi ils conviennent est très compliquée, mais les BiLSTM donnent de très bons résultats car ils comprennent mieux le contexte, je vais essayer de l'expliquer par un exemple.

Disons que nous essayons de prédire le prochain mot d'une phrase, à un haut niveau, ce qu'un LSTM unidirectionnel verra est

Les garçons sont allés sur ....

Et essaiera de prédire le mot suivant uniquement par ce contexte, avec le LSTM bidirectionnel vous serez capable de voir des informations plus loin par exemple

Forward LSTM :

Les garçons sont allés à...

Backward LSTM :

... et puis ils sont sortis de la piscine.

Vous pouvez voir qu'en utilisant les informations du futur, il serait plus facile pour le réseau de comprendre le mot suivant.

Answer 2

En complément de la réponse de Bluesummer, voici comment implémenter le LSTM bidirectionnel à partir de zéro sans appeler BiLSTM module. Cela pourrait mieux mettre en évidence la différence entre un LSTM unidirectionnel et un LSTM bidirectionnel. Comme vous le voyez, nous fusionnons deux LSTMs pour créer un LSTM bidirectionnel.

Vous pouvez fusionner les sorties des LSTMs avant et arrière en utilisant soit {'sum', 'mul', 'concat', 'ave'} .

left = Sequential()
left.add(LSTM(output_dim=hidden_units, init='uniform', inner_init='uniform',
               forget_bias_init='one', return_sequences=True, activation='tanh',
               inner_activation='sigmoid', input_shape=(99, 13)))
right = Sequential()
right.add(LSTM(output_dim=hidden_units, init='uniform', inner_init='uniform',
               forget_bias_init='one', return_sequences=True, activation='tanh',
               inner_activation='sigmoid', input_shape=(99, 13), go_backwards=True))

model = Sequential()
model.add(Merge([left, right], mode='sum'))

model.add(TimeDistributedDense(nb_classes))
model.add(Activation('softmax'))

sgd = SGD(lr=0.1, decay=1e-5, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd)
print("Train...")
model.fit([X_train, X_train], Y_train, batch_size=1, nb_epoch=nb_epoches, validation_data=([X_test, X_test], Y_test), verbose=1, show_accuracy=True)

Answer 3

En comparaison avec LSTM , BLSTM ou BiLSTM a deux réseaux, un accès past l'information dans forward et un autre accès future dans le reverse direction. wiki

Une nouvelle classe Bidirectional est ajouté selon le document officiel ici : https://www.tensorflow.org/api_docs/python/tf/keras/layers/Bidirectional

model = Sequential()
model.add(Bidirectional(LSTM(10, return_sequences=True), input_shape=(5,
10)))

et la fonction d'activation peut être ajoutée comme suit :

model = Sequential()
model.add(Bidirectional(LSTM(num_channels, 
        implementation = 2, recurrent_activation = 'sigmoid'),
        input_shape=(input_length, input_dim)))

L'exemple complet utilisant les données IMDB sera le suivant : le résultat après 4 époques.

Downloading data from https://s3.amazonaws.com/text-datasets/imdb.npz
17465344/17464789 [==============================] - 4s 0us/step
Train...
Train on 25000 samples, validate on 25000 samples
Epoch 1/4
25000/25000 [==============================] - 78s 3ms/step - loss: 0.4219 - acc: 0.8033 - val_loss: 0.2992 - val_acc: 0.8732
Epoch 2/4
25000/25000 [==============================] - 82s 3ms/step - loss: 0.2315 - acc: 0.9106 - val_loss: 0.3183 - val_acc: 0.8664
Epoch 3/4
25000/25000 [==============================] - 91s 4ms/step - loss: 0.1802 - acc: 0.9338 - val_loss: 0.3645 - val_acc: 0.8568
Epoch 4/4
25000/25000 [==============================] - 92s 4ms/step - loss: 0.1398 - acc: 0.9509 - val_loss: 0.3562 - val_acc: 0.8606

BiLSTM ou BLSTM

import numpy as np
from keras.preprocessing import sequence
from keras.models import Sequential
from keras.layers import Dense, Dropout, Embedding, LSTM, Bidirectional
from keras.datasets import imdb

n_unique_words = 10000 # cut texts after this number of words
maxlen = 200
batch_size = 128

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=n_unique_words)
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)
y_train = np.array(y_train)
y_test = np.array(y_test)

model = Sequential()
model.add(Embedding(n_unique_words, 128, input_length=maxlen))
model.add(Bidirectional(LSTM(64)))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

print('Train...')
model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=4,
          validation_data=[x_test, y_test])

Answer 4

Un autre cas d'utilisation des LSTM bidirectionnels pourrait être la classification de mots dans le texte. Ils peuvent voir le contexte passé et futur du mot et sont beaucoup mieux adaptés pour classifier le mot.

Answer 5

Il peut également être utile dans les problèmes de prévision de séries temporelles, comme la prévision de la consommation électrique d'un ménage. Cependant, nous pouvons également utiliser le LSTM dans ce cas, mais le LSTM bidirectionnel fera un meilleur travail.