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?

[nikitazernov]

Hi,

I had the same problem with such approach and I figured out that PyTorch-Lightning logging slows it down dramatically because it logs to disk.
So when loading model, or initializing it you can disable logging and progress bar as follows, with no need for your suppress_output handler:

nf = NeuralForecast.load(path=f'./checkpoints/{model}/')
nf.models[0].trainer_kwargs['logger'] = False
nf.models[0].trainer_kwargs['enable_progress_bar'] = False