class DeepSVDD(object):
"""A class for the Deep SVDD method.
Attributes:
objective: A string specifying the Deep SVDD objective (either 'one-class' or 'soft-boundary').
nu: Deep SVDD hyperparameter nu (must be 0 < nu <= 1).
R: Hypersphere radius R.
c: Hypersphere center c.
net_name: A string indicating the name of the neural network to use.
net: The neural network \phi.
ae_net: The autoencoder network corresponding to \phi for network weights pretraining.
trainer: DeepSVDDTrainer to train a Deep SVDD model.
optimizer_name: A string indicating the optimizer to use for training the Deep SVDD network.
ae_trainer: AETrainer to train an autoencoder in pretraining.
ae_optimizer_name: A string indicating the optimizer to use for pretraining the autoencoder.
results: A dictionary to save the results.
"""
def __init__(self, objective: str = 'one-class', nu: float = 0.1):
"""Inits DeepSVDD with one of the two objectives and hyperparameter nu."""
assert objective in (
'one-class', 'soft-boundary', 'deep-GMM'
), "Objective must be either 'one-class' or 'soft-boundary'."
self.objective = objective
assert (0 < nu) & (
nu <= 1), "For hyperparameter nu, it must hold: 0 < nu <= 1."
self.nu = nu
self.R = 0.0 # hypersphere radius R
self.c = None # hypersphere center c
self.net_name = None
self.net = None # neural network \phi
self.trainer = None
self.optimizer_name = None
self.ae_net = None # autoencoder network for pretraining
self.ae_trainer = None
self.ae_optimizer_name = None
self.results = {
'train_time': None,
'test_auc': None,
'test_time': None,
'test_scores': None,
}
def set_network(self, net_name):
"""Builds the neural network \phi."""
self.net_name = net_name
self.net = build_network(net_name)
def train(self,
dataset: BaseADDataset,
optimizer_name: str = 'adam',
lr: float = 0.001,
n_epochs: int = 50,
lr_milestones: tuple = (),
batch_size: int = 128,
weight_decay: float = 1e-6,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Trains the Deep SVDD model on the training data."""
self.optimizer_name = optimizer_name
self.trainer = DeepSVDDTrainer(self.objective,
self.R,
self.c,
self.nu,
optimizer_name,
lr=lr,
n_epochs=n_epochs,
lr_milestones=lr_milestones,
batch_size=batch_size,
weight_decay=weight_decay,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
# Get the model
self.net = self.trainer.train(dataset, self.net)
self.R = float(self.trainer.R.cpu().data.numpy()) # get float
self.c = self.trainer.c.cpu().data.numpy().tolist() # get list
self.results['train_time'] = self.trainer.train_time
def test(self,
dataset: BaseADDataset,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Tests the Deep SVDD model on the test data."""
if self.trainer is None:
self.trainer = DeepSVDDTrainer(self.objective,
self.R,
self.c,
self.nu,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
self.trainer.test(dataset, self.net)
# Get results
self.results['test_auc'] = self.trainer.test_auc
self.results['test_time'] = self.trainer.test_time
self.results['test_scores'] = self.trainer.test_scores
def pretrain(self,
dataset: BaseADDataset,
optimizer_name: str = 'adam',
lr: float = 0.001,
n_epochs: int = 100,
lr_milestones: tuple = (),
batch_size: int = 128,
weight_decay: float = 1e-6,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Pretrains the weights for the Deep SVDD network \phi via autoencoder."""
self.ae_net = build_autoencoder(self.net_name)
self.ae_optimizer_name = optimizer_name
self.ae_trainer = AETrainer(optimizer_name,
lr=lr,
n_epochs=n_epochs,
lr_milestones=lr_milestones,
batch_size=batch_size,
weight_decay=weight_decay,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
self.ae_net = self.ae_trainer.train(dataset, self.ae_net)
self.ae_trainer.test(dataset, self.ae_net)
self.init_network_weights_from_pretraining()
def init_network_weights_from_pretraining(self):
"""Initialize the Deep SVDD network weights from the encoder weights of the pretraining autoencoder."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict()
# Filter out decoder network keys
ae_net_dict = {k: v for k, v in ae_net_dict.items() if k in net_dict}
# Overwrite values in the existing state_dict
net_dict.update(ae_net_dict)
# Load the new state_dict
self.net.load_state_dict(net_dict)
def save_model(self, export_model, save_ae=True):
"""Save Deep SVDD model to export_model."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict() if save_ae else None
torch.save(
{
'R': self.R,
'c': self.c,
'net_dict': net_dict,
'ae_net_dict': ae_net_dict
}, export_model)
def load_model(self, model_path, load_ae=False):
"""Load Deep SVDD model from model_path."""
model_dict = torch.load(model_path)
self.R = model_dict['R']
self.c = model_dict['c']
self.net.load_state_dict(model_dict['net_dict'])
if load_ae:
if self.ae_net is None:
self.ae_net = build_autoencoder(self.net_name)
self.ae_net.load_state_dict(model_dict['ae_net_dict'])
def save_results(self, export_json):
"""Save results dict to a JSON-file."""
with open(export_json, 'w') as fp:
json.dump(self.results, fp)
class BaseNNModel(object):
"""
Attributes:
net_name: A string indicating the name of the neural network to use.
net: The neural network phi.
trainer: Trainer to train a model.
optimizer_name: A string indicating the optimizer to use for training the Deep SAD network.
ae_net: The autoencoder network corresponding to phi for network weights pretraining.
ae_trainer: AETrainer to train an autoencoder in pretraining.
ae_optimizer_name: A string indicating the optimizer to use for pretraining the autoencoder.
results: A dictionary to save the results.
ae_results: A dictionary to save the autoencoder results.
"""
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
self.kwargs = kwargs
self.net_name = None
self.net = None # neural network phi
self.ae_net = None # autoencoder network for pretraining
self.ae_trainer = None
self.ae_optimizer_name = None
self.trainer = None
self.results = {
'train_time': None,
'auc_roc': None,
'auc_pr': None,
'test_time': None,
'test_scores': None,
}
self.ae_results = {
'train_time': None,
'auc_roc': None,
'test_time': None
}
def set_network(self, net_name):
"""Builds the neural network phi."""
self.net_name = net_name
self.net = build_network(net_name)
return self
def _train(self, trainer, dataset):
"""Trains the model on the training data."""
self.trainer = trainer
# Get the model
self.net = self.trainer.train(dataset, self.net)
self.results['train_time'] = self.trainer.train_time
return self
def train_one_step(self, epoch):
"""Trains the model on the training data."""
# Get the model
self.train_loss = self.trainer.train_one_step(self.net, epoch)
self.results['train_time'] = self.trainer.train_time
return self
def setup(self, dataset, net_name):
self.set_network(net_name)
self.trainer.setup(dataset, self.net)
return self
def set_dataset(self, dataset):
self.trainer.setup(dataset, self.net)
return self
def set_network_manual(self, net):
self.net = net
return self
def _test(self, trainer, dataset, set_split="test"):
"""Tests the Deep SAD model on the test data."""
self.trainer = trainer
self.trainer.test(dataset, self.net, set_split)
return self
def _get_output(self, trainer, dataset, set_split="test"):
"""Tests the Deep SAD model on the test data."""
self.trainer = trainer
return self.trainer.get_output(dataset, self.net, set_split)
def pretrain(self,
dataset: BaseADDataset,
optimizer_name: str = 'adam',
lr: float = 0.001,
n_epochs: int = 100,
lr_milestones: tuple = (),
batch_size: int = 128,
weight_decay: float = 1e-6,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Pretrains the weights for the Deep SAD network phi via autoencoder."""
# Set autoencoder network
self.ae_net = build_autoencoder(self.net_name)
# Train
self.ae_optimizer_name = optimizer_name
self.ae_trainer = AETrainer(optimizer_name,
lr=lr,
n_epochs=n_epochs,
lr_milestones=lr_milestones,
batch_size=batch_size,
weight_decay=weight_decay,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
self.ae_net = self.ae_trainer.train(dataset, self.ae_net)
# Get train results
self.ae_results['train_time'] = self.ae_trainer.train_time
# Test
self.ae_trainer.test(dataset, self.ae_net)
# Get test results
self.ae_results['auc_roc'] = self.ae_trainer.auc_roc
self.ae_results['test_time'] = self.ae_trainer.test_time
# Initialize Deep SAD network weights from pre-trained encoder
self.init_network_weights_from_pretraining()
return self
def init_network_weights_from_pretraining(self):
"""Initialize the Deep SAD network weights from the encoder weights of the pretraining autoencoder."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict()
# Filter out decoder network keys
ae_net_dict = {k: v for k, v in ae_net_dict.items() if k in net_dict}
# Overwrite values in the existing state_dict
net_dict.update(ae_net_dict)
# Load the new state_dict
self.net.load_state_dict(net_dict)
return self
def save_model(self, export_model_path, save_ae=False):
"""Save Deep SAD model to export_model."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict() if save_ae else None
torch.save(
{
'net_dict': net_dict,
'ae_net_dict': ae_net_dict,
**self.kwargs
}, export_model_path)
return self
def load_model(self, model_path, load_ae=False, map_location='cpu'):
"""Load Deep SAD model from model_path."""
model_dict = torch.load(model_path, map_location=map_location)
for key in self.kwargs:
setattr(self, key, model_dict[key])
self.net.load_state_dict(model_dict['net_dict'])
# load autoencoder parameters if specified
if load_ae:
if self.ae_net is None:
self.ae_net = build_autoencoder(self.net_name)
self.ae_net.load_state_dict(model_dict['ae_net_dict'])
return self
def save_results(self, export_json):
"""Save results dict to a JSON-file."""
with open(export_json, 'w') as fp:
json.dump(self.results, fp)
def save_ae_results(self, export_json):
"""Save autoencoder results dict to a JSON-file."""
with open(export_json, 'w') as fp:
json.dump(self.ae_results, fp)
class DeepSAD(object):
"""A class for the Deep SAD method.
Attributes:
eta: Deep SAD hyperparameter eta (must be 0 < eta).
c: Hypersphere center c.
net_name: A string indicating the name of the neural network to use.
net: The neural network phi.
trainer: DeepSADTrainer to train a Deep SAD model.
optimizer_name: A string indicating the optimizer to use for training the Deep SAD network.
ae_net: The autoencoder network corresponding to phi for network weights pretraining.
ae_trainer: AETrainer to train an autoencoder in pretraining.
ae_optimizer_name: A string indicating the optimizer to use for pretraining the autoencoder.
results: A dictionary to save the results.
ae_results: A dictionary to save the autoencoder results.
"""
def __init__(self, eta: float = 1.0):
"""Inits DeepSAD with hyperparameter eta."""
self.eta = eta
self.c = None # hypersphere center c
self.net_name = None
self.net = None # neural network phi
self.trainer = None
self.optimizer_name = None
self.ae_net = None # autoencoder network for pretraining
self.ae_trainer = None
self.ae_optimizer_name = None
self.results = {
'train_time': None,
'test_auc': None,
'test_time': None,
'test_scores': None,
'train_time (corner)': None,
'test_auc (corner)': None,
'test_time (corner)': None,
'test_scores (corner)': None,
}
self.ae_results = {
'train_time': None,
'test_auc': None,
'test_time': None
}
def set_network(self, net_name):
"""Builds the neural network phi."""
self.net_name = net_name
self.net = build_network(net_name)
def train(self,
dataset: BaseADDataset,
optimizer_name: str = 'adam',
lr: float = 0.001,
n_epochs: int = 50,
lr_milestones: tuple = (),
batch_size: int = 128,
weight_decay: float = 1e-6,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Trains the Deep SAD model on the training data."""
self.optimizer_name = optimizer_name
self.trainer = DeepSADTrainer(self.c,
self.eta,
optimizer_name=optimizer_name,
lr=lr,
n_epochs=n_epochs,
lr_milestones=lr_milestones,
batch_size=batch_size,
weight_decay=weight_decay,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
# Get the model
self.net = self.trainer.train(dataset, self.net)
self.results['train_time'] = self.trainer.train_time
self.c = self.trainer.c.cpu().data.numpy().tolist() # get as list
def test(self,
dataset: BaseADDataset,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Tests the Deep SAD model on the test data."""
if self.trainer is None:
self.trainer = DeepSADTrainer(self.c,
self.eta,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
# To test on two different test sets, one with and one without corner cracks.
corner_cracks = False
self.trainer.test(dataset, self.net, corner_cracks=corner_cracks)
self.results['test_auc'] = self.trainer.test_auc
self.results['test_time'] = self.trainer.test_time
self.results['test_scores'] = self.trainer.test_scores
corner_cracks = True
self.trainer.test(dataset, self.net, corner_cracks=corner_cracks)
self.results['test_auc (corner)'] = self.trainer.test_auc
self.results['test_time (corner)'] = self.trainer.test_time
self.results['test_scores (corner)'] = self.trainer.test_scores
return self.results
def pretrain(self,
dataset: BaseADDataset,
optimizer_name: str = 'adam',
lr: float = 0.001,
n_epochs: int = 100,
lr_milestones: tuple = (),
batch_size: int = 128,
weight_decay: float = 1e-6,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Pretrains the weights for the Deep SAD network phi via autoencoder."""
# Set autoencoder network
self.ae_net = build_autoencoder(self.net_name)
# Train
self.ae_optimizer_name = optimizer_name
self.ae_trainer = AETrainer(optimizer_name,
lr=lr,
n_epochs=n_epochs,
lr_milestones=lr_milestones,
batch_size=batch_size,
weight_decay=weight_decay,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
self.ae_net = self.ae_trainer.train(dataset, self.ae_net)
# Get train results
self.ae_results['train_time'] = self.ae_trainer.train_time
# Test
self.ae_trainer.test(dataset, self.ae_net)
# Get test results
self.ae_results['test_auc'] = self.ae_trainer.test_auc
self.ae_results['test_time'] = self.ae_trainer.test_time
# Initialize Deep SAD network weights from pre-trained encoder
self.init_network_weights_from_pretraining()
def init_network_weights_from_pretraining(self):
"""Initialize the Deep SAD network weights from the encoder weights of the pretraining autoencoder."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict()
# Filter out decoder network keys
ae_net_dict = {k: v for k, v in ae_net_dict.items() if k in net_dict}
# Overwrite values in the existing state_dict
net_dict.update(ae_net_dict)
# Load the new state_dict
self.net.load_state_dict(net_dict)
def save_model(self, export_model, save_ae=True):
"""Save Deep SAD model to export_model."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict() if save_ae else None
torch.save(
{
'c': self.c,
'net_dict': net_dict,
'ae_net_dict': ae_net_dict
}, export_model)
def load_model(self, model_path, load_ae=False, map_location='cpu'):
"""Load Deep SAD model from model_path."""
model_dict = torch.load(model_path, map_location=map_location)
self.c = model_dict['c']
self.net.load_state_dict(model_dict['net_dict'])
# load autoencoder parameters if specified
if load_ae:
if self.ae_net is None:
self.ae_net = build_autoencoder(self.net_name)
self.ae_net.load_state_dict(model_dict['ae_net_dict'])
def save_results(self, export_json):
"""Save results dict to a JSON-file."""
with open(export_json, 'w') as fp:
json.dump(self.results, fp)
def save_ae_results(self, export_json):
"""Save autoencoder results dict to a JSON-file."""
with open(export_json, 'w') as fp:
json.dump(self.ae_results, fp)
class DeepSVDD(object):
"""
dldm-svdd 部分的逻辑代码
"""
def __init__(self,
lstm: Lstm,
objective: str = 'one-class',
nu: float = 0.1,
n_code=8):
"""Inits DeepSVDD with one of the two objectives and hyperparameter nu."""
assert objective in (
'one-class', 'soft-boundary'
), "Objective must be either 'one-class' or 'soft-boundary'."
self.objective = objective
assert (0 < nu) & (
nu <= 1), "For hyperparameter nu, it must hold: 0 < nu <= 1."
self.nu = nu
self.n_code = n_code
self.R = 0.0
self.c = None
self.c_tensor = None
self.R_tensor = None
self.net_name = None
self.net = None # neural networks \phi
self.lstm_net = lstm.net
self.trainer = None
self.optimizer_name = None
self.ae_net = None # autoencoder networks for pretraining
self.ae_trainer = None
self.ae_optimizer_name = None
self.results = {
'train_time': None,
'test_auc': None,
'test_time': None,
'test_scores': None,
'test_score': None,
'test_fscore': None,
'test_ftr': None,
'test_tpr': None,
}
def set_network(self, net_name):
"""Builds the neural networks ."""
self.net_name = net_name
self.net = build_network(net_name, self.n_code)
def train(self,
dataset: BaseADDataset,
optimizer_name: str = 'adam',
lr: float = 0.001,
n_epochs: int = 50,
lr_milestones: tuple = (),
batch_size: int = 128,
weight_decay: float = 1e-6,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Trains the Deep SVDD model on the training data."""
self.optimizer_name = optimizer_name
self.trainer = DeepSVDDTrainer(self.objective,
self.R,
self.c,
self.nu,
optimizer_name,
lr=lr,
n_epochs=n_epochs,
lr_milestones=lr_milestones,
batch_size=batch_size,
weight_decay=weight_decay,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
# Get the model
self.net = self.trainer.train(dataset, self.net)
self.R = float(self.trainer.R.cpu().data.numpy()) # get float
self.c = self.trainer.c.cpu().data.numpy().tolist() # get list
self.R_tensor = self.trainer.R
self.c_tensor = self.trainer.c
self.results['train_time'] = self.trainer.train_time
def test(self,
dataset: BaseADDataset,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Tests the Deep SVDD model on the test data."""
if self.trainer is None:
self.trainer = DeepSVDDTrainer(objective=self.objective,
R=self.R,
c=self.c,
nu=self.nu,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
self.trainer.test(dataset, net1=self.lstm_net, net2=self.net)
# Get results
self.results['test_auc'] = self.trainer.test_auc
self.results['test_time'] = self.trainer.test_time
self.results['test_scores'] = self.trainer.test_scores
self.results['test_score'] = self.trainer.test_score
self.results['test_fscore'] = self.trainer.test_fscore
self.results['test_ftr'] = self.trainer.test_ftr
self.results['test_tpr'] = self.trainer.test_tpr
def pretrain(self,
dataset: BaseADDataset,
optimizer_name: str = 'adam',
lr: float = 0.001,
n_epochs: int = 100,
lr_milestones: tuple = (),
batch_size: int = 128,
weight_decay: float = 1e-6,
device: str = 'cuda',
n_jobs_dataloader: int = 0):
"""Pretrains the weights for the Deep SVDD networks via autoencoder."""
self.ae_net = build_autoencoder(self.net_name)
self.ae_optimizer_name = optimizer_name
self.ae_trainer = AETrainer(optimizer_name,
lr=lr,
n_epochs=n_epochs,
lr_milestones=lr_milestones,
batch_size=batch_size,
weight_decay=weight_decay,
device=device,
n_jobs_dataloader=n_jobs_dataloader)
self.ae_net = self.ae_trainer.train(dataset, self.ae_net)
self.ae_trainer.test(dataset, self.ae_net)
self.init_network_weights_from_pretraining()
def init_network_weights_from_pretraining(self):
"""Initialize the Deep SVDD networks weights from the encoder weights of the pretraining autoencoder."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict()
# Filter out decoder networks keys
ae_net_dict = {k: v for k, v in ae_net_dict.items() if k in net_dict}
# Overwrite values in the existing state_dict
net_dict.update(ae_net_dict)
# Load the new state_dict
self.net.load_state_dict(net_dict)
def save_model(self, export_model, save_ae=True):
"""Save Deep SVDD model to export_model."""
net_dict = self.net.state_dict()
ae_net_dict = self.ae_net.state_dict() if save_ae else None
torch.save(
{
'R': self.R,
'c': self.c,
'net_dict': net_dict,
'ae_net_dict': ae_net_dict
}, export_model)
def load_model(self, model_path, load_ae=False):
"""Load Deep SVDD model from model_path."""
model_dict = torch.load(model_path)
self.R = model_dict['R']
self.c = model_dict['c']
self.net.load_state_dict(model_dict['net_dict'])
if load_ae:
if self.ae_net is None:
self.ae_net = build_autoencoder(self.net_name)
self.ae_net.load_state_dict(model_dict['ae_net_dict'])
def save_results(self, export_json):
"""Save results dict to a JSON-file."""
with open(export_json, 'w') as fp:
json.dump(self.results, fp)
