timesead.models.other.thoc ========================== .. py:module:: timesead.models.other.thoc Classes ------- .. autoapisummary:: timesead.models.other.thoc.THOC timesead.models.other.thoc.THOCLoss timesead.models.other.thoc.THOCTrainer timesead.models.other.thoc.THOCAnomalyDetector Module Contents --------------- .. py:class:: THOC(input_size, hidden_sizes: Union[Sequence[int], int] = 128, n_hidden_layers: Optional[int] = 3, dilations: Union[Sequence[int], int] = [1, 2, 4], clusters_dims: Union[Sequence[int], int] = 6, tau: float = 100.0) Bases: :py:obj:`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 :meth:`to`, etc. .. note:: As per the example above, an ``__init__()`` call to the parent class must be made before assignment on the child. :ivar training: Boolean represents whether this module is in training or evaluation mode. :vartype training: bool Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:attribute:: dilations :value: [1, 2, 4] .. py:attribute:: clusters_dims :value: 6 .. py:attribute:: tau :value: 100.0 .. py:attribute:: drnn .. py:attribute:: centers .. py:attribute:: transforms .. py:attribute:: out_project .. py:attribute:: join_f .. py:method:: grouped_parameters() -> Tuple[Iterator[torch.nn.Parameter], Ellipsis] .. py:method:: 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. .. py:method:: forward(x: torch.Tensor) -> torch.Tensor .. py:class:: THOCLoss(model: THOC, lambda_orth: float = 1.0, lambda_tss: float = 10.0) Bases: :py:obj:`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 :meth:`to`, etc. .. note:: As per the example above, an ``__init__()`` call to the parent class must be made before assignment on the child. :ivar training: Boolean represents whether this module is in training or evaluation mode. :vartype training: bool Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:attribute:: model .. py:attribute:: lambda_orth :value: 1.0 .. py:attribute:: lambda_tss :value: 10.0 .. py:method:: thoc_loss(f_final: torch.Tensor, R_last: torch.Tensor) -> torch.Tensor .. py:method:: orth_loss() .. py:method:: 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) .. py:method:: forward(predictions: Tuple[torch.Tensor, Ellipsis], targets: Tuple[torch.Tensor, Ellipsis] = None, *args, **kwargs) -> torch.Tensor .. py:class:: THOCTrainer(*args, tau_decrease_steps: int = 5, tau_decrease_gamma: float = 2.0 / 3.0, init_centers_batches: int = 20, **kwargs) Bases: :py:obj:`timesead.optim.trainer.Trainer` .. py:attribute:: tau_decrease_steps :value: 5 .. py:attribute:: tau_decrease_gamma :value: 0.6666666666666666 .. py:attribute:: init_centers_batches :value: 20 .. py:method:: 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] .. py:method:: 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] .. py:method:: train(network: THOC, *args, **kwargs) .. py:class:: THOCAnomalyDetector(model: THOC) Bases: :py:obj:`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 :meth:`to`, etc. .. note:: As per the example above, an ``__init__()`` call to the parent class must be made before assignment on the child. :ivar training: Boolean represents whether this module is in training or evaluation mode. :vartype training: bool Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:attribute:: model .. py:method:: 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. :param inputs: tuple of input tensors :return: Tensor of shape (B,) that contains the anomaly scores for this batch .. py:method:: compute_offline_anomaly_score(inputs: Tuple[torch.Tensor, Ellipsis]) -> torch.Tensor :abstractmethod: 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. :param inputs: tuple of input tensors :return: Tensor of shape (N,) that contains the anomaly scores for this batch .. py:method:: fit(dataset: torch.utils.data.DataLoader) -> None Fit this anomaly detector on a dataset. Note that we assume only normal data here. :param dataset: A dataset .. py:method:: 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. :param targets: tuple of target tensors :return: Tensor of shape (B,) that contains the ground truth labels for this batch