Addestramento di un RNN con esempi di diverse lunghezze in Keras

Sto cercando di iniziare a conoscere gli RNN e sto usando Keras. Comprendo le premesse di base dei livelli Vanilla RNN e LSTM, ma ho difficoltà a comprendere un certo punto tecnico per l'allenamento.

Nella documentazione di keras , dice che l'input di un layer RNN deve avere forma (batch_size, timesteps, input_dim). Ciò suggerisce che tutti gli esempi di addestramento hanno una lunghezza di sequenza fissa, vale a dire timesteps.

Ma questo non è particolarmente tipico, vero? Potrei voler far funzionare l'RNN su frasi di varia lunghezza. Quando lo alleno su alcuni corpus, gli darò da mangiare gruppi di frasi, tutte di diversa lunghezza.

Suppongo che la cosa ovvia da fare sarebbe trovare la lunghezza massima di qualsiasi sequenza nel set di allenamento e zero pad. Ma allora significa che non posso fare previsioni al momento del test con una lunghezza di input maggiore di quella?

Questa è una domanda sulla particolare implementazione di Keras, suppongo, ma sto anche chiedendo cosa fanno di solito le persone di fronte a questo tipo di problema in generale.

Ciò suggerisce che tutti gli esempi di addestramento hanno una lunghezza di sequenza fissa, vale a dire timesteps.

Questo non è del tutto corretto, dal momento che quella dimensione può essere None, cioè lunghezza variabile. All'interno di un singolo batch , devi avere lo stesso numero di timestep (questo è in genere il punto in cui vedi 0-padding e mascheramento). Ma tra i lotti non esiste tale restrizione. Durante l'inferenza, puoi avere qualsiasi lunghezza.

Codice di esempio che crea batch casuali di lunghezza dei dati di allenamento.

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)

E questo è ciò che stampa. Si noti che le forme di output (None, None, x)indicano dimensioni batch variabili e dimensioni timestep variabili.

__________________________________________________________________________________________
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 sembra avere una soluzione migliore

Suppongo che la cosa ovvia da fare sarebbe trovare la lunghezza massima di qualsiasi sequenza nel set di allenamento e zero pad.

Questa è di solito una buona soluzione. Forse prova la lunghezza massima della sequenza + 100. Usa ciò che funziona meglio per la tua applicazione.

Ma allora significa che non posso fare previsioni al momento del test con una lunghezza di input maggiore di quella?

Non necessariamente. Il motivo per cui una lunghezza fissa viene utilizzata in keras è perché migliora notevolmente le prestazioni creando tensori di forme fisse. Ma questo è solo per l'allenamento. Dopo l'allenamento, avrai imparato i pesi giusti per il tuo compito.

Supponiamo, dopo l'allenamento per ore, ti rendi conto che la lunghezza massima del tuo modello non era abbastanza grande / piccola e ora devi cambiare i passi del tempo, basta estrarre i pesi appresi dal vecchio modello, costruire un nuovo modello con i nuovi passi del tempo e iniettare i pesi appresi in esso.

Probabilmente puoi farlo usando qualcosa come:

new_model.set_weights(old_model.get_weights())

Non l'ho provato da solo. Provalo e pubblica i risultati qui a beneficio di tutti. Ecco alcuni link: uno due