But first, why bother? Because a method just gives you a number, while a model gives you a likelihood, and with it flexibility: you can select components and features via information criteria, get predictive distributions, and extend the model however you like. So, if you derive a model underlying a method, you bring that method to another level.

A quick recap. Croston split intermittent demand into two parts: how often the product sells (demand intervals) and how much it sells when it does (demand sizes), and applied Simple Exponential Smoothing (SES) to each of them. In my previous post, I showed the simplest model for the “how often” part, which assumes that the chance of a sale does not change over time.

A more complicated statistical model was proposed by John Boylan and me in our iETS paper. It assumes that the occurrence of sales follows a Bernoulli distribution with a time-varying probability. In the “inverse-odds-ratio” version of the model, we track the expected number of periods without sales: if the gap between sales is 4 periods then the probability of a sale is 1/4. Every new zero or one is converted into an error term, and this expected number is updated via ETS(M,N,N), the model underlying SES. When the probability does not change much over time, this model can be estimated with Croston’s method, which is why it can be considered as the model underlying it.

In Python, the basic model is done like this:

from smooth import OM, ADAM

occ = OM(model="MNN", occurrence="inverse-odds-ratio")
occ.fit(y)
model = ADAM(model="MNN")
model.fit(y, occurrence=occ)
model.predict(h=10, interval="prediction")

In the paper, we also showed that this model is especially suitable for new products with demand building up. This means that the gaps between sales become shorter and shorter, i.e. the demand transforms from intermittent to regular. If you expect this to continue in the holdout period, you can use the trend model, and here how to do that in Python:

occ = OM(model="MMN", occurrence="inverse-odds-ratio")

This way, the expected gap between sales would decline in the holdout period, and the probability of a sale would grow. The image in this post shows how this works on an artificial example.

And if you know what drives sales (e.g. promotions or price changes), you can include this information in the occurrence model as well.

So, yes, there is a model underlying Croston’s method, and it allows doing things that the method itself cannot do.

Try smooth for Python: pip install smooth
Occurrence model on wiki

Message smooth in Python: iETS and the Croston’s Method first appeared on OpenForecast.

This idea goes back to Croston, who suggested splitting intermittent demand into demand occurrence and demand sizes. The main image in the post shows a typical intermittent demand series, and the one below shows its occurrence part: “1” when someone bought the product, and “0” otherwise.

We now have a series that can be modelled on its own, and there are many ways to do that, which come down to your preferences and experience: ETS, ARIMA, logistic regression, GBM, Neural Network – you name it!

One thing to avoid, though, is trying to predict the exact periods when sales will happen: when demand is truly intermittent, you can’t. What you can forecast is the probability. I had a post on that topic.

In the smooth package, there is a separate function for this, OM, which allows using ETS, ARIMA and regression elements to model demand occurrence. It supports several types of occurrence, including the odds-ratio, the inverse-odds-ratio (related to Croston’s method) and the direct one (similar to TSB). But the simplest of all is the fixed probability, which assumes that the probability of sale does not change over time. It simply takes the share of periods with sales: if the product sold in 30 out of 100 weeks, the probability is 0.3. If you read my previous post, you might notice that this is essentially 1/ADI turned into a forecast, with the same limitation of ignoring how demand evolves. Still, it is a good benchmark and a starting point for intermittent demand forecasting.

In Python, this is done like this:

from smooth import OM, ADAM

model = OM(occurrence="fixed")
model.fit(y)
fc = model.predict(h=10)

The resulting probability forecast is shown in the following image:

We can also use this directly in ADAM, which splits the demand into two parts on its own. Here is the model with ETS(M,N,N) for demand sizes and the fixed probability of occurrence, iETS(M,N,N)_F:

model = ADAM(model="MNN", occurrence="fixed")
model.fit(y)
model.predict(h=10)

The last command takes the probability from the occurrence model and multiplies it by the forecast of demand sizes. The result is the mean demand per period, just like from any other forecasting method.

Next time, I’ll tell you about the more advanced occurrence models, where the probability changes over time. So, stay tuned!

Try smooth for Python: pip install smooth
Occurrence model on wiki.

