Predict Multiple Steps Ahead

[eric-lluz]

Hi,

I am working on a time series forecasting project and facing a challenge with multistep forecasting.
Currently, I have a model trained to predict one step ahead, but I need to adapt this approach to predict multiple steps ahead more efficiently. I need to keep training with h=1.

import logging
import os
import sys
from contextlib import contextmanager

import pandas as pd
from neuralforecast.models import LSTM
from neuralforecast import NeuralForecast
import torch

data = pd.DataFrame({
    'unique_id': ['serie_1'] * 100,  
    'ds': pd.date_range(start='2023-01-01', periods=100, freq='D'),
    'y': torch.sin(torch.arange(100)).numpy()
})

train_size = int(len(data) * 0.8)
train_data = data.iloc[:train_size]
test_data = data.iloc[train_size:]
win = 10

model = LSTM(h=1,input_size=win, max_steps=200)
nf = NeuralForecast(models=[model], freq='D')

nf.fit(df=train_data)

n_steps = 10
y_hat = predict_multistep(nf, test_data, n_steps)
y_hat

@contextmanager
def suppress_output():
    with open(os.devnull, 'w') as fnull:
        old_stdout = sys.stdout
        old_stderr = sys.stderr
        sys.stdout = fnull
        sys.stderr = fnull
        try:
            yield
        finally:
            sys.stdout = old_stdout
            sys.stderr = old_stderr

logging.getLogger("pytorch_lightning").setLevel(logging.ERROR)

def predict_multistep(nf, dataset, n_steps, mode='OSA'):
    """#+
    This function performs multi-step forecasting using a trained NeuralForecast model.#+

    Parameters:#+
    nf (NeuralForecast): The trained NeuralForecast model.#+
    dataset (pandas.DataFrame): The dataset containing the time series data.#+
    n_steps (int): The number of steps to forecast.#+
    mode (str): The forecasting mode. It can be either 'OSA' (One Step Ahead) or 'FR' (Free Simulation).#+

    Returns:#+
    pandas.DataFrame: A DataFrame containing the forecasted values and actual values.#+
    """
    data = dataset.copy()
    id = data['unique_id'].values[0]
    predictions = []

    # One Step Ahead prediction#+
    if mode == 'OSA':
        for i in range(n_steps):
            with suppress_output():
                y_hat = nf.predict(test_data.iloc[i:win+i,:])
            row = {'unique_id': id, 
                   'ds':y_hat['ds'].values[0], 
                   'y':dataset.iloc[win+i,:]['y'],
                   'y_hat':y_hat['LSTM'].values[0]}
            predictions.append(row)

    # Free Simulation prediction#+
    elif mode == 'FR':
        ini = data.index[0]
        for i in range(n_steps):
            with suppress_output():
                y_hat = nf.predict(data.iloc[i:win+i,:])
            data.loc[ini+i+win,'y'] =  y_hat['LSTM'].values[0]
            row = {'unique_id': id, 
                   'ds':y_hat['ds'].values[0], 
                   'y':dataset.iloc[win+i,:]['y'],
                   'y_hat':y_hat['LSTM'].values[0]}
            predictions.append(row)

    else:
        raise ValueError("Invalid mode. Choose between 'one_step_ahead' and 'free_simulation'.")

    return pd.DataFrame(predictions)

This approach is considerably slow. Is there any other model to make this prediction?