Skip to content

ADAM

Jump to bottom
Ivan Svetunkov edited this page Jan 30, 2026 · 20 revisions

ADAM - Augmented Dynamic Adaptive Model

ADAM is the primary unified framework in the smooth package, combining ETS (Error-Trend-Seasonal), ARIMA, and regression components into a single state-space model using the Single Source of Error (SSOE) approach.

Mathematical Form

The ADAM model is specified in state-space form as:

y_t = o_t(w(v_{t-l}, x_t) + r(v_{t-l})ε_t)
v_t = f(v_{t-l}, a_{t-1}) + g(v_{t-l}, a_{t-1}, x_t)ε_t

Where:

  • y_t: Observed value at time t
  • o_t: Occurrence indicator (for intermittent data)
  • v_t: State vector (level, trend, seasonal, ARIMA components, regression parameters)
  • l: Vector of lags
  • x_t: Vector of exogenous variables
  • w(·): Measurement function
  • r(·): Error function (additive or multiplicative)
  • f(·): Transition function (state evolution)
  • g(·): Persistence function (smoothing parameters)
  • ε_t: Error term

Key Features

  • Unified Framework: Seamlessly combines ETS, ARIMA and regression in a single model
  • Multiple Seasonality: Supports multiple seasonal periods (e.g., daily + weekly)
  • Automatic Selection: Branch & Bound algorithm for efficient model selection
  • Flexible Distributions: Normal, Laplace, Gamma, Log-Normal, Inverse Gaussian, S, Generalized Normal
  • Intermittent Demand: Built-in occurrence models for sparse data
  • External Regressors: Include covariates with adaptive or fixed coefficients

Model Specification

ETS Models

Models are specified using a three-letter (or four-letter in case of damped trend) string "ETS":

  • E (Error): "A" (Additive), "M" (Multiplicative)
  • T (Trend): "N" (None), "A" (Additive), "Ad" (Additive Damped), "M" (Multiplicative), "Md" (Multiplicative Damped)
  • S (Seasonal): "N" (None), "A" (Additive), "M" (Multiplicative)

Examples:

  • model="ANN": Simple Exponential Smoothing
  • model="AAN": Holt's Linear Trend
  • model="AAdA": Holt-Winters Additive with damped trend
  • model="MAM": Multiplicative Holt-Winters

Read more about ETS in Svetunkov (2023), Chapters 4 - 7.

Automatic Selection Codes

  • "ZZZ": Select best model using Branch & Bound
  • "XXX": Select only additive components
  • "YYY": Select only multiplicative components
  • "ZXZ": Auto-select error and seasonal, additive trend only (default, safer)
  • "FFF": Full search across all 30 ETS model types
  • "PPP": Check pure additive and pure multiplicative models only
  • "SSS": Pool of safe models from the forecast package. Letters can be substituted with "X" and "Y" to narrow the pool down.
  • "CCC": AIC-based combination of ETS models. Also supports narrower pools, e.g. "CCN".
  • Vector of models, e.g. c("ANN","AAN","AAA") - will test models in the specified pool.

Model selection is explained in Svetunkov (2023), Section 15.1.

ARIMA Components

Specified via list in orders, e.g. orders=list(ar=c(1,2), i=c(1,1), ma=c(2,2)). Requires lags to be specified explicitly.

To switch off ARIMA, provide model="NNN" in the adam() call.

Note: Python does not support ARIMA at the moment.

Read more about ARIMA in Svetunkov (2023), Chapter 8 and Chapter 9.

Loss Functions

Main loss functions (see Supported Loss Functions subsection below for more):

  • "likelihood": Maximum likelihood (default)
  • "MSE": Mean Squared Error
  • "MAE": Mean Absolute Error
  • "HAM": Half-Absolute Moment
  • "LASSO": use LASSO to shrink the parameters of the model;
  • "RIDGE": use RIDGE to shrink the parameters of the model;
  • "GTMSE": Geometric Trace Mean Squared Error,
  • "GPL": Generalised Predictive Likelihood,
  • custom loss - define your own loss function and use it in the model estimation.

Read more about loss functions in Svetunkov (2023), Chapter 11.

Persistence Parameters

Fixed smoothing parameters can be provided:

Python usage:

