Former un RNN avec des exemples de différentes longueurs à Keras

J'essaie de commencer à apprendre sur les RNN et j'utilise Keras. Je comprends le principe de base des couches RNN et LSTM à la vanille, mais j’ai du mal à comprendre un certain point technique pour la formation.

Dans la documentation de keras , il est indiqué que l’entrée dans une couche RNN doit avoir une forme (batch_size, timesteps, input_dim). Cela suggère que tous les exemples d'apprentissage ont une longueur de séquence fixe, à savoir timesteps.

Mais ce n'est pas particulièrement typique, n'est-ce pas? Je souhaiterais peut-être que le RNN opère avec des phrases de durée variable. Lorsque je l’entraînerai sur un corpus, je le nourrirai de lots de phrases de longueurs différentes.

Je suppose que la chose la plus évidente à faire serait de trouver la longueur maximale d’une séquence dans l’ensemble d’entraînement et de la mettre à zéro. Mais alors cela signifie-t-il que je ne peux pas faire de prédiction au moment du test avec une longueur d'entrée supérieure à celle?

Je suppose que cette question concerne la mise en œuvre particulière de Keras, mais je demande aussi ce que les gens font généralement lorsqu'ils sont confrontés à ce type de problème en général.

Cela suggère que tous les exemples d'apprentissage ont une longueur de séquence fixe, à savoir timesteps.

Ce n’est pas tout à fait correct, puisque cette dimension peut être None, c’est-à-dire une longueur variable. Dans un même lot , vous devez avoir le même nombre de pas de temps (c'est généralement l'endroit où vous voyez le remplissage et le masquage 0). Mais entre les lots, il n'y a pas de telle restriction. Pendant l'inférence, vous pouvez avoir n'importe quelle longueur.

Exemple de code qui crée des lots de données d’entraînement aléatoires dans le temps.

from keras.models import Sequential
from keras.layers import LSTM, Dense, TimeDistributed
from keras.utils import to_categorical
import numpy as np

model = Sequential()

model.add(LSTM(32, return_sequences=True, input_shape=(None, 5)))
model.add(LSTM(8, return_sequences=True))
model.add(TimeDistributed(Dense(2, activation='sigmoid')))

print(model.summary(90))

model.compile(loss='categorical_crossentropy',
              optimizer='adam')

def train_generator():
    while True:
        sequence_length = np.random.randint(10, 100)
        x_train = np.random.random((1000, sequence_length, 5))
        # y_train will depend on past 5 timesteps of x
        y_train = x_train[:, :, 0]
        for i in range(1, 5):
            y_train[:, i:] += x_train[:, :-i, i]
        y_train = to_categorical(y_train > 2.5)
        yield x_train, y_train

model.fit_generator(train_generator(), steps_per_epoch=30, epochs=10, verbose=1)

Et c'est ce que ça imprime. Notez que les formes en sortie (None, None, x)indiquent une taille de lot variable et une taille de pas variable.

__________________________________________________________________________________________
Layer (type)                            Output Shape                        Param #
==========================================================================================
lstm_1 (LSTM)                           (None, None, 32)                    4864
__________________________________________________________________________________________
lstm_2 (LSTM)                           (None, None, 8)                     1312
__________________________________________________________________________________________
time_distributed_1 (TimeDistributed)    (None, None, 2)                     18
==========================================================================================
Total params: 6,194
Trainable params: 6,194
Non-trainable params: 0
__________________________________________________________________________________________
Epoch 1/10
30/30 [==============================] - 6s 201ms/step - loss: 0.6913
Epoch 2/10
30/30 [==============================] - 4s 137ms/step - loss: 0.6738
...
Epoch 9/10
30/30 [==============================] - 4s 136ms/step - loss: 0.1643
Epoch 10/10
30/30 [==============================] - 4s 142ms/step - loss: 0.1441

@kbrose semble avoir une meilleure solution

Je suppose que la chose la plus évidente à faire serait de trouver la longueur maximale d’une séquence dans l’ensemble d’entraînement et de la mettre à zéro.

C'est généralement une bonne solution. Essayez peut-être longueur maximale de séquence + 100. Utilisez ce qui convient le mieux à votre application.

Mais alors cela signifie-t-il que je ne peux pas faire de prédiction au moment du test avec une longueur d'entrée supérieure à celle?

Pas nécessairement. La raison pour laquelle une longueur fixe est utilisée dans les keras est qu’elle améliore considérablement les performances en créant des tenseurs de formes fixes. Mais ce n'est que pour la formation. Après la formation, vous aurez appris le poids qui convient à votre tâche.

Supposons qu'après des heures d'entraînement, vous réalisiez que la longueur maximale de votre modèle n'était pas assez grande / petite et que vous deviez maintenant modifier les pas de temps, extraire simplement les poids appris de l'ancien modèle, construire un nouveau modèle avec les nouveaux pas de temps. et injecter les poids appris en elle.

Vous pouvez probablement le faire en utilisant quelque chose comme:

new_model.set_weights(old_model.get_weights())

Je n'ai pas essayé moi-même. Essayez-le et publiez vos résultats ici pour le bénéfice de tous. Voici quelques liens: un deux