Table of Contents

Class DeepARModel<T>

Namespace
AiDotNet.TimeSeries
Assembly
AiDotNet.dll

Implements DeepAR: Probabilistic Forecasting with Autoregressive Recurrent Networks.

public class DeepARModel<T> : TimeSeriesModelBase<T>, ITimeSeriesModel<T>, IFullModel<T, Matrix<T>, Vector<T>>, IModel<Matrix<T>, Vector<T>, ModelMetadata<T>>, IModelSerializer, ICheckpointableModel, IParameterizable<T, Matrix<T>, Vector<T>>, IFeatureAware, IFeatureImportance<T>, ICloneable<IFullModel<T, Matrix<T>, Vector<T>>>, IGradientComputable<T, Matrix<T>, Vector<T>>, IJitCompilable<T>

Type Parameters

T

The numeric type used for calculations (e.g., float, double).

Inheritance
DeepARModel<T>
Implements
IFullModel<T, Matrix<T>, Vector<T>>
IModel<Matrix<T>, Vector<T>, ModelMetadata<T>>
IParameterizable<T, Matrix<T>, Vector<T>>
ICloneable<IFullModel<T, Matrix<T>, Vector<T>>>
IGradientComputable<T, Matrix<T>, Vector<T>>
Inherited Members
Extension Methods

Remarks

DeepAR is a probabilistic forecasting model that produces full probability distributions rather than point estimates. Key features include:

  • Autoregressive RNN architecture (typically LSTM-based)
  • Probabilistic forecasts with quantile predictions
  • Handles multiple related time series
  • Built-in handling of covariates and categorical features
  • Effective for cold-start scenarios

Original paper: Salinas et al., "DeepAR: Probabilistic Forecasting with Autoregressive Recurrent Networks" (2020).

Production-Ready Features:

  • Uses Tensor<T> for GPU-accelerated operations via IEngine
  • Proper LSTM with all gates (input, forget, output, cell)
  • Backpropagation through time (BPTT) for gradient computation
  • Vectorized operations - no numerical differentiation
  • All parameters are trained (not subsets)

For Beginners: DeepAR is like a weather forecaster that doesn't just say "it will be 70 degrees tomorrow" but rather "there's a 50% chance it'll be between 65-75 degrees, a 90% chance it'll be between 60-80 degrees," etc.

It uses a type of neural network called LSTM (Long Short-Term Memory) that's good at remembering patterns over time. The "autoregressive" part means it uses its own predictions to make future predictions - similar to how you might predict tomorrow's weather based on today's forecast.

This is particularly useful when you need to:

  • Make decisions based on uncertainty (e.g., inventory planning)
  • Forecast many related series efficiently (e.g., sales across stores)
  • Handle new products or stores with limited data

Constructors

DeepARModel(DeepAROptions<T>?)

Initializes a new instance of the DeepARModel class.

public DeepARModel(DeepAROptions<T>? options = null)

Parameters

options DeepAROptions<T>

Configuration options for DeepAR.

Properties

ParameterCount

Gets the number of parameters in the model.

public override int ParameterCount { get; }

Property Value

int

Remarks

This property returns the total count of trainable parameters in the model. It's useful for understanding model complexity and memory requirements.

Methods

CreateInstance()

Creates a new instance of the derived model class.

protected override IFullModel<T, Matrix<T>, Vector<T>> CreateInstance()

Returns

IFullModel<T, Matrix<T>, Vector<T>>

A new instance of the same model type.

Remarks

This abstract factory method must be implemented by derived classes to create a new instance of their specific type. It's used by Clone and DeepCopy to ensure that the correct derived type is instantiated.

For Beginners: This method creates a new, empty instance of the specific model type. It's used during cloning and deep copying to ensure that the copy is of the same specific type as the original.

For example, if the original model is an ARIMA model, this method would create a new ARIMA model. If it's a TBATS model, it would create a new TBATS model.

DeserializeCore(BinaryReader)

Deserializes model-specific data from the binary reader.

protected override void DeserializeCore(BinaryReader reader)

Parameters

reader BinaryReader

The binary reader to read from.

Remarks

This abstract method must be implemented by each specific model type to load its unique parameters and state.

For Beginners: This method is responsible for loading the specific details that make each type of time series model unique. It reads exactly what was written by SerializeCore, in the same order, reconstructing the specialized parts of the model.

It's the counterpart to SerializeCore and should read data in exactly the same order and format that it was written.

This separation allows the base class to handle common deserialization tasks while each model type handles its specialized data.

ForecastWithQuantiles(Vector<T>, double[])

Generates probabilistic forecasts with quantile predictions.

public Dictionary<double, Vector<T>> ForecastWithQuantiles(Vector<T> history, double[] quantiles)

Parameters

history Vector<T>
quantiles double[]

Returns

Dictionary<double, Vector<T>>

GetModelMetadata()

Gets metadata about the time series model.

public override ModelMetadata<T> GetModelMetadata()

Returns

ModelMetadata<T>

A ModelMetaData object containing information about the model.

Remarks

This method provides comprehensive metadata about the model, including its type, configuration options, training status, evaluation metrics, and information about which features/lags are most important.

For Beginners: This method provides important information about the model that can help you understand its characteristics and performance.

The metadata includes:

  • The type of model (e.g., ARIMA, TBATS, Neural Network)
  • Configuration details (e.g., lag order, seasonality period)
  • Whether the model has been trained
  • Performance metrics from the last evaluation
  • Information about which features (time periods) are most influential

This information is useful for documentation, model comparison, and debugging. It's like a complete summary of everything important about the model.

PredictSingle(Vector<T>)

Generates a prediction for a single input vector.

public override T PredictSingle(Vector<T> input)

Parameters

input Vector<T>

The input feature vector.

Returns

T

The predicted value.

Remarks

This abstract method must be implemented by derived classes to generate a prediction for a single input vector using the model-specific algorithm.

For Beginners: This method takes a single row of input data (representing one time point) and calculates what the model predicts will happen at that point. Each type of time series model will have its own way of calculating this prediction based on the patterns it learned during training.

SerializeCore(BinaryWriter)

Serializes model-specific data to the binary writer.

protected override void SerializeCore(BinaryWriter writer)

Parameters

writer BinaryWriter

The binary writer to write to.

Remarks

This abstract method must be implemented by each specific model type to save its unique parameters and state.

For Beginners: This method is responsible for saving the specific details that make each type of time series model unique. Different models have different internal structures and parameters that need to be saved separately from the common elements.

For example:

  • An ARIMA model would save its AR, I, and MA coefficients
  • A TBATS model would save its level, trend, and seasonal components
  • A neural network model would save its weights and biases

This separation allows the base class to handle common serialization tasks while each model type handles its specialized data.

TrainCore(Matrix<T>, Vector<T>)

Trains the model using proper backpropagation through time (BPTT).

protected override void TrainCore(Matrix<T> x, Vector<T> y)

Parameters

x Matrix<T>
y Vector<T>
Edit this page