Probabilistic forecasting | MLForecast

Documentation Index

Fetch the complete documentation index at: https://nixtlaverse.nixtla.io/llms.txt

Use this file to discover all available pages before exploring further.

In this example, we’ll implement prediction intervals

Prerequisites This tutorial assumes basic familiarity with MLForecast. For a minimal example visit the Quick Start

​

Introduction

Important Although the terms are often confused, prediction intervals are not the same as confidence intervals.

Warning In practice, most prediction intervals are too narrow since models do not account for all sources of uncertainty. A discussion about this can be found here.

1. Install libraries
2. Load and explore the data
3. Train models
4. Plot prediction intervals

Tip You can use Colab to run this Notebook interactively

​

Install libraries

​

Load and explore the data

import pandas as pd
from utilsforecast.plotting import plot_series

train = pd.read_csv('https://auto-arima-results.s3.amazonaws.com/M4-Hourly.csv')
test = pd.read_csv('https://auto-arima-results.s3.amazonaws.com/M4-Hourly-test.csv')

train.head()

test.head()

n_series = 8
uids = train['unique_id'].unique()[:n_series] # select first n_series of the dataset
train = train.query('unique_id in @uids')
test = test.query('unique_id in @uids')

• df: A pandas dataframe with columns [unique_id, ds, y].
• forecasts_df: A pandas dataframe with columns [unique_id, ds] and models.
• plot_random: bool = True. Plots the time series randomly.
• models: List[str]. A list with the models we want to plot.
• level: List[float]. A list with the prediction intervals we want to plot.
• engine: str = matplotlib. It can also be plotly. plotly generates interactive plots, while matplotlib generates static plots.

fig = plot_series(train, test.rename(columns={'y': 'y_test'}), models=['y_test'], plot_random=False)

​

Train models

• Lasso
• LinearRegression
• Ridge
• K-Nearest Neighbors
• Multilayer Perceptron (NeuralNetwork)

from mlforecast import MLForecast
from mlforecast.target_transforms import Differences
from mlforecast.utils import PredictionIntervals
from sklearn.linear_model import Lasso, LinearRegression, Ridge
from sklearn.neighbors import KNeighborsRegressor
from sklearn.neural_network import MLPRegressor

# Create a list of models and instantiation parameters
models = [
    KNeighborsRegressor(),
    Lasso(),
    LinearRegression(),
    MLPRegressor(),
    Ridge(),
]

• models: The list of models defined in the previous step.
• target_transforms: Transformations to apply to the target before computing the features. These are restored at the forecasting step.
• lags: Lags of the target to use as features.

mlf = MLForecast(
    models=[Ridge(), Lasso(), LinearRegression(), KNeighborsRegressor(), MLPRegressor(random_state=0)],
    freq=1,
    target_transforms=[Differences([1])],
    lags=[24 * (i+1) for i in range(7)],
)

• data: Series data in long format.
• id_col: Column that identifies each series. In our case, unique_id.
• time_col: Column that identifies each timestep, its values can be timestamps or integers. In our case, ds.
• target_col: Column that contains the target. In our case, y.
• prediction_intervals: A PredicitonIntervals class. The class takes two parameters: n_windows and h. n_windows represents the number of cross-validation windows used to calibrate the intervals and h is the forecast horizon. The strategy will adjust the intervals for each horizon step, resulting in different widths for each step.

mlf.fit(
    train,
    prediction_intervals=PredictionIntervals(n_windows=10, h=48),
);

• horizon: An integer that represent the forecasting horizon. In this case, we’ll forecast the next 48 hours.
• level: A list of floats with the confidence levels of the prediction intervals. For example, level=[95] means that the range of values should include the actual future value with probability 95%.

levels = [50, 80, 95]
forecasts = mlf.predict(48, level=levels)
forecasts.head()

test = test.merge(forecasts, how='left', on=['unique_id', 'ds'])

​

Plot prediction intervals

​

KNeighborsRegressor

fig = plot_series(
    train,
    test,
    plot_random=False,
    models=['KNeighborsRegressor'],
    level=levels,
    max_insample_length=48
)

​

Lasso

fig = plot_series(
    train,
    test,
    plot_random=False,
    models=['Lasso'],
    level=levels,
    max_insample_length=48
)

​

Linear Regression

fig = plot_series(
    train,
    test,
    plot_random=False,
    models=['LinearRegression'],
    level=levels,
    max_insample_length=48
)

​

MLPRegressor

fig = plot_series(
    train,
    test,
    plot_random=False,
    models=['MLPRegressor'],
    level=levels,
    max_insample_length=48
)

​

Ridge

fig = plot_series(
    train,
    test,
    plot_random=False,
    models=['Ridge'],
    level=levels,
    max_insample_length=48
)

​

References

• Kamile Stankeviciute, Ahmed M. Alaa and Mihaela van der Schaar (2021). “Conformal Time-Series Forecasting”
• Rob J. Hyndman and George Athanasopoulos (2018). “Forecasting principles and practice, The Statistical Forecasting Perspective”.