timesead.models.layers.anom_attention

Classes

TriangularCausalMask
AnomalyAttention	Base class for all neural network modules.
AttentionLayer	Base class for all neural network modules.

Module Contents

class timesead.models.layers.anom_attention.TriangularCausalMask(B, L, device: str = 'cpu')

Parameters:

device (str)

property mask: torch.Tensor

Return type:

torch.Tensor

class timesead.models.layers.anom_attention.AnomalyAttention(win_size: int, mask_flag: bool = True, scale: float | None = None, attention_dropout: float = 0.0, output_attention: bool = False)

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:

• win_size (int)

• mask_flag (bool)

• scale (Optional[float])

• attention_dropout (float)

• output_attention (bool)

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

scale = None

mask_flag = True

output_attention = False

dropout

forward(queries, keys, values, sigma, attn_mask)

class timesead.models.layers.anom_attention.AttentionLayer(attention: torch.nn.Module, d_model: int, n_heads: int, d_keys: int | None = None, d_values: int | None = None)

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:

• attention (torch.nn.Module)

• d_model (int)

• n_heads (int)

• d_keys (Optional[int])

• d_values (Optional[int])

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

norm

inner_attention

query_projection

key_projection

value_projection

sigma_projection

out_projection

n_heads

forward(queries, keys, values, attn_mask)