timesead.models.other

Submodules

Classes

`LSTMAEOCSVMAnomalyDetector`	Base class for all neural network modules.
`MTAD_GATLoss`	Base class for all neural network modules.
`MTAD_GATAnomalyDetector`	Base class for all neural network modules.
`MTAD_GAT`	Base class for all neural network modules.
`NCAD`	Neural Contrastive Detection in Time Series
`NCADAnomalyDetector`	Base class for all neural network modules.
`NCADTrainer`
`THOC`	Base class for all neural network modules.
`THOCAnomalyDetector`	Base class for all neural network modules.
`THOCLoss`	Base class for all neural network modules.
`THOCTrainer`

Package Contents

class timesead.models.other.LSTMAEOCSVMAnomalyDetector(model: timesead.models.reconstruction.lstm_ae.LSTMAE, kernel: str = 'rbf', gamma: float = 0.001, nu: float = 0.4, normalize_data: bool = False)

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 (timesead.models.reconstruction.lstm_ae.LSTMAE)
kernel (str)
gamma (float)
nu (float)
normalize_data (bool)

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

model

ocsvm

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

abstract 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

class timesead.models.other.MTAD_GATLoss(size_average=None, reduce=None, reduction: str = 'mean')

Bases: timesead.models.common.VAELoss

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:: reduction (str)

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

mse_loss

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

Parameters:

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

Return type:

torch.Tensor

class timesead.models.other.MTAD_GATAnomalyDetector(model: MTAD_GAT, gamma: float = 0.8)

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 (MTAD_GAT)
gamma (float)

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

model

gamma = 0.8

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

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

