Entrenando a un RNN con ejemplos de diferentes longitudes en Keras

Estoy tratando de comenzar a aprender sobre RNN y estoy usando Keras. Entiendo la premisa básica de las capas RNN y LSTM de vainilla, pero tengo problemas para comprender un cierto punto técnico para el entrenamiento.

En la documentación de Keras , dice que la entrada a una capa RNN debe tener forma (batch_size, timesteps, input_dim). Esto sugiere que todos los ejemplos de entrenamiento tienen una longitud de secuencia fija, a saber timesteps.

Pero esto no es especialmente típico, ¿verdad? Es posible que desee que el RNN opere en oraciones de diferentes longitudes. Cuando lo entrene en algún corpus, lo alimentaré con lotes de oraciones, de diferentes longitudes.

Supongo que lo obvio sería encontrar la longitud máxima de cualquier secuencia en el conjunto de entrenamiento y ponerla a cero. Pero entonces, ¿eso significa que no puedo hacer predicciones en el momento de la prueba con una longitud de entrada mayor que eso?

Esta es una pregunta sobre la implementación particular de Keras, supongo, pero también estoy preguntando qué hacen las personas cuando se enfrentan a este tipo de problema en general.

Esto sugiere que todos los ejemplos de entrenamiento tienen una longitud de secuencia fija, a saber timesteps.

Eso no es del todo correcto, ya que esa dimensión puede ser None, es decir, longitud variable. Dentro de un solo lote , debe tener el mismo número de pasos de tiempo (esto es típicamente donde se ve el relleno 0 y el enmascaramiento). Pero entre lotes no existe tal restricción. Durante la inferencia, puede tener cualquier longitud.

Código de ejemplo que crea lotes aleatorios de datos de entrenamiento de duración prolongada.

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)

Y esto es lo que imprime. Tenga en cuenta que las formas de salida (None, None, x)indican un tamaño de lote variable y un tamaño de paso de tiempo 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 parece tener una mejor solución

Supongo que lo obvio sería encontrar la longitud máxima de cualquier secuencia en el conjunto de entrenamiento y ponerla a cero.

Esta suele ser una buena solución. Tal vez intente la longitud máxima de secuencia + 100. Use lo que funcione mejor para su aplicación.

Pero entonces, ¿eso significa que no puedo hacer predicciones en el momento de la prueba con una longitud de entrada mayor que eso?

No necesariamente. La razón por la que se usa una longitud fija en keras es porque mejora enormemente el rendimiento al crear tensores de formas fijas. Pero eso es solo para entrenar. Después del entrenamiento, habrás aprendido los pesos correctos para tu tarea.

Supongamos que, después de entrenar durante horas, se da cuenta de que la longitud máxima de su modelo no era lo suficientemente grande / pequeña y ahora necesita cambiar los pasos de tiempo, simplemente extraer los pesos aprendidos del modelo anterior, construir un nuevo modelo con los nuevos pasos de tiempo e inyectarle los pesos aprendidos.

Probablemente puedas hacer esto usando algo como:

new_model.set_weights(old_model.get_weights())

No lo he probado yo mismo. Pruébelo y publique sus resultados aquí para beneficio de todos. Aquí hay algunos enlaces: uno dos