Message smooth in Python: fixed probability model for demand occurrence first appeared on OpenForecast.

Back in 1972, John Croston, who worked on stock control systems relying on Simple Exponential Smoothing (SES), noticed that SES forecasts were biased exactly when ordering decisions were made: right after a demand occurred. The following image shows why.

Intermittent demand consists mostly of periods with no sales, and SES treats each of them as a sale of size zero rather than as the absence of a sale. So, its forecast goes down with every zero, as if people wanted the product less and less. Then a customer buys 5 units, and SES immediately becomes optimistic. But in intermittent demand, sales rarely happen in consecutive periods, so this optimism leads to wrong ordering decisions.

The problem is not SES itself, but that it does not distinguish demand occurrence from demand sizes. Croston split the series into two parts (see the main image of the post): demand intervals (the number of periods between non-zero demands) and demand sizes (the non-zero values). He applied SES to each of them separately, and defined the final forecast as the ratio of the smoothed sizes to the smoothed intervals, i.e. the expected demand per period. Both parts are updated only when a demand happens, so the method does not change its mind with every zero, giving more stable forecasts and more reasonable ordering decisions.

Nowadays, we have many great forecasting approaches, from simple ones like TSB to more advanced ones like LightGBM. Croston’s method itself turned out to be biased (Syntetos & Boylan proposed a correction for that). Still, it works fine for manufacturers of large expensive items, with low volumes and long gaps between orders, where a stable forecast matters more than a quick reaction. I am not a big fan of the method, but I really like Croston’s original idea: split intermittent demand into demand occurrence and demand sizes. More than half a century later, this idea still works. My iETS paper used it, outperforming other simple forecasting methods on the M5 data. Türkmen et al. (2021) used the same idea with deep neural networks. The paper with Anna Sroginis showed that it also works with LightGBM, leading to substantial accuracy improvements that translate into inventory savings. So, even if you dislike Croston’s method, I bet you can improve your approach by using his original idea.

We will cover intermittent demand and the methods built on Croston’s idea in our Demand Forecasting Principles course in November.

Message The main idea behind the Croston’s method first appeared on OpenForecast.

First, why would we want non-equal weights in the first place? Demand evolves over time, and recent sales might reflect its current level better than the sales we had several years ago. So, it is only natural to give higher weights to recent observations and lower ones to older ones. Can we do that in a simple and principled way? Yes, and there is a forecasting method that does exactly that!

I’m talking about Simple Exponential Smoothing (SES), proposed by Robert Goodell Brown back in 1956 and independently by Charles Holt in 1957. It is yet another simple forecasting method, suitable for data without trend, seasonality or features. Mathematically, it is written like this:

\begin{equation}
F_{t+1} = \alpha A_{t} + (1−\alpha) F_{t}
\end{equation}

where \(F_t\) is the one-step-ahead forecast, \(A_t\) is the actual value, \(t\) is the time index, and \( \alpha \) is the smoothing parameter. Roughly speaking, \( \alpha \) defines how the weight is split between the most recent actual value and the previous forecast. If \( \alpha=0 \), the forecast ignores all new information and stays at its starting value, which could be, for example, the global average. With \( \alpha=1 \), it ignores all previous forecasts and becomes Naïve. The nice thing about SES is that \( \alpha \) also regulates how the weights are distributed over time, because the method can be rewritten as (see derivations here):

\begin{equation}
F_{t+1} = \alpha A_{t} + \alpha (1−\alpha) A_{t−1} + \alpha (1−\alpha)^2 A_{t−2} + \alpha (1−\alpha)^3 A_{t−3} + …
\end{equation}

Take \(\alpha=0.5\). The most recent observation gets the weight of 0.5, the one before it 0.5 × 0.5 = 0.25, the one before that 0.5 × 0.5² = 0.125, and so on. The weights decay exponentially. So, instead of 12 parameters, we define just one, and it determines how fast the weights decay. The chart in this post compares the equal weights of SMA(12) with SES for \( \alpha=0.2 \) and \( \alpha=0.5 \): the closer α is to zero, the more evenly the weights are spread; the closer it is to one, the more weight goes to the most recent observation, and the faster the older ones are forgotten.