compute_online_anomaly_score(inputs: Tuple[torch.Tensor, Ellipsis]) → Tuple[torch.Tensor, 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:: Tuple[torch.Tensor, torch.Tensor]

get_labels_and_scores(dataset: torch.utils.data.DataLoader) → Tuple[torch.Tensor, torch.Tensor]

Parameters:: dataset (torch.utils.data.DataLoader)
Return type:: Tuple[torch.Tensor, 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

class timesead.models.other.MTAD_GAT(input_features: int, window_size: int = 100, gru_hidden_dim: int = 300, gru_dropout_prob: float = 0.0, mlp_hidden_dim: int | Sequence[int] = (300, 300, 300), vae_hidden_dim: int = 300)

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_features (int)
window_size (int)
gru_hidden_dim (int)
gru_dropout_prob (float)
mlp_hidden_dim (Union[int, Sequence[int]])
vae_hidden_dim (int)

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

conv_layer

feature_gat

temporal_gat

gru_layer

forecast_MLP

vae_encoder

vae_decoder

vae

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

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

class timesead.models.other.NCAD(ts_channels: int, suspect_window_length: int = 1, tcn_kernel_size: int = 7, tcn_layers: int = 8, tcn_out_channels: int = 20, tcn_maxpool_out_channels: int = 8, embedding_rep_dim: int = 120, normalize_embedding: bool = True, distance: Callable | str = l2_distance)

Bases: timesead.models.BaseModel

Neural Contrastive Detection in Time Series

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

Parameters:

ts_channels (int)
suspect_window_length (int)
tcn_kernel_size (int)
tcn_layers (int)
tcn_out_channels (int)
tcn_maxpool_out_channels (int)
embedding_rep_dim (int)
normalize_embedding (bool)
distance (Union[Callable, str])

suspect_window_length = 1

encoder

classifier

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

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

class timesead.models.other.NCADAnomalyDetector(model: NCAD)

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

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

model

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

class timesead.models.other.NCADTrainer(*args, coe_rate: float = 1.116, mixup_rate: float = 1.96, **kwargs)

Bases: timesead.optim.trainer.Trainer

Parameters:

coe_rate (float)
mixup_rate (float)

coe_rate = 1.116

mixup_rate = 1.96

validate_batch(network: torch.nn.Module, val_metrics: Dict[str, Callable], b_inputs: Tuple[torch.Tensor, Ellipsis], b_targets: Tuple[torch.Tensor, Ellipsis], *args, **kwargs) → Dict[str, float]

Parameters:

network (torch.nn.Module)
val_metrics (Dict[str, Callable])
b_inputs (Tuple[torch.Tensor, Ellipsis])
b_targets (Tuple[torch.Tensor, Ellipsis])

Return type:

Dict[str, float]

train_batch(network: NCAD, losses: List[timesead.optim.loss.Loss], optimizers: List[torch.optim.Optimizer], epoch: int, num_epochs: int, b_inputs: Tuple[torch.Tensor, Ellipsis], b_targets: Tuple[torch.Tensor, Ellipsis]) → List[float]

Parameters:

network (NCAD)
losses (List[timesead.optim.loss.Loss])
optimizers (List[torch.optim.Optimizer])
epoch (int)
num_epochs (int)
b_inputs (Tuple[torch.Tensor, Ellipsis])
b_targets (Tuple[torch.Tensor, Ellipsis])

Return type:

List[float]

class timesead.models.other.THOC(input_size, hidden_sizes: Sequence[int] | int = 128, n_hidden_layers: int | None = 3, dilations: Sequence[int] | int = [1, 2, 4], clusters_dims: Sequence[int] | int = 6, tau: float = 100.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:

hidden_sizes (Union[Sequence[int], int])
n_hidden_layers (Optional[int])
dilations (Union[Sequence[int], int])
clusters_dims (Union[Sequence[int], int])
tau (float)

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

dilations = [1, 2, 4]

clusters_dims = 6

tau = 100.0

drnn

centers

transforms

out_project

join_f

grouped_parameters() → Tuple[Iterator[torch.nn.Parameter], Ellipsis]

Return type:: Tuple[Iterator[torch.nn.Parameter], Ellipsis]

knn_init_centers(dl: torch.utils.data.DataLoader, num_batches: int)

Function that initiates the centers by Kmeans on the training set. Since taking the whole training data is to large, we only: consider the first (shuffled) num_batches batches.
dl (torch.utils.data.DataLoader): Dataloader from which we take the first num_batches batches.: Ideally the dataloader should shuffle the batches.
num_batches (int, optional): Number of batches to use for inititalization. If num_batches = 0 the: centers will not be initialized by Kmeans at all. Default is 20.

Parameters:

dl (torch.utils.data.DataLoader)
num_batches (int)

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

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

class timesead.models.other.THOCAnomalyDetector(model: THOC)

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

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

model

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

abstract 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

class timesead.models.other.THOCLoss(model: THOC, lambda_orth: float = 1.0, lambda_tss: float = 10.0)

Bases: timesead.optim.loss.Loss

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 (THOC)
lambda_orth (float)
lambda_tss (float)

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

model

lambda_orth = 1.0

lambda_tss = 10.0

thoc_loss(f_final: torch.Tensor, R_last: torch.Tensor) → torch.Tensor

Parameters:

f_final (torch.Tensor)
R_last (torch.Tensor)

Return type:

torch.Tensor

orth_loss()

tss_loss(drnn_outs: List[torch.Tensor], target: torch.Tensor) → torch.Tensor

Calclulates the time-series prediction error. (Equation 12)

inputs:: drnn_outs (torch.Tensor) x (torch.Tensor)

Parameters:

drnn_outs (List[torch.Tensor])
target (torch.Tensor)

Return type:

torch.Tensor

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

Parameters:

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

Return type:

torch.Tensor

class timesead.models.other.THOCTrainer(*args, tau_decrease_steps: int = 5, tau_decrease_gamma: float = 2.0 / 3.0, init_centers_batches: int = 20, **kwargs)

Bases: timesead.optim.trainer.Trainer

Parameters:

tau_decrease_steps (int)
tau_decrease_gamma (float)
init_centers_batches (int)

tau_decrease_steps = 5

tau_decrease_gamma = 0.6666666666666666

init_centers_batches = 20

validate_batch(network: torch.nn.Module, val_metrics: Dict[str, Callable], b_inputs: Tuple[torch.Tensor, Ellipsis], b_targets: Tuple[torch.Tensor, Ellipsis], *args, **kwargs) → Dict[str, float]

Parameters:

network (torch.nn.Module)
val_metrics (Dict[str, Callable])
b_inputs (Tuple[torch.Tensor, Ellipsis])
b_targets (Tuple[torch.Tensor, Ellipsis])

Return type:

Dict[str, float]

train_batch(network: THOC, losses: List[timesead.optim.loss.Loss], optimizers: List[torch.optim.Optimizer], epoch: int, num_epochs: int, b_inputs: Tuple[torch.Tensor, Ellipsis], b_targets: Tuple[torch.Tensor, Ellipsis]) → List[float]

Parameters:

network (THOC)
losses (List[timesead.optim.loss.Loss])
optimizers (List[torch.optim.Optimizer])
epoch (int)
num_epochs (int)
b_inputs (Tuple[torch.Tensor, Ellipsis])
b_targets (Tuple[torch.Tensor, Ellipsis])

Return type:

List[float]

train(network: THOC, *args, **kwargs)

Parameters:: network (THOC)