# 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 CrostonClassic Model with Statsforecast.

​

Table of Contents

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

​

Introduction

1. Intermittent Demand Rate: Calculates the demand rate for periods in which sales or events occur, ignoring periods without sales. This rate is used to estimate the probability that a claim will occur in the future.
2. Demand Interval: Calculates the time interval between sales or events occurring, again ignoring non-sales periods. This interval is used to estimate the probability that a demand will occur in the next period.

​

Croston Classic Model

​

What is intermittent demand?

​

Problem with intermittent demand

1. Unpredictable variability: Intermittent demand can have unpredictable variability, making planning and forecasting difficult. Demand patterns can be irregular and fluctuate dramatically between periods with sales and periods without sales.
2. Low frequency of sales: Intermittent demand is characterized by long periods without sales. This can lead to inventory management difficulties, as it is necessary to hold enough stock to meet demand when it occurs, while avoiding excess inventory during non-sales periods.
3. Forecast error: Forecasting intermittent demand can be more difficult to pin down than constant demand. Traditional forecast models may not be adequate to capture the variability and lack of patterns in intermittent demand, which can lead to significant errors in estimates of future demand.
4. Impact on the supply chain: Intermittent demand can affect the efficiency of the supply chain and create difficulties in production planning, supplier management and logistics. Lead times and inventory levels must be adjusted to meet unpredictable demand.
5. Operating costs: Managing inventory in situations of intermittent demand can increase operating costs. Maintaining adequate inventory during non-sales periods and managing stock levels may require additional investments in storage and logistics.

​

Croston’s method(CR)

• ${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.

• The non-zero demand are independent and obey normal distribution;
• The demand intervals are independent and obey geometric distribution;
• There are mutual independence between the demand size and demand intervals.

​

Croston’s variations

​

Area of application of the Croston method

1. Inventory management: The Croston model is used to forecast demand for products with sporadic or intermittent sales. Helps determine optimal inventory levels and replenishment policies, minimizing inventory costs and ensuring adequate availability to meet intermittent demand.
2. Retail sales: In the retail sector, especially in products with low sales frequency or irregular sales, the Croston model can be useful for forecasting demand and optimizing inventory planning in stores or warehouses.
3. Demand forecasting: In general, the Croston model is applied in demand forecasting when there is a lack of clear patterns or high variability in the time series. It can be used in various industries, such as the pharmaceutical industry, the automotive industry, the perishable goods industry, and other sectors where intermittent demand is common.
4. Supply Chain Planning: The Croston model can be used in supply chain planning and management to improve the accuracy of intermittent demand forecasts. This helps streamline production, inventory management, supplier order scheduling, and other aspects of the supply chain.

​

Croston Method for Stationary Time Series

​

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

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

1. Data to train our Croston Classic Model.
2. Data to test our model

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))

sns.lineplot(train,x="ds", y="y", label="Train", linestyle="--",linewidth=2)
sns.lineplot(test, x="ds", y="y", label="Test", linewidth=2, color="yellow")
plt.title("Store visit");
plt.show()

​

Implementation of CrostonClassic with StatsForecast

alias : str
    Custom name of the model.

​

Load libraries

from statsforecast import StatsForecast
from statsforecast.models import CrostonClassic

​

Instantiating Model

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

models = [CrostonClassic()]

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

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

{'mean': array([27.41841685]),
 'fitted': array([     nan,  0.     ,  5.     , ..., 30.61961, 30.61961, 30.61961],
       dtype=float32),
 'sigma': np.float32(49.5709)}

​

Forecast Method

• h (int): represents the forecast h steps into the future. In this case, 25 week 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.