model = ADAM(
    model="AAA",
    lags=12,
    persistence={"alpha": 0.3, "beta": 0.1, "gamma": 0.05}
)

R usage:

model = adam(y, model="AAA", lags=12,
    persistence=list(alpha=0.3, beta=0.1, gamma=0.05))
  • alpha: Level smoothing (0 to 1)
  • beta: Trend smoothing (0 to alpha)
  • gamma: Seasonal smoothing (0 to 1-alpha)

If some of parameters are not provided, they will be estimated.

Initialisation Methods

  • "backcasting": Use backcasting (default, faster)
  • "optimal": Optimize all initial states
  • "two-stage": Backcast then optimize
  • "complete": Pure backcasting without optimization
  • provided: User can provide a vector or a list of parameters for the function to use.

More detailed explanation of those is provided in Section 11.4 of Svetunkov (2023).

Python Usage

from smooth import ADAM
import numpy as np

# Sample data
y = np.array([112, 118, 132, 129, 121, 135, 148, 148, 136, 119, 104, 118] * 3)

# Automatic model selection
model = ADAM(model="ZXZ", lags=12, ic="AICc")
model.fit(y)

# Model output
print(model)

# Generate forecasts with intervals
forecasts = model.predict(h=12, calculate_intervals=True, level=0.95)

# Access fitted parameters
print(f"Model: {model.model_type_dict['model']}")
print(f"Alpha: {model.persistence_level_:.3f}")
print(f"AICc: {model.ic_selection}")

Common Use Cases

# 1. Automatic Forecasting
model = ADAM(model="ZXZ", lags=12)

# 2. Multiple Seasonality (hourly with daily/weekly)
model = ADAM(model="AAA", lags=[24, 168])

# 3. Advanced loss functions. Mean Absolute Error
model = ADAM(model="AAA", lags=12, loss="MAE")

# 4. Advanced loss functions. Multistep loss
model = ADAM(model="AAA", lags=12, loss="GTMSE", h=12)

# 5. Custom loss functions
def loss_function(actual, fitted, B):
    return np.mean(np.abs(actual - fitted)^3)

model = ADAM(model="AAA", lags=12, loss=loss_function)

R Usage

library(smooth)

# Automatic model selection
model <- adam(y, model="ZZZ", lags=12)
print(model)
forecast(model, h=12)

# Pure MSARIMA
model <- adam(y, model="NNN", orders=list(ar=c(1,1), i=c(1,1), ma=c(1,1)), lags=c(1,12))

# ETS(A,A,N) With external regressors
ourData <- cbind(y, X)
model <- adam(ourData, model="AAN", formula=y~x1+x2)

# ETS(A,A,N) + AR(1)  with holdout of 18 last observations
model <- adam(y, model="AAN", orders=c(1,0,0), h=18, holdout=TRUE)

Parameters

Core Parameters

Parameter Type (R) Type (Python) Default Description
model character/vector str/List[str] "ZXZ" Model specification string or list
lags numeric vector int/List[int]/None frequency(y) Seasonal period(s)
orders list - NULL/None ARIMA orders (R only)

Estimation Parameters

Parameter Type (R) Type (Python) Default Description
distribution character str/None "default" Error distribution
loss character str "likelihood" Loss function for estimation
ic character str "AICc" Information criterion for model selection
bounds character str "usual" Parameter bounds type
initial character/list/vector str/Dict/None "backcasting" Initialization method
persistence list/vector Dict[str, float]/None NULL/None Fixed smoothing parameters
phi numeric float/None NULL/None Damping parameter
h integer int/None 0 Forecast horizon
holdout logical bool FALSE Use holdout validation

Supported Loss Functions

  • "likelihood": Maximum likelihood (default)
  • "MSE", "MAE", "HAM": Standard error measures
  • "MSEh", "MAEh", "HAMh": Multi-step versions
  • "TMSE", "TMAE", "THAM": Trace versions
  • "GTMSE", "GTAME", "GTHAM": Geometric trace versions
  • "GPL": Generalised Predictive Likelihood
  • "LASSO", "RIDGE": Regularization

Supported Distributions

  • "dnorm": Normal (default for additive errors)
  • "dgamma": Gamma (default for multiplicative errors)
  • "dlaplace": Laplace (heavy-tailed)
  • "dlnorm": Log-Normal (positive data)
  • "dinvgauss": Inverse Gaussian
  • "ds": S distribution (extremely heavy-tailed)
  • "dgnorm": Generalized Normal

