timesead.models.reconstruction.tcn_ae

Classes

`TCNAE`	A class used to represent the Temporal Convolutional Autoencoder (TCN-AE).
`TCNAEAnomalyDetector`	Base class for all neural network modules.

Module Contents

class timesead.models.reconstruction.tcn_ae.TCNAE(input_dimension: int, dilations: List[int] = (1, 2, 4, 8, 16), nb_filters: int | List[int] = 20, kernel_size: int = 20, nb_stacks: int = 1, padding: str = 'same', dropout_rate: float = 0.0, filters_conv1d: int = 8, activation_conv1d: str | Callable = 'linear', latent_sample_rate: int = 42, pooler: Type[torch.nn.Module] = torch.nn.AvgPool1d)

Bases: timesead.models.BaseModel

A class used to represent the Temporal Convolutional Autoencoder (TCN-AE). Loss for this is logcosh

Parameters:

ts_dimension (int) – The dimension of the time series (default is 1)
dilations (tuple) – The dilation rates used in the TCN-AE model (default is (1, 2, 4, 8, 16))
nb_filters (int) – The number of filters used in the dilated convolutional layers. All dilated conv. layers use the same number of filters (default is 20)
input_dimension (int)
kernel_size (int)
nb_stacks (int)
padding (str)
dropout_rate (float)
filters_conv1d (int)
activation_conv1d (Union[str, Callable])
latent_sample_rate (int)
pooler (Type[torch.nn.Module])

tcn_enc

conv1d

activation = 'linear'

pooler

tcn_dec

linear

forward(inputs: Tuple[torch.Tensor, Ellipsis]) → torch.Tensor

Parameters:: inputs (Tuple[torch.Tensor, Ellipsis]) – Tuple with single Tensor of shape (B, T, D)
Returns:
Return type:: torch.Tensor

class timesead.models.reconstruction.tcn_ae.TCNAEAnomalyDetector(model: TCNAE, offline_window_size: int = 128)

Bases: timesead.models.common.AnomalyDetector

Base class for all neural network modules.

Your models should also subclass this class.

Modules can also contain other Modules, allowing them to be nested in a tree structure. You can assign the submodules as regular attributes:

import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

Submodules assigned in this way will be registered, and will also have their parameters converted when you call to(), etc.

Note

As per the example above, an __init__() call to the parent class must be made before assignment on the child.

Variables:

training (bool) – Boolean represents whether this module is in training or evaluation mode.

Parameters:

model (TCNAE)
offline_window_size (int)

Initialize internal Module state, shared by both nn.Module and ScriptModule.

model

offline_window_size = 128

fit(dataset: torch.utils.data.DataLoader) → None

Fit this anomaly detector on a dataset. Note that we assume only normal data here.

Parameters:: dataset (torch.utils.data.DataLoader) – A dataset
Return type:: None

compute_online_anomaly_score(inputs: Tuple[torch.Tensor, Ellipsis]) → torch.Tensor

Compute the online anomaly score for a batch of inputs. The output tensor must have the same shape as the output of format_targets when called with the corresponding targets for this batch. This method expects a window (or a batch of windows) as its input and should return a score for the last point in the window.

Parameters:: inputs (Tuple[torch.Tensor, Ellipsis]) – tuple of input tensors
Returns:: Tensor of shape (B,) that contains the anomaly scores for this batch
Return type:: torch.Tensor

compute_offline_anomaly_score(inputs: Tuple[torch.Tensor, Ellipsis]) → torch.Tensor

Compute the offline anomaly score for a batch of inputs. The output tensor must have the same shape as the output of format_targets when called with the corresponding targets for this batch. This method expects a window (or a batch of windows) as its input and should return a score for the last point in the window.

Parameters:: inputs (Tuple[torch.Tensor, Ellipsis]) – tuple of input tensors
Returns:: Tensor of shape (N,) that contains the anomaly scores for this batch
Return type:: torch.Tensor

format_online_targets(targets: Tuple[torch.Tensor, Ellipsis]) → torch.Tensor

Format the labels for a batch of targets. The output tensor must have the same shape as the output of compute_online_anomaly_score when called with the corresponding inputs for this batch.

Parameters:: targets (Tuple[torch.Tensor, Ellipsis]) – tuple of target tensors
Returns:: Tensor of shape (B,) that contains the ground truth labels for this batch
Return type:: torch.Tensor