Introduction

You can run these experiments using CPU or GPU with Google Colab.

1. Hierarchical Series

In many applications, a set of time series is hierarchically organized. Examples include the presence of geographic levels, products, or categories that define different types of aggregations. In such scenarios, forecasters are often required to provide predictions for all disaggregate and aggregate series. A natural desire is for those predictions to be “coherent”, that is, for the bottom series to add up precisely to the forecasts of the aggregated series.

The above figure shows a simple hierarchical structure where we have four bottom-level series, two middle-level series, and the top level representing the total aggregation. Its hierarchical aggregations or coherency constraints are:

y_{\mathrm{Total},\tau} = y_{\beta_{1},\tau}+y_{\beta_{2},\tau}+y_{\beta_{3},\tau}+y_{\beta_{4},\tau} \qquad \qquad \qquad \qquad \qquad \\ \mathbf{y}_{[a],\tau}=\left[y_{\mathrm{Total},\tau},\; y_{\beta_{1},\tau}+y_{\beta_{2},\tau},\;y_{\beta_{3},\tau}+y_{\beta_{4},\tau}\right]^{\intercal} \qquad \mathbf{y}_{[b],\tau}=\left[ y_{\beta_{1},\tau},\; y_{\beta_{2},\tau},\; y_{\beta_{3},\tau},\; y_{\beta_{4},\tau} \right]^{\intercal}

Luckily these constraints can be compactly expressed with the following matrices:

\mathbf{S}_{[a,b][b]} = \begin{bmatrix} \mathbf{A}_{\mathrm{[a][b]}} \\ \\ \\ \mathbf{I}_{\mathrm{[b][b]}} \\ \\ \end{bmatrix} = \begin{bmatrix} 1 & 1 & 1 & 1 \\ 1 & 1 & 0 & 0 \\ 0 & 0 & 1 & 1 \\ 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \\ \end{bmatrix}

where

\mathbf{A}_{[a,b][b]}

aggregates the bottom series to the upper levels, and

\mathbf{I}_{\mathrm{[b][b]}}

is an identity matrix. The representation of the hierarchical series is then:

\mathbf{y}_{[a,b],\tau} = \mathbf{S}_{[a,b][b]} \mathbf{y}_{[b],\tau}

To visualize an example, in Figure 2, one can think of the hierarchical time series structure levels to represent different geographical aggregations. For example, in Figure 2, the top level is the total aggregation of series within a country, the middle level being its states and the bottom level its regions.

2. Hierarchical Forecast

To achieve “coherency”, most statistical solutions to the hierarchical forecasting challenge implement a two-stage reconciliation process.

First, we obtain a set of the base forecast $\mathbf{\hat{y}}_{[a,b],\tau}$
Later, we reconcile them into coherent forecasts $\mathbf{\tilde{y}}_{[a,b],\tau}$ .

Most hierarchical reconciliation methods can be expressed by the following transformations:

\tilde{\mathbf{y}}_{[a,b],\tau} = \mathbf{S}_{[a,b][b]} \mathbf{P}_{[b][a,b]} \hat{\mathbf{y}}_{[a,b],\tau}

The HierarchicalForecast library offers a Python collection of reconciliation methods, datasets, evaluation and visualization tools for the task. Among its available reconciliation methods we have BottomUp, TopDown, MiddleOut, MinTrace, ERM. Among its probabilistic coherent methods we have Normality, Bootstrap, PERMBU.

3. Minimal Example

!pip install hierarchicalforecast statsforecast datasetsforecast

Wrangling Data

import numpy as np
import pandas as pd

We are going to creat a synthetic data set to illustrate a hierarchical time series structure like the one in Figure 1. We will create a two level structure with four bottom series where aggregations of the series are self evident.

# Create Figure 1. synthetic bottom data
ds = pd.date_range(start='2000-01-01', end='2000-08-01', freq='MS')
y_base = np.arange(1,9)
r1 = y_base * (10**1)
r2 = y_base * (10**1)
r3 = y_base * (10**2)
r4 = y_base * (10**2)

ys = np.concatenate([r1, r2, r3, r4])
ds = np.tile(ds, 4)
unique_ids = ['r1'] * 8 + ['r2'] * 8 + ['r3'] * 8 + ['r4'] * 8
top_level = 'Australia'
middle_level = ['State1'] * 16 + ['State2'] * 16
bottom_level = unique_ids

bottom_df = dict(ds=ds,
                 top_level=top_level, 
                 middle_level=middle_level, 
                 bottom_level=bottom_level,
                 y=ys)
bottom_df = pd.DataFrame(bottom_df)
bottom_df.groupby('bottom_level').head(2)

	ds	top_level	middle_level	bottom_level	y
0	2000-01-01	Australia	State1	r1	10
1	2000-02-01	Australia	State1	r1	20
8	2000-01-01	Australia	State1	r2	10
9	2000-02-01	Australia	State1	r2	20
16	2000-01-01	Australia	State2	r3	100
17	2000-02-01	Australia	State2	r3	200
24	2000-01-01	Australia	State2	r4	100
25	2000-02-01	Australia	State2	r4	200