Fitted Attributes

Model Information

Element (R) Element (Python) Type (R) Type (Python) Description
model model_type_dict['model'] character str Name of the constructed model
timeElapsed - difftime - Time elapsed for model estimation
call - call - The function call used
bounds - character - Type of bounds used in estimation

Data and Fitted Values

Element (R) Element (Python) Type (R) Type (Python) Description
data - matrix/ts - In-sample data used for training
holdout - vector/ts - Holdout part of data
fitted prepared_model['y_fitted'] vector NDArray Vector of fitted values
residuals prepared_model['residuals'] vector NDArray Vector of residuals
forecast predict() result vector NDArray Point forecast for h steps ahead

State Space Components

Element (R) Element (Python) Type (R) Type (Python) Description
states adam_created['mat_vt'] matrix NDArray Matrix of states
persistence persistence_level_, persistence_trend_, persistence_seasonal_ vector float/List[float] Smoothing parameters (α, β, γ)
phi phi_ numeric float Damping parameter value
transition adam_created['mat_f'] matrix NDArray Transition matrix F
measurement adam_created['mat_wt'] matrix NDArray Measurement matrix w
initial initial_states_ list NDArray Initial state values
initialEstimated - vector - Which initials were estimated
initialType - character - Initialization method used

ARIMA Components (R only)

Element (R) Type (R) Description
orders list ARIMA orders used
arma list List of AR/MA parameters
constant numeric Constant/drift value
lags vector Vector of lags used
lagsAll vector Vector of internal lags

Model Fit Statistics

Element (R) Element (Python) Type (R) Type (Python) Description
nParam - matrix - Matrix of estimated/provided parameters count
loss - character - Loss function type used
lossValue - numeric - Value of the loss function
logLik - numeric - Log-likelihood value
distribution - character - Distribution function used
scale - numeric - Scale parameter value
ICs ic_selection vector float Information criterion value
ICw - vector - IC weights if combination was done

Other Elements

Element (R) Element (Python) Type (R) Type (Python) Description
B adam_estimated['B'] vector NDArray Vector of all estimated parameters
occurrence - oes object - OES model for intermittent demand
formula - formula - Formula for explanatory variables
profile - matrix - Profile matrix used in construction
profileInitial - matrix - Initial profile matrix
lambda - numeric - LASSO/RIDGE parameter
res - list - Optimisation result from nloptr()
other - list - Additional parameters
- model_type_dict - Dict Complete model specification

Accessing Elements (R)

model <- adam(y, model="AAA", lags=12)

# Model name
modelName(model)

# Type of the ETS model
modelType(model)

# ARIMA orders and lags
orders(model)
lags(model)

# Smoothing parameters
model$persistence

# Initial states
model$initial

# Fitted values and residuals
fitted(model)
residuals(model)

# State matrix
model$states

# Information criteria (via methods)
AIC(model)
BIC(model)
logLik(model)

# Coefficients
coef(model)

# Summary with confidence intervals
summary(model)

Accessing Elements (Python)

model = ADAM(model="AAA", lags=[12])
model.fit(y)

# Model name
model.model_type_dict['model']

# Smoothing parameters
model.persistence_level_
model.persistence_trend_
model.persistence_seasonal_

# Damping parameter
model.phi_

# Initial states
model.initial_states_

# Fitted values and residuals
model.prepared_model['y_fitted']
model.prepared_model['residuals']

# State matrix
model.adam_created['mat_vt']

# Information criterion
model.ic_selection

# All estimated parameters
model.adam_estimated['B']

References

  • Svetunkov, I. (2023). Forecasting and Analytics with the Augmented Dynamic Adaptive Model (ADAM). Chapman and Hall/CRC. Online book: https://openforecast.org/adam/
  • Hyndman, R.J., et al. (2008). Forecasting with Exponential Smoothing: The State Space Approach. Springer.

See Also

Related Functions

  • ES - ETS wrapper of ADAM
  • CES - Complex Exponential Smoothing
  • SSARIMA - State Space ARIMA
  • MSARIMA - Multiple Seasonal ARIMA

Parameter Documentation

Clone this wiki locally