timesead.models.generative.madgan

Classes

MADGAN

Base class for all neural network modules.

MADGANTrainer

MADGANAnomalyDetector

Module Contents

class timesead.models.generative.madgan.MADGAN(input_dim: int, latent_dim: int = 15, generator_hidden_dims: List[int] = [100, 100, 100], discriminator_hidden_dims: List[int] = [100])

Bases: timesead.models.common.GAN, 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)

  • latent_dim (int)

  • generator_hidden_dims (List[int])

  • discriminator_hidden_dims (List[int])

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

latent_dim = 15
grouped_parameters() → Tuple[Iterator[torch.nn.Parameter], Ellipsis]
Return type:

Tuple[Iterator[torch.nn.Parameter], Ellipsis]

class timesead.models.generative.madgan.MADGANTrainer(*args, disc_iterations: int = 1, gen_iterations: int = 3, **kwargs)

Bases: timesead.optim.trainer.Trainer

Parameters:

  • disc_iterations (int)

  • gen_iterations (int)

disc_iterations = 1
gen_iterations = 3
validate_batch(network: MADGAN, val_metrics: Dict[str, Callable], b_inputs: Tuple[torch.Tensor, Ellipsis], b_targets: Tuple[torch.Tensor, Ellipsis], *args, **kwargs) → Dict[str, float]
Parameters:
Return type:

Dict[str, float]

train_batch(network: MADGAN, 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]
Parameters:
Return type:

List[float]

class timesead.models.generative.madgan.MADGANAnomalyDetector(model: MADGAN, max_iter: int = 1000, lambder: float = 0.5, rec_error_tolerance: float = 0.1)

Bases: timesead.models.common.AnomalyDetector

Parameters:
model
max_iter = 1000
lambder = 0.5
rec_error_tolerance = 0.1
rbf_kernel
compute_online_anomaly_score(inputs: Tuple[torch.Tensor, Ellipsis]) → torch.Tensor
Parameters:

inputs (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor

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

inputs (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor

fit(dataset: torch.utils.data.DataLoader) → None
Parameters:

dataset (torch.utils.data.DataLoader)

Return type:

None

format_online_targets(targets: Tuple[torch.Tensor, Ellipsis]) → torch.Tensor
Parameters:

targets (Tuple[torch.Tensor, Ellipsis])

Return type:

torch.Tensor