TSB Model

# This cell will not be rendered but is to hide warnings and limit the rows shown

import warnings
warnings.filterwarnings("ignore")

import logging
logging.getLogger('statsforecast').setLevel(logging.ERROR)

import pandas as pd
pd.set_option('display.max_rows', 6)

Step-by-step guide on using the TSB Model with Statsforecast.

​

Table of Contents

• Introduction
• TSB
• Loading libraries and data
• Explore data with the plot method
• Split the data into training and testing
• Implementation of TSB with StatsForecast
• Cross-validation
• Model evaluation
• References

​

Introduction

​

TSB Model

• $Y'_t:$ Average demand per period
• $Z_t:$ Actual demand at period $t$
• $Z'_t:$ Time between two positive demand
• $D'_t:$ Estimate probability of a demand occurrence at the end of period $t$
• $\alpha, \beta:$ Smoothing Constant, $0 \leq \alpha, \beta \leq 1$

​

TSB General Properties

1. Intermittent Demand Modelling: The TSB model is specifically designed to forecast intermittent demand, which is characterized by periods of non-demand followed by periods of demand. The model efficiently addresses this characteristic of demand.
2. Level and interval components: The TSB model is based on two main components: the level model and the interval model. The level model estimates the level of demand when it occurs, while the interval model estimates the interval between demand occurrences.
3. Handling data with many zeros: The TSB model can efficiently handle time series data with many zeros, which are common in intermittent demand. The model properly considers these zeros in the forecasting process.
4. Exponential Smoothing: The TSB model uses exponential smoothing methods to estimate demand levels and intervals between occurrences. Exponential smoothing is a widely used technique in time series forecasting.
5. Confidence interval estimation: The TSB model provides confidence interval estimates for the generated forecasts. This allows having a measure of the uncertainty associated with forecasts and facilitates decision making.
6. Simplicity and ease of implementation: The TSB model is relatively simple and easy to implement compared to other more complex approaches. It does not require sophisticated assumptions about the distribution of demand and can be applied in a practical way.

​

Loading libraries and data

Tip Statsforecast will be needed. To install, see instructions.

import matplotlib.pyplot as plt
import seaborn as sns
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
plt.style.use('grayscale') # fivethirtyeight  grayscale  classic
plt.rcParams['lines.linewidth'] = 1.5
dark_style = {
    'figure.facecolor': '#008080',  # #212946
    'axes.facecolor': '#008080',
    'savefig.facecolor': '#008080',
    'axes.grid': True,
    'axes.grid.which': 'both',
    'axes.spines.left': False,
    'axes.spines.right': False,
    'axes.spines.top': False,
    'axes.spines.bottom': False,
    'grid.color': '#000000',  #2A3459
    'grid.linewidth': '1',
    'text.color': '0.9',
    'axes.labelcolor': '0.9',
    'xtick.color': '0.9',
    'ytick.color': '0.9',
    'font.size': 12 }
plt.rcParams.update(dark_style)


from pylab import rcParams
rcParams['figure.figsize'] = (18,7)

import pandas as pd

df=pd.read_csv("https://raw.githubusercontent.com/Naren8520/Serie-de-tiempo-con-Machine-Learning/main/Data/intermittend_demand2")
df.head()

• The unique_id (string, int or category) represents an identifier for the series.
• The ds (datestamp) column should be of a format expected by Pandas, ideally YYYY-MM-DD for a date or YYYY-MM-DD HH:MM:SS for a timestamp.
• The y (numeric) represents the measurement we wish to forecast.

df["unique_id"]="1"
df.columns=["ds", "y", "unique_id"]
df.head()

print(df.dtypes)

ds           object
y             int64
unique_id    object
dtype: object

df["ds"] = pd.to_datetime(df["ds"])

​

Explore Data with the plot method

from statsforecast import StatsForecast

StatsForecast.plot(df)

​

Autocorrelation plots

• Look for patterns in charts. Common patterns include repeating peaks and valleys, sawtooth patterns, and plateau patterns.
• Compare ACF and PACF charts. The PACF chart generally has fewer spikes than the ACF chart.
• Consider the length of the time series. ACF and PACF charts for longer time series will have more spikes.
• Use a confidence interval. The ACF and PACF plots also show confidence intervals for the autocorrelation values. If an autocorrelation value is outside the confidence interval, it is likely to be significant.

fig, axs = plt.subplots(nrows=1, ncols=2)

plot_acf(df["y"],  lags=30, ax=axs[0],color="fuchsia")
axs[0].set_title("Autocorrelation");

plot_pacf(df["y"],  lags=30, ax=axs[1],color="lime")
axs[1].set_title('Partial Autocorrelation')

