timesead.models.reconstruction.lstm_ae ====================================== .. py:module:: timesead.models.reconstruction.lstm_ae Classes ------- .. autoapisummary:: timesead.models.reconstruction.lstm_ae.LSTMAEDecoder timesead.models.reconstruction.lstm_ae.LSTMAEDecoderSimple timesead.models.reconstruction.lstm_ae.LSTMAEDecoderReverse timesead.models.reconstruction.lstm_ae.LSTMAE timesead.models.reconstruction.lstm_ae.LSTMAEMalhotra2016 timesead.models.reconstruction.lstm_ae.LSTMAEMirza2018 timesead.models.reconstruction.lstm_ae.LSTMAEAnomalyDetector Functions --------- .. autoapisummary:: timesead.models.reconstruction.lstm_ae.max_pool Module Contents --------------- .. py:class:: LSTMAEDecoder(enc_hidden_dimension: int, hidden_dimensions: List[int], output_dimension: int) Bases: :py:obj:`torch.nn.Module`, :py:obj:`abc.ABC` 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:method:: forward(initial_hidden: torch.Tensor, seq_len: int, x: torch.Tensor = None) -> torch.Tensor :abstractmethod: .. py:class:: LSTMAEDecoderSimple(enc_hidden_dimension: int, hidden_dimensions: List[int], output_dimension: int) Bases: :py:obj:`LSTMAEDecoder` Reconstruct the time series using a LSTM decoder, starting with an initial hidden state from the encoder that is used as input to every timestep of the decoder This corresponds to Mirza 2018 Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:attribute:: lstm .. py:method:: forward(initial_hidden: List[torch.Tensor], seq_len: int, x: torch.Tensor = None) -> torch.Tensor :param initial_hidden: list (length hidden_layers) of tensors of shape (B, D) :param seq_len: int that determines the length of the produced sequence :param x: The ground truth sequence that should be reconstructed as a tensor of shape (T, B, D). This will be fed into the LSTM during training instead of the output from the previous step. :return: Tensor of shape (T, B, D) .. py:class:: LSTMAEDecoderReverse(enc_hidden_dimension: int, hidden_dimensions: List[int], output_dimension: int) Bases: :py:obj:`LSTMAEDecoder` Reconstruct the time series in the opposite direction, starting with an initial hidden state from the encoder This corresponds to Malhotra 2016 Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:attribute:: lstm .. py:attribute:: linear .. py:method:: forward(initial_hidden: List[torch.Tensor], seq_len: int, x: torch.Tensor = None) -> torch.Tensor :param initial_hidden: tensor of shape (B, D) :param seq_len: int that determines the length of the produced sequence :param x: The ground truth sequence that should be reconstructed as a tensor of shape (T, B, D). This will be fed into the LSTM during training instead of the output from the previous step. :return: Tensor of shape (T, B, D) .. py:function:: max_pool(x: torch.Tensor, dim: int = 0) -> torch.Tensor .. py:class:: LSTMAE(input_dimension: int, hidden_dimensions=None, latent_pooling: Union[str, Callable] = 'last', decoder_class: Type[LSTMAEDecoder] = LSTMAEDecoderReverse, return_latent: bool = False) Bases: :py:obj:`timesead.models.common.AE`, :py:obj:`timesead.models.BaseModel` Generic LSTMAE implementation Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:method:: encode(x: torch.Tensor) -> List[torch.Tensor] .. py:method:: forward(inputs: Tuple[torch.Tensor]) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]] :param inputs: Tuple with a single tensor of shape (T, B, D) :return: tensor of shape (T, B, D) .. py:class:: LSTMAEMalhotra2016(input_dimension: int, hidden_dimensions=None) Bases: :py:obj:`LSTMAE` Implementation of Malhotra 2016 (https://arxiv.org/pdf/1607.00148.pdf, default parameters) Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:class:: LSTMAEMirza2018(input_dimension: int, hidden_dimensions: List[int] = [64], latent_pooling: str = 'mean') Bases: :py:obj:`LSTMAE` Mirza 2018 (http://repository.bilkent.edu.tr/bitstream/handle/11693/50234/Computer_network_intrusion_detection_using_sequential_LSTM_neural_networks_autoencoders.pdf?sequence=1) Initialize internal Module state, shared by both nn.Module and ScriptModule. .. py:attribute:: sigmoid .. py:method:: forward(inputs: Tuple[torch.Tensor]) -> Union[torch.Tensor, Tuple[torch.Tensor, torch.Tensor]] :param inputs: Tuple with a single tensor of shape (T, B, D) :return: tensor of shape (T, B, D) .. py:class:: LSTMAEAnomalyDetector(model: LSTMAE) 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:: 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:: 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:: 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