The previously introduced hierarchical series

\mathbf{y}_{[a,b]\tau}

is captured within the Y_hier_df dataframe. The aggregation constraints matrix

\mathbf{S}_{[a][b]}

is captured within the S_df dataframe. Finally the tags contains a list within Y_hier_df composing each hierarchical level, for example the tags['top_level'] contains Australia’s aggregated series index.

from hierarchicalforecast.utils import aggregate

# Create hierarchical structure and constraints
hierarchy_levels = [['top_level'],
                    ['top_level', 'middle_level'],
                    ['top_level', 'middle_level', 'bottom_level']]
Y_hier_df, S_df, tags = aggregate(df=bottom_df, spec=hierarchy_levels)
print('S_df.shape', S_df.shape)
print('Y_hier_df.shape', Y_hier_df.shape)
print("tags['top_level']", tags['top_level'])

S_df.shape (7, 5)
Y_hier_df.shape (56, 3)
tags['top_level'] ['Australia']

Y_hier_df.groupby('unique_id').head(2)

	unique_id	ds	y
0	Australia	2000-01-01	220
1	Australia	2000-02-01	440
8	Australia/State1	2000-01-01	20
9	Australia/State1	2000-02-01	40
16	Australia/State2	2000-01-01	200
17	Australia/State2	2000-02-01	400
24	Australia/State1/r1	2000-01-01	10
25	Australia/State1/r1	2000-02-01	20
32	Australia/State1/r2	2000-01-01	10
33	Australia/State1/r2	2000-02-01	20
40	Australia/State2/r3	2000-01-01	100
41	Australia/State2/r3	2000-02-01	200
48	Australia/State2/r4	2000-01-01	100
49	Australia/State2/r4	2000-02-01	200

S_df

	unique_id	Australia/State1/r1	Australia/State1/r2	Australia/State2/r3	Australia/State2/r4
0	Australia	1.0	1.0	1.0	1.0
1	Australia/State1	1.0	1.0	0.0	0.0
2	Australia/State2	0.0	0.0	1.0	1.0
3	Australia/State1/r1	1.0	0.0	0.0	0.0
4	Australia/State1/r2	0.0	1.0	0.0	0.0
5	Australia/State2/r3	0.0	0.0	1.0	0.0
6	Australia/State2/r4	0.0	0.0	0.0	1.0

Base Predictions

Next, we compute the base forecast for each time series using the naive model. Observe that Y_hat_df contains the forecasts but they are not coherent.

from statsforecast.models import Naive
from statsforecast.core import StatsForecast

# Split train/test sets
Y_test_df  = Y_hier_df.groupby('unique_id', as_index=False).tail(4)
Y_train_df = Y_hier_df.drop(Y_test_df.index)

# Compute base Naive predictions
# Careful identifying correct data freq, this data monthly 'M'
fcst = StatsForecast(models=[Naive()],
                     freq='MS', n_jobs=-1)
Y_hat_df = fcst.forecast(df=Y_train_df, h=4, fitted=True)
Y_fitted_df = fcst.forecast_fitted_values()

Reconciliation

from hierarchicalforecast.methods import BottomUp
from hierarchicalforecast.core import HierarchicalReconciliation

# You can select a reconciler from our collection
reconcilers = [BottomUp()] # MinTrace(method='mint_shrink')
hrec = HierarchicalReconciliation(reconcilers=reconcilers)

Y_rec_df = hrec.reconcile(Y_hat_df=Y_hat_df, 
                          Y_df=Y_fitted_df,
                          S_df=S_df, tags=tags)
Y_rec_df.groupby('unique_id').head(2)

	unique_id	ds	Naive	Naive/BottomUp
0	Australia	2000-05-01	880.0	880.0
1	Australia	2000-06-01	880.0	880.0
4	Australia/State1	2000-05-01	80.0	80.0
5	Australia/State1	2000-06-01	80.0	80.0
8	Australia/State2	2000-05-01	800.0	800.0
9	Australia/State2	2000-06-01	800.0	800.0
12	Australia/State1/r1	2000-05-01	40.0	40.0
13	Australia/State1/r1	2000-06-01	40.0	40.0
16	Australia/State1/r2	2000-05-01	40.0	40.0
17	Australia/State1/r2	2000-06-01	40.0	40.0
20	Australia/State2/r3	2000-05-01	400.0	400.0
21	Australia/State2/r3	2000-06-01	400.0	400.0
24	Australia/State2/r4	2000-05-01	400.0	400.0
25	Australia/State2/r4	2000-06-01	400.0	400.0

Getting Started

Tutorials

API Reference

1. Hierarchical Series

2. Hierarchical Forecast

3. Minimal Example

Wrangling Data

Base Predictions

Reconciliation

References

Getting Started

Tutorials

API Reference

​1. Hierarchical Series

​2. Hierarchical Forecast

​3. Minimal Example

​Wrangling Data

​Base Predictions

​Reconciliation

​References

1. Hierarchical Series

2. Hierarchical Forecast

3. Minimal Example

Wrangling Data

Base Predictions

Reconciliation

References