Table of Contents

Class LSTMVAE<T>

Namespace
AiDotNet.TimeSeries.AnomalyDetection
Assembly
AiDotNet.dll

Implements LSTM-VAE (Long Short-Term Memory Variational Autoencoder) for anomaly detection.

public class LSTMVAE<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
LSTMVAE<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

LSTM-VAE combines the sequential modeling capabilities of LSTMs with the probabilistic framework of Variational Autoencoders. It learns a compressed latent representation of normal time series patterns and detects anomalies as points with high reconstruction error.

Key components: - LSTM Encoder: Compresses time series into latent space - Latent Space: Probabilistic representation (mean and variance) - LSTM Decoder: Reconstructs time series from latent representation - Anomaly Detection: Based on reconstruction error and KL divergence

For Beginners: LSTM-VAE is like a compression and decompression system for time series: 1. The encoder "compresses" your time series into a simpler representation 2. The decoder tries to "decompress" it back to the original 3. For normal patterns, this works well (low reconstruction error) 4. For anomalies, the reconstruction is poor (high error) because the model hasn't seen such patterns

Think of it like a photocopier that's been trained on normal documents - it copies normal pages perfectly but produces poor copies of unusual documents, making them easy to identify.

Constructors

LSTMVAE(LSTMVAEOptions<T>?)

Initializes a new instance of the LSTMVAE class.

public LSTMVAE(LSTMVAEOptions<T>? options = null)

Parameters

options LSTMVAEOptions<T>

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

ComputeAnomalyScores(Matrix<T>)

Computes anomaly scores for a time series.

public Vector<T> ComputeAnomalyScores(Matrix<T> data)

Parameters

data Matrix<T>

Returns

Vector<T>

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.

DetectAnomalies(Matrix<T>)

Detects anomalies in a time series using reconstruction error.

public bool[] DetectAnomalies(Matrix<T> data)

Parameters

data Matrix<T>

Returns

bool[]

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

Performs the model-specific training algorithm.

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

Parameters

x Matrix<T>

The input features matrix.

y Vector<T>

The target values vector.

Remarks

This abstract method must be implemented by derived classes to perform the actual model training.

For Beginners: This is where the specific math and algorithms for each type of time series model are implemented. Different models (like ARIMA, Exponential Smoothing, etc.) will have their own unique ways of finding patterns in the data.

Edit this page