There are tons of papers discussing SES, its modifications and extensions. Gardner (1985 and 2006) is the best review on the topic. And finally, SES is a predecessor of ETS, and its mechanism is used in TBATS.

How do you choose α in practice, and what do you do when SES is not enough? This is what we discuss in our Demand Forecasting Principles course.

Message Simple Exponential Smoothing: one parameter instead of many weights first appeared on OpenForecast.

The standard practice when ETS is not enough to capture the dynamics of real demand is to either switch to ARIMA or apply it to the residuals of the model. But it is possible to join the two models in one by using the Single Source of Error (SSOE) state space framework and to estimate the parameters jointly. This reduces the bias in the parameter estimates, letting the two models work as a team rather than one cleaning up after the other.

In the SSOE form, ETS and ARIMA states are stacked one after another in a large vector. For example, an ETS(A,N,A)+AR(2) model has four states: level, seasonal, and two AR components — each updated independently but responding to the same shock. Structurally, this resembles fitting ETS and then modelling its residuals with ARIMA, but with a critical difference: the parameters are estimated jointly, removing the bias that accumulates from sequential fitting.

But this flexibility comes with constraints. Some ETS and ARIMA combinations are actually redundant — they describe the same process from two angles, producing infinitely many parameter combinations with identical fit. For example, ETS(A,N,N) and ARIMA(0,1,1) are equivalent models, and combining them creates an unidentifiable model with no stable solution. So, I have come up with a few practical guidelines, which you can read about in Section 9.4 of ADAM.

Practically speaking, this is all handled under the hood of the ADAM function in Python, so you don’t need to worry about it. Here is an example:

from fcompdata import AirPassengers
from smooth import ADAM

# ETS(A,A,N) + SARIMA(0,0,0)(1,1,1)[12]
model = ADAM(
    model="AAN",
    ar_order=[0, 1],
    i_order=[0, 1],
    ma_order=[0, 1],
    lags=[1, 12],
    h=12, holdout=True
)
model.fit(AirPassengers.y)

Note how the orders are specified: per lag, with the first element referring to lag 1 and the second to lag 12. The code above fits ETS(A,A,N) + SARIMA(0,0,0)(1,1,1)[12], delegating the seasonality to the ARIMA part. The advantage of doing this via ADAM is that the result can be compared with pure ETS or ARIMA directly using information criteria. And if you don’t want to choose the orders yourself, AutoADAM will select them for you.

But do you even need the full combination? Gardner (1985) and Taylor (2010) argued that adding AR(1) tends to improve the accuracy of ETS. So, maybe you can get away with the simple ETS+AR(1) model, which is easy to apply using ADAM.

When to use ETS vs ARIMA.
How to combine them.

Try it yourself: pip install smooth

Message smooth for Python: ETS+ARIMA first appeared on OpenForecast.

Conventional maximum likelihood estimation minimises one-step-ahead errors. It works well in many standard situations and produces quite robust models. But in practice, you are rarely interested in just the next observation. Supply chains operate on lead times. Budgets are planned quarterly. The model you trained on one-step-ahed forecast is not the model that minimises your actual decision-relevant error.

Multistep losses address this directly. Instead of minimising \(\mathrm{MSE}_1\), they minimise errors computed \(h\) steps ahead from every in-sample point. The key theoretical result (Svetunkov et al., 2023) is that this implies *shrinkage* of smoothing parameters towards zero — the model becomes less stochastic, less reactive to noise, and more stable across longer horizons. Shrinkage strength grows with \(h\) and weakens as sample size increases.

ADAM supports several multistep losses, each with a different trade-off:

• MSEh — minimises the \(h\)-step-ahead variance only; strongest shrinkage, simplest interpretation;
• TMSE — sums \(\mathrm{MSE}_j\) for \(j=1,…,h\), i.e. sum of the MSEs between 1 and h steps ahead; balances all horizons but is dominated by longer-horizon errors;
• GTMSE — takes the log of each \(\mathrm{MSE}_j\) before summing; equalises the influence of short and long horizons, milder shrinkage;
• MSCE — minimises cumulative forecast error; directly relevant for inventory decisions with lead time \(h\);
• GPL — the full General Predictive Likelihood; accounts for the entire covariance structure of multistep errors and encompasses all the above.

