AutoADAM

Automatic ADAM model selection with distribution and ARIMA order selection.

class smooth.AutoADAM(model='ZXZ', lags=None, ar_order=None, i_order=None, ma_order=None, orders=None, arima_select=False, distribution=None, outliers='ignore', level=0.99, constant=False, ic='AICc', loss='likelihood', h=None, holdout=False, bounds='usual', initial='backcasting', regressors='use', verbose=0, ets='conventional', **kwargs)

Automatic ADAM model selection.

Wraps ADAM with automatic selection of ARIMA orders and error distribution.

ETS model selection (ZZZ, ZXZ, FFF, CCC …) is handled by the underlying ADAM machinery and is not duplicated here.

Parameters:

  • model (Union[str, List[str]]) – ETS model specification passed to each internal ADAM fit. Supports all codes accepted by ADAM.

  • lags (Union[int, List[int], None]) – Seasonal period(s). Lag 1 is prepended automatically when absent.

  • ar_order (Union[int, List[int], None]) – Maximum AR order(s) per lag level for ARIMA selection. Defaults to [3, 3] matching R’s auto.adam().

  • i_order (Union[int, List[int], None]) – Maximum integration order(s) per lag level for ARIMA selection. Defaults to [2, 1] matching R’s auto.adam().

  • ma_order (Union[int, List[int], None]) – Maximum MA order(s) per lag level for ARIMA selection.

  • orders (Optional[Dict[str, Any]]) – Dict-style alternative to the scalar max-order arguments above. A dict with keys "ar", "i", "ma" (each an int or list) and optionally "select" (bool). When provided, ar_order / i_order / ma_order are ignored.

  • arima_select (bool) – Whether to perform ARIMA order selection. Unlike ADAM, this defaults to True.

  • distribution (Union[str, List[str], None]) – Distribution(s) to try. When a list is supplied every entry is fitted and the one with lowest IC is kept. A single string uses only that distribution (no selection loop).

  • outliers (Literal['ignore', 'use', 'select']) – Outlier handling mode. "use" and "select" are accepted but not yet implemented; a UserWarning is issued.

  • level (float) – Confidence level for outlier detection (placeholder for future use).

  • ic (Literal['AIC', 'AICc', 'BIC', 'BICc']) – Information criterion used for all model comparisons.

  • loss (Literal['likelihood', 'GPL', 'MSE', 'MAE', 'HAM', 'MSEh', 'MAEh', 'HAMh', 'MSCE', 'MACE', 'CHAM', 'TMSE', 'TMAE', 'THAM', 'GTMSE', 'GTAME', 'GTHAM', 'LASSO', 'RIDGE']) – Loss function for parameter estimation.

  • constant (Union[bool, float]) – Constant/drift term. Overridden by ARIMA selection when arima_select=True (the selection algorithm tests constant on/off).

  • holdout (bool) – Whether to use a holdout sample.

  • h (Optional[int]) – Forecast horizon.

  • bounds (Literal['usual', 'admissible', 'none']) – Parameter bounds type.

  • initial (Union[str, Dict[str, Any], None]) – Initialisation method or fixed initial values.

  • regressors (Literal['use', 'select', 'adapt']) – How to handle external regressors.

  • verbose (int) – Verbosity level for the final model fit. All intermediate selection fits are always silent.

  • **kwargs – Additional arguments forwarded to every internal ADAM fit.

See also

ADAM

Full ADAM model.

ES

ETS-only wrapper.

MSARIMA

Pure ARIMA wrapper.

Examples

Full automatic selection (ETS + ARIMA + distribution):

>>> from smooth import AutoADAM
>>> import numpy as np
>>> y = np.cumsum(np.random.randn(120)) + 100
>>> model = AutoADAM(lags=[12])
>>> model.fit(y)
>>> print(model.model, model.distribution_)

ARIMA-only automatic selection (no ETS):

>>> model = AutoADAM(model="NNN", lags=[1, 12])
>>> model.fit(y)

Fix the distribution, only select ARIMA orders:

>>> model = AutoADAM(distribution="dnorm", lags=[1, 12])
>>> model.fit(y)

References

Overview

AutoADAM extends ADAM with automatic selection of:

  1. Distribution — tests multiple error distributions and selects by IC

  2. ARIMA orders — when arima_select=True or orders={..., "select": True} (see ARIMA precedence below), selects AR/I/MA orders

  3. Outlier detection — optionally detects and includes outlier dummies

ARIMA orders precedence

AutoADAM (and ADAM) share the following rule for resolving the ARIMA-order arguments:

  • If orders (dict) is supplied, it is used and the three scalar arguments ar_order / i_order / ma_order are ignored (a UserWarning is emitted). Order selection runs iff orders.get("select", arima_select) is true.

  • Otherwise, if any of ar_order / i_order / ma_order has a non-zero value, those are used. They are interpreted as upper search bounds when arima_select=True, or as fixed orders when arima_select=False (the default).

  • With no ARIMA spec at all (orders=None and all three scalars zero/None), the model is pure ETS and no ARIMA selection is performed.

lags accepts either a scalar (lags=12) or a list (lags=[12]).

Verbose progress

When constructed with verbose=1, AutoADAM prints the distribution loop’s progress in real time:

Evaluating models with different distributions... dnorm, dlaplace, ds, Done!
Selected distribution: dlaplace
Selected ARIMA orders: AR=[1], I=[1], MA=[1]

Example Usage

Distribution selection:

from smooth import AutoADAM

model = AutoADAM(model="ZZZ",
                 distribution=["dnorm", "dlaplace", "ds"])
model.fit(y)
print(model)

With ARIMA order selection (using the orders dict — recommended):

model = AutoADAM(model="ZZZ",
                 lags=[1, 12],
                 orders={"ar": [3, 1], "i": [2, 1], "ma": [3, 1], "select": True})
model.fit(y)
fc = model.predict(h=24)

Equivalent using scalar bounds with arima_select=True:

model = AutoADAM(model="ZZZ",
                 lags=[1, 12],
                 ar_order=[3, 1],
                 i_order=[2, 1],
                 ma_order=[3, 1],
                 arima_select=True)   # required: default is False
model.fit(y)

With outlier detection:

model = AutoADAM(model="ZZZ", lags=[1, 12],
                 outliers="use", level=0.99)
model.fit(y)

Diagnostics after fitting:

# Standardised residuals
std_res = model.rstandard()

# Studentised residuals
stud_res = model.rstudent()

# Outlier dummy variables (if outliers detected)
dummies = model.outlierdummy()

See Also