Quand et où devrions-nous utiliser ces modèles Keras LSTM

Question

Je sais comment un RNN, LSTM, réseaux neuronaux, fonction d'activation fonctionne mais à partir de divers modèles LSTM disponibles Je ne sais pas ce que dois-je utiliser pour quelles données et quand. J'ai créé ces 5 modèles en tant qu'échantillon de différents varits de modèles LSTM que j'ai vus mais je ne sais pas quel ensemble de données de séquence optimal devrait utiliser. J'ai la plupart de mes confussion dans les deuxième/troisième lignes de ces modèles. Est-ce que model1 et model4 sont identiques? Pourquoi model1.add(LSTM(10, input_shape=(max_len, 1), return_sequences=False)) est-il différent de model4.add(Embedding(X_train.shape[1], 128, input_length=max_len))? J'apprécierais beaucoup Si quelqu'un peut expliquer ces cinq modèles en anglais simple.

from keras.layers import Dense, Dropout, Embedding, LSTM, Bidirectional 
from keras.models import Sequential 
from keras.layers.wrappers import TimeDistributed 

#model1 
model1 = Sequential() 
model1.add(LSTM(10, input_shape=(max_len, 1), return_sequences=False)) 
model1.add(Dense(1, activation='sigmoid')) 
model1.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 

print model1.summary() 

#model2 
model2 = Sequential() 
model2.add(LSTM(10, batch_input_shape=(1, 1, 1), return_sequences=False, stateful=True)) 
model2.add(Dense(1, activation='sigmoid')) 
model2.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 

print model2.summary() 


#model3 
model3 = Sequential() 
model3.add(TimeDistributed(Dense(X_train.shape[1]), input_shape=(X_train.shape[1],1))) 
model3.add(LSTM(10, return_sequences=False)) 
model3.add(Dense(1, activation='sigmoid')) 
model3.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 

print model3.summary() 


#model4 
model4 = Sequential() 
model4.add(Embedding(X_train.shape[1], 128, input_length=max_len)) 
model4.add(LSTM(10)) 
model4.add(Dense(1, activation='sigmoid')) 
model4.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 

print model4.summary() 

#model5 
model5 = Sequential() 
model5.add(Embedding(X_train.shape[1], 128, input_length=max_len)) 
model5.add(Bidirectional(LSTM(10))) 
model5.add(Dense(1, activation='sigmoid')) 
model5.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy']) 

print model5.summary() 

Answer 1

Alors:

1. Le premier réseau est le meilleur pour le classement. Il s'agit simplement d'analyser l'ensemble de la séquence - et une fois que toutes les étapes d'entrée sont transmises à un modèle - il est capable de prendre une décision. Il existe d'autres variantes de cette architecture (en utilisant, par exemple, GlobalAveragePooling1D ou maxi) qui sont assez similaires d'un point de vue conceptuel.

2. Deuxième réseau - d'un point de vue de la conception est assez similaire à une première architecture. Ce qui les différencie est le fait que dans une première approche deux appels consécutifs fit et predict sont totalement indépendants, alors qu'ici - l'état de départ pour le deuxième appel est le même que le dernier dans un premier. Cela permet beaucoup de scénarios sympas comme par exemple. analyse de séquences de longueur variable ou par ex. processus de prise de décision grâce au fait que vous pouvez arrêter efficacement le processus d'inférence/formation - affecter le réseau ou l'entrée et y revenir avec l'état actualisé.

3. Est le meilleur quand vous ne voulez pas utiliser le réseau récurrent à toutes les étapes de vos calculs. Surtout - lorsque votre réseau est grand - l'introduction de couches récurrentes est assez coûteuse du point de vue du nombre de paramètres (l'introduction d'une connexion récurrente augmente généralement le nombre de paramètres par un facteur d'au moins 2). Vous pouvez donc appliquer un réseau statique en tant qu'étape de prétraitement - et ensuite vous alimentez les résultats à une partie récurrente. Cela rend la formation plus facile. Le modèle est un cas particulier du cas 3. Ici - vous avez une séquence de jetons qui sont codés par un codage mono-chaud, puis transformés en utilisant Embedding. Cela rend le processus moins consommateur de mémoire.

4. Le réseau bidrectionnel vous offre l'avantage de connaître à chaque étape non seulement une séquence d'historique - mais aussi d'autres étapes. Ceci est au coût de calcul et vous perdez également la possibilité d'un flux de données séquentiel - comme vous devez avoir une séquence complète lorsque l'analyse est effectuée.