All of these are accessible in the Python smooth package with a single parameter change. Here is an example of the code with GTMSE:

from fcompdata import AirPassengers
from smooth import ADAM

model = ADAM(model="AAA", lags=12, loss="GTMSE", h=12)
model.fit(AirPassengers.y)
model.predict(h=10)

The h parameter sets the horizon over which multistep errors are evaluated during estimation. This allows connecting the loss with the specific decision horizon better. The image in the post shows the ETS model fit and forecasts, when estimated with several different losses, including the conventional one.

One practical note: on small samples, MSEh and MSCE can produce noticeably biased parameter estimates (closer to zero) due to strong shrinkage. GTMSE tends to be a safer default for small samples.

Read more about these and other losses in the ADAM monograph or in the wiki of the package.

Message smooth in python: Multistep losses first appeared on OpenForecast.

Since 2024, Kandrika Pritularga and I have run a demand forecasting principles course at the Centre for Marketing Analytics and Forecasting. We ran it three times, and it has received good reviews from the participants. They liked that the material was motivated by real-life problems, that we explained it in detail, answered all the questions, and had helpful workshops. So, having discussed this with Kandrika and Nikos, we decided to continue the course, but now under the umbrella of OpenForecast, and this time Nikos Kourentzes and I will be teaching it together.

Demand Forecasting Principles is a four-week online course running in October 2026. We plan to have eight live Zoom sessions (two per week), with hands-on workshops in both R and Python between them. All sessions are recorded and shared with the participants for their reference.

The course will cover all the essentials of forecasting, starting from the forecasting principles, moving to the simple methods, ETS, intermittent demand, forecast evaluation, judgement, and finishing with forecast combinations.

Who is this for?

• demand planners,
• data scientists,
• business analysts
• anyone who works with forecasts and wants to understand what happens behind the numbers.

What do you need to know?

You don’t need prior knowledge of forecasting or statistics – we explain everything as we go, in as much detail as you need. Yet, experienced practitioners will still find plenty that is new: some of our previous participants were seasoned forecasters and said exactly that.

The details, programme, prices and booking are available here. Students get a discount.

Exact October dates will be announced next week, but you can already book your place.

If you are not sure whether the course fits you or your team, get in touch.

Message Demand Forecasting Principles course, October 2026 first appeared on OpenForecast.

There are situations where non-normal distributions fit considerably better. The main candidate for substitution is the conditional distribution of the response variable. For example, sales of engines cannot follow the normal distribution by definition: they are intermittent and integer-based — you cannot sell 1.78 engines. More generally, while demand can be fractional, it cannot be negative. It is therefore only logical to use distributions that support positive values only in these situation. Examples include Log-Normal, Gamma, and Inverse Gaussian, among many others.

In my last paper with John Boylan (this one), we discussed how ETS can be extended to use these three distributions instead of the normal one. I implemented this functionality (together with the others, such as Laplace and Generalised Normal) in ADAM. It supports any of these distributions with any ETS/ARIMA/regression model, for both additive and multiplicative error terms. There is some maths involved, which you can find here and here.

Why bother? The main is in the predictive distribution. If the data is not normal, we may end up with poorly calibrated forecasts and misleading prediction intervals. Using a more appropriate distribution can resolve this.

But how do we choose the right distribution for our data?

A possible solution (similar to selecting ETS components) is to fit models with different distributions and pick the one with the lowest information criterion. This is implemented in the ADAM function from the smooth package. We can do this manually, or use AutoADAM (called auto.adam in R) to select the most suitable distribution based on AICc automatically:

from fcompdata import AirPassengers
from smooth import AutoADAM

model = AutoADAM(lags=[12], h=12, holdout=True, orders=None, verbose=True)
model.fit(AirPassengers.y)
model.summary()

The orders=None line stops the function from trying different ARIMA orders – something we will come back to in a future post. For this example, the output is:

