Como fazer com que o LSTM preveja várias etapas de tempo à frente?

Estou tentando usar um LSTM para previsão de séries temporais. Os dados são transmitidos uma vez por minuto, mas eu gostaria de prever uma hora à frente. Existem duas maneiras de pensar sobre isso:

1. Agrupe os dados em dados horários, considerando a média a cada período de 60 minutos como um ponto de dados.
2. Para cada (X, y)par de dados de treinamento, Xseja a série temporal de t - 120até t - 60e yseja a série temporal de t - 60até t. Force o LSTM a prever 60 timesteps à frente e use y[-1]como a previsão.

Existem práticas recomendadas para fazer isso?

Existem diferentes abordagens

• Estratégia recursiva

  • um modelo muitos-para-um

    prediction(t+1) = model(obs(t-1), obs(t-2), ..., obs(t-n))
    prediction(t+2) = model(prediction(t+1), obs(t-1), ..., obs(t-n)) 
    

• Estratégia direta

  • vários modelos muitos-para-um

    prediction(t+1) = model1(obs(t-1), obs(t-2), ..., obs(t-n))
    prediction(t+2) = model2(obs(t-2), obs(t-3), ..., obs(t-n))`
    

• Estratégia de saída múltipla

  • um modelo muitos-para-muitos

    prediction(t+1), prediction(t+2) = model(obs(t-1), obs(t-2), ..., obs(t-n))`
    

• Estratégias híbridas

  • combine duas ou mais estratégias acima

Referência: Previsão de séries temporais em várias etapas

De https://machinelearningmastery.com/multi-step-time-series-forecasting-long-short-term-memory-networks-python/

train = [[t-120,t-199...t,t+1...t+60],[...],[...]]

# fit an LSTM network to training data
def fit_lstm(train, n_lag, n_seq, n_batch, nb_epoch, n_neurons):
    # reshape training into [samples, timesteps, features]
    X, y = train[:, 0:n_lag], train[:, n_lag:]
    X = X.reshape(X.shape[0], 1, X.shape[1])
    # 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(y.shape[1]))
    model.compile(loss='mean_squared_error', optimizer='adam')
    # fit network
    for i in range(nb_epoch):
        model.fit(X, y, epochs=1, batch_size=n_batch, verbose=0, shuffle=False)
        model.reset_states()
    return model