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 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 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 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 load_ae(self, dataset_name, model_path):
"""Load pretrained autoencoder from model_path for feature extraction in a hybrid SSAD model."""
model_dict = torch.load(model_path, map_location='cpu')
ae_net_dict = model_dict['ae_net_dict']
if dataset_name in ['mnist', 'fmnist', 'cifar10']:
net_name = dataset_name + '_LeNet'
else:
net_name = dataset_name + '_mlp'
if self.ae_net is None:
self.ae_net = build_autoencoder(net_name)
# update keys (since there was a change in network definition)
ae_keys = list(self.ae_net.state_dict().keys())
for i in range(len(ae_net_dict)):
k, v = ae_net_dict.popitem(False)
new_key = ae_keys[i]
ae_net_dict[new_key] = v
i += 1
self.ae_net.load_state_dict(ae_net_dict)
self.ae_net.eval()
def train(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):
self.ae_net = build_autoencoder(self.net_name)
self.ae_optimizer_name = optimizer_name
self.ae_trainer = AEKTrainer(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=dataset, ae_net=self.ae_net,
flg=1) # 测试训练集
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,
dataset_name: str = 'mnist',
ae_loss_type: str = 'l2',
ae_only: bool = False,
model_save_path: str = ''):
"""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,
dataset_name=dataset_name,
ae_loss_type=ae_loss_type,
ae_only=ae_only)
self.ae_net = self.ae_trainer.train(dataset, self.ae_net)
if model_save_path != '':
torch.save(self.ae_net, model_save_path)
self.init_network_weights_from_pretraining()
self.ae_trainer.test(dataset, self.ae_net, self.net)
# Get results
# self.results['ae_test_auc'] = self.ae_trainer.test_auc
# self.results['ae_test_time'] = self.ae_trainer.test_time
self.results['ae_test_scores'] = self.ae_trainer.test_scores
def set_vae(self, net_name):
"""Builds the variational autoencoder network for pretraining."""
self.net_name = net_name
self.vae_net = build_autoencoder(self.net_name) # VAE for pretraining
