Pourquoi la taille de lot LSTM de Keras utilisée pour la prédiction doit-elle être la même que la taille de lot ajustée?

Malheureusement, ce que vous souhaitez est impossible parce que vous spécifiez le batch_size lorsque vous définissez le modèle... Cependant, j'ai trouvé un moyen simple de contourner ce problème: créer 2 modèles! Le premier est utilisé pour la formation et le second pour les prédictions, et leur faire partager des poids:

train_model = Sequential([Input(batch_input_shape=(batch_size,...),
<continue specifying your model>])

predict_model = Sequential([Input(batch_input_shape=(1,...),
<continue specifying exact same model>])

train_model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam())
predict_model.compile(loss='sparse_categorical_crossentropy', optimizer=Adam())

train_model.save_weights('lstm_model.h5')
predict_model.load_weights('lstm_model.h5')

notez que vous souhaitez enregistrer et chargez les poids, et non l'ensemble du modèle (qui comprend l'architecture, l'optimiseur, etc...). De cette façon, vous obtenez le poids, mais vous pouvez saisir un lot à la fois... plus sur keras enregistrer/charger des modèles: https://keras.io/getting-started/faq/#how-can-i-save-a-keras-model

notez que vous devez installer h5py pour utiliser "save weights".

une Autre solution est:

def create_model(batch_size):
    model = Sequential()
    model.add(LSTM(1, batch_input_shape=(batch_size, 1, sl), stateful=True))
    model.add(Dense(1))
    return model

model_train = create_model(batch_size=50)

model_train.compile(loss='mean_squared_error', optimizer='adam')
model_train.fit(trainX, trainY, epochs=epochs, batch_size=batch_size)

model_predict = create_model(batch_size=1)

weights = model_train.get_weights()
model_predict.set_weights(weights)

j'ai trouvé ci-dessous utiles (et entièrement en ligne avec ci-dessus). La section "Solution 3: Copy Weights" a fonctionné pour moi:

Comment utiliser les Différentes Tailles de Lots lors de la Formation et de Prédire avec LSTMs, par Jason Brownlee

n_neurons = 10
# design network
model = Sequential()
model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')
# fit network
for i in range(n_epoch):
    model.fit(X, y, epochs=1, batch_size=n_batch, verbose=1, shuffle=False)
    model.reset_states()
# re-define the batch size
n_batch = 1
# re-define model
new_model = Sequential()
new_model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
new_model.add(Dense(1))
# copy weights
old_weights = model.get_weights()
new_model.set_weights(old_weights)
# compile model
new_model.compile(loss='mean_squared_error', optimizer='adam')

j'ai aussi le même problème et résolu.

d'une autre façon, vous pouvez enregistrer votre poids, lorsque vous testez votre résultat, vous pouvez recharger votre modèle avec la même architecture et set batch_size=1 comme ci-dessous:

 n_neurons = 10
 # design network
 model = Sequential()
 model.add(LSTM(n_neurons, batch_size=1, batch_input_shape=(n_batch,X.shape[1], X.shape[2]), statefull=True))
 model.add(Dense(1))
 model.compile(loss='mean_squared_error', optimizer='adam')
 model.load_weights("w.h5")

Il fonctionne bien. j'espère qu'il sera utile pour vous.

la meilleure solution à ce problème est "copy Weights". Il peut être vraiment utile si vous voulez former et prédire avec votre modèle LSTM avec différentes tailles de lots.

par exemple, une fois que vous avez formé votre modèle avec la taille de lot 'n' Comme montré ci-dessous:

# configure network
n_batch = len(X)
n_epoch = 1000
n_neurons = 10
# design network
model = Sequential()
model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]), stateful=True))
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')

et maintenant vous voulez prédire des valeurs inférieures à la taille de votre Lot où n=1.

ce que vous pouvez faire est que, Copier les poids de votre modèle fit et de réinitialiser le nouveau modèle LSTM modèle avec la même architecture et la taille de lot égale à 1.

# re-define the batch size
n_batch = 1
# re-define model
new_model = Sequential()
new_model.add(LSTM(n_neurons, batch_input_shape=(n_batch, X.shape[1], X.shape[2]),       stateful=True))
new_model.add(Dense(1))
# copy weights
old_weights = model.get_weights()
new_model.set_weights(old_weights)

pour plus d'information, veuillez lire: https://machinelearningmastery.com/use-different-batch-sizes-training-predicting-python-keras/