Auto Encoder

class dtaianomaly.anomaly_detection.AutoEncoder(window_size: str | int, error_metric: Literal['mean-absolute-error', 'mean-squared-error'] = 'mean-absolute-error', encoder_dimensions: list[int] = (64,), latent_space_dimension: int = 32, decoder_dimensions: list[int] = (64,), dropout_rate: float = 0.2, activation_function: Literal['linear', 'relu', 'sigmoid', 'tanh'] = 'relu', batch_normalization: bool = True, stride: int = 1, standard_scaling: bool = True, batch_size: int = 32, data_loader_kwargs: dict[str, any] = None, optimizer: Literal['adam', 'sgd'] | Callable[[any], Optimizer] = 'adam', learning_rate: float = 0.001, compile_model: bool = False, compile_mode: Literal['default', 'reduce-overhead', 'max-autotune', 'max-autotune-no-cudagraphs'] = 'default', n_epochs: int = 10, loss_function: Module = MSELoss(), device: str = 'cpu', seed: int = None)[source]

Use an auto encoder to detect anomalies [22].

An auto encoder is a neural network that consists of two parts: an encoder and a decoder. The encoder maps the input features to a lower dimensional space, the latent space, while the decoder reconstructs the latent embedding back into the original feature space. Samples that are common during the training phase (i.e., normal behavior) are more easily reconstructed compared to rare observations (i.e., anomalies). Thus, anomalies are detected by reconstructing the time series data and measuring the deviation of the reconstruction from the original data.

The architecture of the autoencoder consists of blocks, in which each block applies the following operations: fully-connected layer \(\rightarrow\) batch normalization \(\rightarrow\) activation function \(\rightarrow\) dropout layer. The first layer of the encoder has no batch normalization, and the final layer of the decoder has no batch normalization nor dropout.

Parameters:

window_size (int or str) – The window size to use for extracting sliding windows from the time series. This value will be passed to compute_window_size().
error_metric ({"mean-absolute-error", "mean-squared-error"}, default="mean-absolute-error") – The error measure between the reconstructed window and the original window.
encoder_dimensions (list of ints, default=[64]) – The number of neurons in each layer of the encoder. If an empty list is given, then the input of the encoder is directly connected to the latent space in a fully-connected manner.
latent_space_dimension (int default=32) – The dimension of the latent space.
decoder_dimensions (list of ints, default=[64]) – The number of neurons in each layer of the decoder. If an empty list is given, then the latent space is directly connected to the output in a fully-connected manner.
dropout_rate (float in interval [0, 1[, default=0.2) – The dropout rate for the dropout layers. If the dropout rate is 0, no dropout layers will be added to the auto encoder.
activation_function ({"linear", "relu", "sigmoid", "tanh"} default="relu") – The activation function to use at the end of each layer.
batch_normalization (bool = True,) – Whether to add batch normalization after each layer or not.
stride (int, default=1) – The stride, i.e., the step size for extracting sliding windows from the time series.
standard_scaling (bool, default=True) – Whether to standard scale each window independently, before feeding it to the network.
batch_size (int, default=32) – The size of the batches to feed to the network.
data_loader_kwargs (dictionary, default=None) – Additional kwargs to be passed to the data loader. For more information, see: https://docs.pytorch.org/docs/stable/data.html
optimizer ({"adam", "sgd"} or callable default="adam") – The optimizer to use for learning the weights. If “adam” is given, then the torch.optim.Adam optimizer will be used. If “sgd” is given, then the torch.optim.SGD optimizer will be used. Otherwise, a callable should be given, which takes as input the network parameters, and then creates an optimizer.
learning_rate (float, default=1e-3) – The learning rate to use for training the network. Has no effect if optimize is a callable.
compile_model (bool, default=False) – Whether the network architecture should be compiled or not before training the weights. For more information, see: https://docs.pytorch.org/docs/stable/generated/torch.compile.html
compile_mode ({"default", "reduce-overhead", "max-autotune", "max-autotune-no-cudagraphs"}, default="default") – Method to compile the architecture. For more information, see: https://docs.pytorch.org/docs/stable/generated/torch.compile.html
n_epochs (int, default=10) – The number of epochs for which the neural network should be trained.
loss_function (torch.nn.Module, default=torch.nn.MSELoss()) – The loss function to use for updating the weights.
device (str, default="cpu") – The device on which te neural network should be trained. For more information, see: https://docs.pytorch.org/docs/stable/tensor_attributes.html#torch-device
seed (int, default=None) – The seed used for training the model. This seed will update the torch and numpy seed at the beginning of the fit method.

window_size_

The effectively used window size for this anomaly detector.

Type:: int

optimizer_

The optimizer used for learning the weights of the network.

Type:: torch.optim.Optimizer

neural_network_

The PyTorch network architecture.

Type:: torch.nn.Module

Examples

>>> from dtaianomaly.anomaly_detection import AutoEncoder
>>> from dtaianomaly.data import demonstration_time_series
>>> x, y = demonstration_time_series()
>>> auto_encoder = AutoEncoder(10, seed=0).fit(x)
>>> auto_encoder.decision_function(x)
array([0.59210092, 0.56707534, 0.56629006, ..., 0.58380051, 0.5808109 , 0.54450774]...)