timesead.models.reconstruction.genad

Classes

`Attention`	Base class for all neural network modules.
`GENAD`	Base class for all neural network modules.
`MaskedLogCoshLoss`	Base class for all neural network modules.
`RandomMaskTransform`	Caches the results from a previous transform in memory so that expensive calculations do not have to be
`GENADDetector`	Base class for all neural network modules.

Module Contents

class timesead.models.reconstruction.genad.Attention(dim: int, heads: int = 8, dim_head: int = None, dropout: float = 0.0)

Bases: torch.nn.Module

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:

dim (int)
heads (int)
dim_head (int)
dropout (float)

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

dim_head = None

heads = 8

scale

attend

dropout

to_qkv

to_out

forward(x: torch.Tensor) → torch.Tensor

Parameters:: x (torch.Tensor)
Return type:: torch.Tensor

class timesead.models.reconstruction.genad.GENAD(input_dim: int, window_size: int, split_folds: int = 5, attention_heads: int = 12, attention_layers: int = 4, dropout: float = 0.0)

Bases: timesead.models.BaseModel

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:

input_dim (int)
window_size (int)
split_folds (int)
attention_heads (int)
attention_layers (int)
dropout (float)

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

window_size

input_dim

split_folds = 5

corr_attention_layers

ts_attention_layers

combination_weight

sigmoid

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

Parameters:: inputs (Tuple[torch.Tensor, Ellipsis])
Return type:: Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]]

class timesead.models.reconstruction.genad.MaskedLogCoshLoss(split_folds: int = 5, size_average=None, reduce=None, reduction: str = 'mean')

Bases: timesead.optim.loss.LogCoshLoss

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:

split_folds (int)
reduction (str)

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

split_folds = 5

forward(predictions: Tuple[torch.Tensor, Ellipsis], targets: Tuple[torch.Tensor, Ellipsis], *args, **kwargs) → torch.Tensor | Tuple[torch.Tensor]

Parameters:

predictions (Tuple[torch.Tensor, Ellipsis])
targets (Tuple[torch.Tensor, Ellipsis])

Return type:

Union[torch.Tensor, Tuple[torch.Tensor]]

class timesead.models.reconstruction.genad.RandomMaskTransform(parent: timesead.data.transforms.Transform, masked_fraction: float = 0.2, split_folds: int = 5)

Bases: timesead.data.transforms.Transform

Caches the results from a previous transform in memory so that expensive calculations do not have to be recomputed.

Parameters:

parent (timesead.data.transforms.Transform) – Another transform which is used as the data source for this transform.
masked_fraction (float)
split_folds (int)

masked_dims

split_folds = 5

class timesead.models.reconstruction.genad.GENADDetector(model: GENAD, threshold_frac: float = 1.05)

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 (GENAD)
threshold_frac (float)

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

model

threshold_frac = 1.05

loss

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

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

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