web-dev-qa-db-fra.com

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

Quelqu'un peut-il s'il vous plaît expliquer cela? Je sais que les LSTM bidirectionnels ont un passage aller et retour, mais quel est l’avantage de cela par rapport à un LSTM unidirectionnel?

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

machine-learningneural-networkkeraslstmrecurrent-neural-network
34
shekit

Le LSTM, dans son cœur, conserve les informations des entrées qui lui ont déjà été transmises en utilisant l'état masqué.

LSTM unidirectionnel ne conserve que les informations du past car les seules entrées qu'il a vues sont du passé.

L’utilisation bidirectionnelle exécute vos entrées de deux manières, l’une du passé au futur et l’autre du futur au passé. Ce qui différencie cette approche de l’unidirectionnel, c’est que dans le LSTM qui fonctionne en arrière, vous conservez les informations des future et En combinant les deux états cachés, vous pouvez à tout moment conserver les informations de passé et futur.

Ce à quoi ils conviennent est une question très compliquée, mais les BiLSTM donnent de très bons résultats car ils peuvent mieux comprendre le contexte, je vais essayer d’expliquer à travers un exemple.

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

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

Et nous essaierons de prédire le prochain mot uniquement dans ce contexte. Avec LSTM bidirectionnel, vous pourrez voir des informations plus loin, par exemple.

Forward LSTM:

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

LSTM arrière:

... et puis ils sont sortis de la piscine

Vous pouvez constater qu'en utilisant les informations de l'avenir, il pourrait être plus facile pour le réseau de comprendre ce que sera le prochain Word.

56
bluesummers

Ajoutant à la réponse de Bluesummer, voici comment implémenter un LSTM bidirectionnel sans appeler le module BiLSTM. Cela pourrait mieux contraster la différence entre les LSTM unidirectionnels et bidirectionnels. Comme vous le voyez, nous fusionnons deux LSTM pour créer un LSTM bidirectionnel.

Vous pouvez fusionner les sorties des LSTM 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)
6
Aerin

Par rapport à LSTM, BLSTM ou BiLSTM a deux réseaux, un accès pastinformation dans forward direction et un autre accès future dans le sens reverse. wiki

Une nouvelle classe Bidirectional est ajoutée conformément à la documentation officielle 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 ceci:

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

Voici un exemple complet utilisant des données IMDB. 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])
4
Partha Sen

Un autre cas d'utilisation de LSTM bidirectionnel pourrait être la classification de Word dans le texte. Ils peuvent voir le contexte passé et futur de la Parole et sont beaucoup mieux à même de classer la Parole.

1
Fardin