timesead.models.prediction

Submodules

• timesead.models.prediction.gdn
• timesead.models.prediction.lstm_prediction
• timesead.models.prediction.tcn_prediction

Classes

GDN	Base class for all neural network modules.
GDNAnomalyDetector	Base class for all neural network modules.
LSTMPrediction	Base class for all neural network modules.
LSTMS2SPrediction	Base class for all neural network modules.
LSTMPredictionAnomalyDetector	Base class for all neural network modules.
LSTMS2SPredictionAnomalyDetector	Base class for all neural network modules.
LSTMS2STargetTransform
TCNPrediction	Base class for all neural network modules.
TCNS2SPrediction	Base class for all neural network modules.
TCNPredictionAnomalyDetector	Base class for all neural network modules.
TCNS2SPredictionAnomalyDetector	Base class for all neural network modules.

Package Contents

class timesead.models.prediction.GDN(node_num: int, input_dim: int, dim=64, out_layer_hidden_dims: Sequence[int] = (64,), topk=15, dropout_prob: float = 0.2)

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:

• node_num (int)

• input_dim (int)

• out_layer_hidden_dims (Sequence[int])

• dropout_prob (float)

(Comments by Tobias) Terminology is a bit confusing here, so I’ll add some explanations.

Parameters:

• node_num (int) – This is the number of features in the dataset, i.e., D!

• input_dim (int) – This is the length of a TS window, i.e, T!

• dim – The dimensionality of the embedding.

• out_layer_hidden_dims (Sequence[int]) – Hidden dimensions for fully connected output layer

• topk – Number of edges that should be kept in the graph construction.

• dropout_prob (float)

edge_index_sets

embedding

bn_outlayer_in

gnn_layers

node_embedding = None

topk = 15

learned_graph = None

out_layer

cache_edge_index_sets = [None]

cache_embed_index = None

dp

init_params()

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

Parameters:

inputs (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor

class timesead.models.prediction.GDNAnomalyDetector(model: GDN, epsilon: float = 1e-07)

Bases: 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 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 (GDN)

• epsilon (float)

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

model

epsilon = 1e-07

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.prediction.LSTMPrediction(input_dim: int, lstm_hidden_dims: List[int] = [30, 20], linear_hidden_layers: List[int] = [], linear_activation: Callable | str = torch.nn.ELU(), prediction_horizon: int = 3)

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_dim (int)

• lstm_hidden_dims (List[int])

• linear_hidden_layers (List[int])

• linear_activation (Union[Callable, str])

• prediction_horizon (int)

LSTM prediction (Malhotra2015) :param input_dim: :param lstm_hidden_dims: :param linear_hidden_layers: :param linear_activation: :param prediction_horizon:

prediction_horizon = 3

lstm

mlp

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

Parameters:

inputs (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor

class timesead.models.prediction.LSTMS2SPrediction(input_dim: int, lstm_hidden_dims: List[int] = [30, 20], linear_hidden_layers: List[int] = [], linear_activation: Callable | str = torch.nn.ELU(), dropout: float = 0.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:

• input_dim (int)

• lstm_hidden_dims (List[int])

• linear_hidden_layers (List[int])

• linear_activation (Union[Callable, str])

• dropout (float)

LSTM prediction (Filonov2016) :param input_dim: :param lstm_hidden_dims: :param linear_hidden_layers: :param linear_activation:

lstm

mlp

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

Parameters:

inputs (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor

class timesead.models.prediction.LSTMPredictionAnomalyDetector(model: LSTMPrediction)

Bases: 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 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 (LSTMPrediction)

Malhotra2016

Parameters:

model (LSTMPrediction)

model

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

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]

class timesead.models.prediction.LSTMS2SPredictionAnomalyDetector(model: LSTMS2SPrediction, half_life: int)

Bases: 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 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 (LSTMS2SPrediction)

• half_life (int)

Filonov2016

Parameters:

• model (LSTMS2SPrediction)

• half_life (int)

model

alpha

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, 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.

Parameters:

inputs (Tuple[torch.Tensor, torch.Tensor, float, float]) – tuple of input tensors

Returns:

Tensor of shape (B,) that contains the anomaly scores for this batch

Return type:

Tuple[torch.Tensor, float, float]

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

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]

class timesead.models.prediction.LSTMS2STargetTransform(parent: timesead.data.transforms.Transform, window_size: int, replace_labels: bool = False, reverse: bool = False)

Bases: timesead.data.transforms.PredictionTargetTransform

Parameters:

• parent (timesead.data.transforms.Transform)

• window_size (int)

• replace_labels (bool)

• reverse (bool)

class timesead.models.prediction.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: Callable | str = torch.nn.ReLU(), prediction_horizon: int = 1)

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_dim (int)

• window_size (int)

• filters (Sequence[int])

• kernel_sizes (Sequence[int])

• linear_hidden_layers (Sequence[int])

• activation (Union[Callable, str])

• prediction_horizon (int)

DeepAnT aka TCN prediction (Munir2018) :param input_dim: :param filters: :param kernel_sizes: :param linear_hidden_layers: :param activation: :param prediction_horizon:

activation

prediction_horizon = 1

pooler

conv_layers

mlp

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

Parameters:

inputs (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor

class timesead.models.prediction.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: 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_dim (int)

• filters (Sequence[int])

• kernel_sizes (Sequence[int])

• dilations (Sequence[int])

• last_n_layers_to_cat (int)

He2019

Parameters:

• input_dim (int)

• filters (Sequence[int])

• kernel_sizes (Sequence[int])

• dilations (Sequence[int])

• last_n_layers_to_cat (int)

• activation

last_n_layers_to_cat = 3

activation

conv_layers

final_conv

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

Parameters:

inputs (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor

class timesead.models.prediction.TCNPredictionAnomalyDetector(model: TCNPrediction)

Bases: 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 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 (TCNPrediction)

Munir2018

Parameters:

model (TCNPrediction)

model

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

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]

class timesead.models.prediction.TCNS2SPredictionAnomalyDetector(model: TCNS2SPrediction, offset: int)

Bases: 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 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 (TCNS2SPrediction)

• offset (int)

He2019

Parameters:

• model (TCNS2SPrediction)

• offset (int)

model

offset

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

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]