timesead.models.prediction ========================== .. py:module:: timesead.models.prediction Submodules ---------- .. toctree:: :maxdepth: 1 /autoapi/timesead/models/prediction/gdn/index /autoapi/timesead/models/prediction/lstm_prediction/index /autoapi/timesead/models/prediction/tcn_prediction/index Classes ------- .. autoapisummary:: timesead.models.prediction.GDN timesead.models.prediction.GDNAnomalyDetector timesead.models.prediction.LSTMPrediction timesead.models.prediction.LSTMS2SPrediction timesead.models.prediction.LSTMPredictionAnomalyDetector timesead.models.prediction.LSTMS2SPredictionAnomalyDetector timesead.models.prediction.LSTMS2STargetTransform timesead.models.prediction.TCNPrediction timesead.models.prediction.TCNS2SPrediction timesead.models.prediction.TCNPredictionAnomalyDetector timesead.models.prediction.TCNS2SPredictionAnomalyDetector Package Contents ---------------- .. py:class:: GDN(node_num: int, input_dim: int, dim=64, out_layer_hidden_dims: Sequence[int] = (64, ), topk=15, dropout_prob: float = 0.2) 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 (Comments by Tobias) Terminology is a bit confusing here, so I'll add some explanations. :param node_num: This is the number of features in the dataset, i.e., D! :param input_dim: This is the length of a TS window, i.e, T! :param dim: The dimensionality of the embedding. :param out_layer_hidden_dims: Hidden dimensions for fully connected output layer :param topk: Number of edges that should be kept in the graph construction. .. py:attribute:: edge_index_sets .. py:attribute:: embedding .. py:attribute:: bn_outlayer_in .. py:attribute:: gnn_layers .. py:attribute:: node_embedding :value: None .. py:attribute:: topk :value: 15 .. py:attribute:: learned_graph :value: None .. py:attribute:: out_layer .. py:attribute:: cache_edge_index_sets :value: [None] .. py:attribute:: cache_embed_index :value: None .. py:attribute:: dp .. py:method:: init_params() .. py:method:: forward(inputs: Tuple[torch.Tensor, Ellipsis]) -> torch.Tensor .. py:class:: GDNAnomalyDetector(model: GDN, epsilon: float = 1e-07) Bases: :py:obj:`timesead.models.common.PredictionAnomalyDetector` 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:: epsilon :value: 1e-07 .. 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 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 .. py:class:: LSTMPrediction(input_dim: int, lstm_hidden_dims: List[int] = [30, 20], linear_hidden_layers: List[int] = [], linear_activation: Union[Callable, str] = torch.nn.ELU(), prediction_horizon: int = 3) 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 LSTM prediction (Malhotra2015) :param input_dim: :param lstm_hidden_dims: :param linear_hidden_layers: :param linear_activation: :param prediction_horizon: .. py:attribute:: prediction_horizon :value: 3 .. py:attribute:: lstm .. py:attribute:: mlp .. py:method:: forward(inputs: Tuple[torch.Tensor, Ellipsis]) -> torch.Tensor .. py:class:: LSTMS2SPrediction(input_dim: int, lstm_hidden_dims: List[int] = [30, 20], linear_hidden_layers: List[int] = [], linear_activation: Union[Callable, str] = torch.nn.ELU(), dropout: float = 0.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 LSTM prediction (Filonov2016) :param input_dim: :param lstm_hidden_dims: :param linear_hidden_layers: :param linear_activation: .. py:attribute:: lstm .. py:attribute:: mlp .. py:method:: forward(inputs: Tuple[torch.Tensor, Ellipsis]) -> torch.Tensor .. py:class:: LSTMPredictionAnomalyDetector(model: LSTMPrediction) Bases: :py:obj:`timesead.models.common.PredictionAnomalyDetector` 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 Malhotra2016 :param model: .. 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 .. py:method:: get_labels_and_scores(dataset: torch.utils.data.DataLoader) -> Tuple[torch.Tensor, torch.Tensor] .. py:class:: LSTMS2SPredictionAnomalyDetector(model: LSTMS2SPrediction, half_life: int) Bases: :py:obj:`timesead.models.common.PredictionAnomalyDetector` 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 Filonov2016 :param model: :param half_life: .. py:attribute:: model .. py:attribute:: alpha .. 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, torch.Tensor, float, float]) -> Tuple[torch.Tensor, float, float] 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 .. py:method:: get_labels_and_scores(dataset: torch.utils.data.DataLoader) -> Tuple[torch.Tensor, torch.Tensor] .. py:class:: LSTMS2STargetTransform(parent: timesead.data.transforms.Transform, window_size: int, replace_labels: bool = False, reverse: bool = False) Bases: :py:obj:`timesead.data.transforms.PredictionTargetTransform` .. py:class:: TCNPrediction(input_dim: int, window_size: int, filters: Sequence[int] = (32, 32), kernel_sizes: Sequence[int] = (3, 3), linear_hidden_layers: Sequence[int] = (50, ), activation: Union[Callable, str] = torch.nn.ReLU(), prediction_horizon: int = 1) 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 DeepAnT aka TCN prediction (Munir2018) :param input_dim: :param filters: :param kernel_sizes: :param linear_hidden_layers: :param activation: :param prediction_horizon: .. py:attribute:: activation .. py:attribute:: prediction_horizon :value: 1 .. py:attribute:: pooler .. py:attribute:: conv_layers .. py:attribute:: mlp .. py:method:: forward(inputs: Tuple[torch.Tensor, Ellipsis]) -> torch.Tensor .. py:class:: TCNS2SPrediction(input_dim: int, filters: Sequence[int] = (64, 64, 64, 64, 64), kernel_sizes: Sequence[int] = (3, 3, 3, 3, 3), dilations: Sequence[int] = (1, 2, 4, 8, 16), last_n_layers_to_cat: int = 3, activation=torch.nn.ReLU()) 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 He2019 :param input_dim: :param filters: :param kernel_sizes: :param dilations: :param last_n_layers_to_cat: :param activation: .. py:attribute:: last_n_layers_to_cat :value: 3 .. py:attribute:: activation .. py:attribute:: conv_layers .. py:attribute:: final_conv .. py:method:: forward(inputs: Tuple[torch.Tensor, Ellipsis]) -> torch.Tensor .. py:class:: TCNPredictionAnomalyDetector(model: TCNPrediction) Bases: :py:obj:`timesead.models.common.PredictionAnomalyDetector` 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 Munir2018 :param model: .. 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 .. py:method:: get_labels_and_scores(dataset: torch.utils.data.DataLoader) -> Tuple[torch.Tensor, torch.Tensor] .. py:class:: TCNS2SPredictionAnomalyDetector(model: TCNS2SPrediction, offset: int) Bases: :py:obj:`timesead.models.common.PredictionAnomalyDetector` 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 He2019 :param model: .. py:attribute:: model .. py:attribute:: offset .. 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 .. py:method:: get_labels_and_scores(dataset: torch.utils.data.DataLoader) -> Tuple[torch.Tensor, torch.Tensor]