Model estimated using ADAM() function: ETS(MAM)
Response variable: y
Distribution used in the estimation: Normal
Loss function type: likelihood; Loss function value: 523.2756
Coefficients:
       Estimate  Std. Error  Lower 2.5%  Upper 97.5%   
alpha    0.7575      0.0895      0.5807       0.9343  *
beta     0.0000      0.0080      0.0000       0.0158   
gamma    0.0000      0.0503      0.0000       0.0994   
Error standard deviation: 0.0358
Sample size: 144
Number of estimated parameters: 4
Number of degrees of freedom: 140
Information criteria:
      AIC     AICc       BIC      BICc
1054.5512 1054.839 1066.4305 1067.1455

Boring… the function found that the Normal distribution has the lowest AICc among those tested – the Air Passengers data is too well-behaved.

Oh, and don’t forget to produce the forecasts:

model.predict(h=18, interval="prediction")

Smooth forecasting!

Install smooth: pip install smooth

Message smooth in python: Non-normal distributions in ETS/ARIMA first appeared on OpenForecast.

One of the solutions (old but gold) is the multiple seasonal ETS model, which was originally developed by James Taylor (2003) for the pure additive exponential smoothing. The idea was quite simple: to model multiple seasonal cycles, one can add multiple seasonal components, i.e. to capture the day-of-week (frequency 7) and the day-of-year (frequency 365) effects. While it worked fine for some examples, the main issue with it has been its computational speed (or rather slowness): the original ETS needs to estimate all smoothing parameters + all the initial values for seasonal indices and other components. Both ADAM and ES in the smooth package support multiple seasonalities and avoid the whole issue by using a different model initialisation called “backcasting”.

Here is a classical example from James’ paper on the half-hourly electricity demand (see the image in the post). It is clear that there is a half-hour-of-day and the day-of-week effects. In ES, this means that we need to provide the vector for the lags variable:

from smooth import ES
from fcompdata import taylor

# Fit ES with automatic ETS model selection
model = ES(lags=[48, 336], h=336, holdout=True)
model.fit(taylor.y)
model.predict(h=336)
print(model)

This is the output I get from the function:

Time elapsed: 2.03 seconds
Model estimated using ES() function: ETS(MNM)
With backcasting initialisation
Distribution assumed in the model: Normal
Loss function type: likelihood; Loss function value: 25391.1773
Persistence vector g:
 alpha gamma1 gamma2
0.2899 0.1283 0.5270
Sample size: 3696
Number of estimated parameters: 4
Number of degrees of freedom: 3692
Information criteria:
      AIC      AICc       BIC      BICc
50790.3546 50790.3654 50815.2146 50815.2591

Forecast errors:
ME: 829.1195; MAE: 942.1447; RMSE: 1065.1127
sCE: 941.5012%; Asymmetry: 9.2%; sMAE: 3.1841%; sMSE: 0.1296%
MASE: 1.4491; RMSSE: 1.1286; rMAE: 0.1408; rRMSE: 0.1300

The computational time on this data was only 2.03 second. In this time, the function tried several possible ETS models and selected the best one based on the AICc value. The resulting best model is ETS(M,N,M), which makes perfect sense for this data.

Is there a way to improve this model? Yes! Taylor mentions that adding AR(1) to the cocktail tends to improve the accuracy in case of multiple seasonal series. We can try that if we switch to ADAM:

from smooth import ADAM

# Fit ADAM ETS(MNM)+AR(1) model
model = ADAM(model="MNM", ar_orders=1, lags=[48, 336], h=336, holdout=True)
model.fit(taylor.y)
print(model)
model.plot(7)

Here is the output:

Time elapsed: 1.04 seconds
Model estimated using ADAM() function: ETS(MNM)+ARIMA(1,0,0)
With backcasting initialisation
Distribution assumed in the model: Gamma
Loss function type: likelihood; Loss function value: 24157.2473
Persistence vector g:
 alpha gamma1 gamma2
0.1097 0.2225 0.3481
ARMA parameters of the model:
             Lag 1