plt.show();

​

Decomposition of the time series

• Level: This is the primary value that averages over time.
• Trend: The trend is the value that causes increasing or decreasing patterns in a time series.
• Seasonality: This is a cyclical event that occurs in a time series for a short time and causes short-term increasing or decreasing patterns in a time series.
• Residual/Noise: These are the random variations in the time series.

​

Additive time series

​

Multiplicative time series

from plotly.subplots import make_subplots

from statsmodels.tsa.seasonal import seasonal_decompose
from plotly.subplots import make_subplots
import plotly.graph_objects as go

def plotSeasonalDecompose(
    x,
    model='additive',
    filt=None,
    period=None,
    two_sided=True,
    extrapolate_trend=0,
    title="Seasonal Decomposition"):

    result = seasonal_decompose(
            x, model=model, filt=filt, period=period,
            two_sided=two_sided, extrapolate_trend=extrapolate_trend)
    fig = make_subplots(
            rows=4, cols=1,
            subplot_titles=["Observed", "Trend", "Seasonal", "Residuals"])
    for idx, col in enumerate(['observed', 'trend', 'seasonal', 'resid']):
        fig.add_trace(
            go.Scatter(x=result.observed.index, y=getattr(result, col), mode='lines'),
                row=idx+1, col=1,
            )
    return fig

plotSeasonalDecompose(
    df["y"],
    model="additive",
    period=24,
    title="Seasonal Decomposition")

​

Split the data into training and testing

train = df[df.ds\<='2023-01-31 19:00:00'] 
test = df[df.ds>'2023-01-31 19:00:00'] 

train.shape, test.shape

((9500, 3), (500, 3))

​

Implementation of TSB Model with StatsForecast

​

Load libraries

from statsforecast import StatsForecast
from statsforecast.models import TSB

​

Building Model

season_length = 24 # Hourly data 
horizon = len(test) # number of predictions

models = [TSB(alpha_d=0.8, alpha_p=0.9)]

• freq: a string indicating the frequency of the data. (See pandas’ available frequencies.)
• n_jobs: n_jobs: int, number of jobs used in the parallel processing, use -1 for all cores.
• fallback_model: a model to be used if a model fails.

sf = StatsForecast(models=models, freq='h')

​

Fit the Model

sf.fit(df=train)

StatsForecast(models=[TSB])

result=sf.fitted_[0,0].model_
result

{'mean': array([65.58645721]),
 'fitted': array([        nan,  0.        ,  9.        , ..., 14.937817  ,
         1.4937816 ,  0.14937817], dtype=float32),
 'sigma': np.float32(63.87893)}

​

Forecast Method

• h (int): represents the forecast h steps into the future. In this case, 500 hours ahead.

Y_hat = sf.forecast(df=train, h=horizon)
Y_hat

sf.plot(train, Y_hat)

​

Predict method with confidence interval

• h (int): represents the forecast h steps into the future. In this case, 500 hours ahead.

forecast_df = sf.predict(h=horizon) 
forecast_df

​

Cross-validation

​

Perform time series cross-validation

• df: training data frame
• h (int): represents h steps into the future that are being forecasted. In this case, 500 hours ahead.
• step_size (int): step size between each window. In other words: how often do you want to run the forecasting processes.
• n_windows(int): number of windows used for cross validation. In other words: what number of forecasting processes in the past do you want to evaluate.

crossvalidation_df = sf.cross_validation(df=df,
                                         h=horizon,
                                         step_size=50,
                                         n_windows=5)

• unique_id: series identifier
• ds: datestamp or temporal index
• cutoff: the last datestamp or temporal index for the n_windows.
• y: true value
• model: columns with the model’s name and fitted value.

crossvalidation_df

​

Model Evaluation

from functools import partial

import utilsforecast.losses as ufl
from utilsforecast.evaluation import evaluate

evaluate(
    test.merge(Y_hat),
    metrics=[ufl.mae, ufl.mape, partial(ufl.mase, seasonality=season_length), ufl.rmse, ufl.smape],
    train_df=train,
)

​

References

1. Changquan Huang • Alla Petukhina. Springer series (2022). Applied Time Series Analysis and Forecasting with Python.
2. Ivan Svetunkov. Forecasting and Analytics with the Augmented Dynamic Adaptive Model (ADAM)
3. James D. Hamilton. Time Series Analysis Princeton University Press, Princeton, New Jersey, 1st Edition, 1994.
4. Nixtla Parameters.
5. Pandas available frequencies.
6. Rob J. Hyndman and George Athanasopoulos (2018). “Forecasting Principles and Practice (3rd ed)”.
7. Seasonal periods- Rob J Hyndman.