​

Table of Contents

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

​

Introduction

​

Croston SBA Model

• $Y'_t:$ Average demand per period
• $Z_t:$ Actual demand at period $t$
• $Z'_t:$ Time between two positive demand
• $P:$ Demand size forecast for next period
• $P'_t:$ Forecast of demand interval
• $\alpha:$ Smoothing constant

​

Principals of the Croston SBA method

1. Suitable for intermittent data: The Croston SBA method is especially useful when the data exhibits intermittent patterns, that is, periods of demand followed by periods of non-demand. Instead of treating the data as zero for non-demand periods, the Croston SBA method estimates demand occurrence rates and conditional demand rates.
2. Separation of frequency and level: One of the key features of the Croston SBA method is that it separates the frequency and level information in the demand data. This allows these two components to be modeled and forecasted separately, which can result in better predictions.
3. Estimation of occurrence and demand rates: The Croston SBA method uses a simple exponential smoothing technique to estimate conditional occurrence and demand rates. These rates are then used to forecast future demand.
4. Does not assume distribution of the data: Unlike some forecasting techniques that assume a specific distribution of the data, the Croston SBA method makes no assumptions about the distribution of demand. This makes it more flexible and applicable to a wide range of situations.
5. Does not require complete historical data: The Croston SBA method can work even when historical data is sparse or not available at regular intervals. This makes it an attractive option when it comes to forecasting intermittent demand with limited data.

​

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 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 CrostonSBA with StatsForecast

​

Load libraries

from statsforecast import StatsForecast
from statsforecast.models import CrostonSBA

​

Instantiating Model

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

# We call the model that we are going to use
models = [CrostonSBA()]

• 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=[CrostonSBA])

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

{'mean': array([26.04749601]),
 'fitted': array([      nan,  0.      ,  4.75    , ..., 29.088629, 29.088629,
        29.088629], dtype=float32),
 'sigma': np.float32(49.512943)}

​

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, max_insample_length=500)

​

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.