AR(1)       0.6852
Sample size: 3696
Number of estimated parameters: 5
Number of degrees of freedom: 3691
Information criteria:
      AIC      AICc       BIC      BICc
48324.4947 48324.5109 48355.5697 48355.6365

Forecast errors:
ME: 276.4061; MAE: 462.5092; RMSE: 588.5957
sCE: 313.8711%; Asymmetry: 2.1%; sMAE: 1.5631%; sMSE: 0.0396%
MASE: 0.7114; RMSSE: 0.6237; rMAE: 0.0691; rRMSE: 0.0719

The resulting model has lower AICc, but also produces more accurate point forecasts (compare RMSSE values) for the holdout set. The following image shows the data and the point forecasts for it:

What else can we do here? Actually, quite a lot: multistep losses, seasonal ARIMA, explanatory variables – things can get only more complicated from here. Have a look at this.

Do I hear someone shouting “TBATS”? TBATS is the exponential smoothing with additional bells and whistles (ETS + adapted Fourier terms + ARMA errors). I don’t have it as a separate function in the smooth just yet, but you can reproduce it, for example, like this.

So, what are you waiting for? Dive in and see how it works for yourself!

Install smooth: pip install smooth

Message smooth in python: multiple seasonal ETS first appeared on OpenForecast.

We all know that in real life sales don’t just evolve over time on their own. Any univariate model, such as ARIMA or ETS is just a way to approximate a complex reality. In practice, there are many factors affecting the demand for your product. What would happen if the price on your product increases? What if you run a promotion (e.g. “Buy One, Get One Free”)? Your competitor’s strategy impacts the demand for your product as well… There’s lots of different factors, and some of them can be quite useful in demand forecasting. But can we join the dynamic univariate models with regression?

Yes, we can! Although ETS is thought as a pure univariate model, it is easy to extend to include explanatory variables. There are several great papers showing how it works (e.g. Kourentzes & Petropoulos, 2016), and in fact the es() function from the smooth package for R was used as a benchmark in the M5 competition.

So, consider a situation where you have weekly sales of a product with some recorded promotions (encoded as dummy variables). We will use a time series from the fcompdata package for Python. The first image shows how the series looks, the vertical lines show when promotions happen. The series itself seems to be seasonal, roughly repeating peaks and troughs every 52 observations (every year). Also, we see that there are two types of promotions, and when they happen sales tend to increase. So, including them should improve the model fit, and if the company decides to run promotions again, the model will forecast demand better. I will start by fitting the ETS(M,N,M) to the data:

from smooth import ES
from fcompdata import PromoData

y = PromoData.y

model = ES(model="MNM", lags=52, holdout=True, h=13)
model.fit(y)
model.predict(h=13)
model.plot(7)

NOTE: PromoData has a specific structure with several attributes. PromoData.x contains the in-sample data, PromoData.xx has the holdout – this is consistent with the Mcomp package for R. The new features in python are:

• PromoData.y – concatenated training and test sets,
• PromoData.xregx – matrix of explanatory variables for the training set,
• PromoData.xregxx – matrix of explanatory variables for the test set,
• PromoData.xreg – the full (concatenated) matrix of explanatory variables.

The following image shows the model fit and the point forecasts from the ETS(M,N,M):

As expected, because the model does not take promotions into account, it fits the data as best as it can and produces forecasts that are oblivious of the potential external effects on sales. We can improve it by including the promotional dummies:

X_train = PromoData.xreg
X_test =  PromoData.xregxx

model = ES(model="MNM", lags=52, holdout=True, h=13)
model.fit(y, X_train)
model.predict(h=13, X=X_test)
model.plot(7)

The image above shows the fit and the point forecasts from the ETSX(M,N,M) model that now takes the promotions into account. This is quite an improvement in comparison with the previous one. Furthermore, if we can control when to have promotions and what types of promotions to run, we can change the values in the `X_test` matrix and see what demand to expected in that situation. So, this gives an analyst a tool for a more advanced sensitivity analysis.

Read more about the ETSX here.
Install smooth: pip install smooth
ETSX wiki on github.

Message smooth in python: ETS with explanatory variables first appeared on OpenForecast.