def build_default_parameter(self):
if self.src_dataset.domain == "office31":
self.batchsize = 25
lr = 0.001
momentum = 0.9
l2_decay = 5e-4
self.net = build_network("office_ResNet50").to(self.device)
self.optimizer = torch.optim.SGD(
[{
'params': self.net.backbone.parameters(),
'lr': lr
}, {
'params': self.net.classifier1.parameters(),
'lr': lr * 10
}],
momentum=momentum,
weight_decay=l2_decay)
elif self.src_dataset.domain == "visda":
self.batchsize = 50
lr = 0.001
momentum = 0.9
l2_decay = 5e-4
self.net = build_network("visda_ResNet50")
self.optimizer = torch.optim.SGD(
[{
'params': self.net.backbone.parameters(),
'lr': lr
}, {
'params': self.net.classifier1.parameters(),
'lr': lr * 10
}],
momentum=momentum,
weight_decay=l2_decay)
def set_network(self, net_name, dataset, pretrained_model, embedding_size=None, attention_size=150,
n_attention_heads=3):
"""Builds the CVDD network composed of a pretrained_model, the self-attention module, and context vectors."""
self.net_name = net_name
self.net = build_network(net_name, dataset, embedding_size=embedding_size, pretrained_model=pretrained_model,
update_embedding=False, attention_size=attention_size,
n_attention_heads=n_attention_heads)
def main(dataset_name, net_name, xp_path, data_path, load_model, device, seed,
batch_size, n_jobs_dataloader, normal_class, isize, rep_dim, k,
npc_temperature, npc_momentum, ans_select_rate, ans_size):
cfg = Config(locals().copy())
# Set seed
if seed != -1:
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
# Default device to 'cpu' if cuda is not available
if not torch.cuda.is_available():
device = 'cpu'
dataset = load_dataset(dataset_name, data_path, normal_class, isize)
network = build_network(net_name, rep_dim)
lr, n_epochs, weight_decay, w_rec, w_contrast = 0, 0, 0, 0, 0
trainer = Solver(dataset, network, lr, n_epochs, batch_size, rep_dim, k,
weight_decay, device, n_jobs_dataloader, w_rec,
w_contrast, npc_temperature, npc_momentum,
ans_select_rate, ans_size, cfg)
trainer.load_model(load_model)
auc_score = trainer.test()
print("AUC score = %.5f" % (auc_score))
def main(dataset_name, net_name, xp_path, data_path, load_model, device, seed,
lr, n_epochs, batch_size, weight_decay, n_jobs_dataloader, normal_class, isize, rep_dim, k, w_rec, w_feat):
# Get configuration
cfg = Config(locals().copy())
# Set up logging
if not os.path.exists(xp_path):
os.mkdir(xp_path)
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger()
logger.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
log_file = xp_path + '/log.txt'
file_handler = logging.FileHandler(log_file)
file_handler.setLevel(logging.INFO)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# Print arguments
logger.info('Log file is %s.' % log_file)
logger.info('Data path is %s.' % data_path)
logger.info('Export path is %s.' % xp_path)
logger.info('Dataset: %s' % dataset_name)
logger.info('Normal class: %d' % normal_class)
logger.info('Network: %s' % net_name)
# Set seed
if cfg.settings['seed'] != -1:
random.seed(cfg.settings['seed'])
np.random.seed(cfg.settings['seed'])
torch.manual_seed(cfg.settings['seed'])
logger.info('Set seed to %d.' % cfg.settings['seed'])
# Default device to 'cpu' if cuda is not available
if not torch.cuda.is_available():
device = 'cpu'
logger.info('Computation device: %s' % device)
logger.info('Number of dataloader workers: %d' % n_jobs_dataloader)
# Log training details
logger.info('Training learning rate: %g' % cfg.settings['lr'])
logger.info('Training epochs: %d' % cfg.settings['n_epochs'])
logger.info('Training batch size: %d' % cfg.settings['batch_size'])
logger.info('Training weight decay: %g' % cfg.settings['weight_decay'])
logger.info('Training rep_dim: %d' % cfg.settings['rep_dim'])
logger.info('Training k: %d' % cfg.settings['k'])
logger.info('Training reconstruction loss weight: %d' % cfg.settings['w_rec'])
logger.info('Training feature consistency loss weight: %d' % cfg.settings['w_feat'])
dataset = load_dataset(dataset_name, data_path, normal_class, isize)
network = build_network(net_name, rep_dim)
trainer = Solver(dataset, network, k, lr, n_epochs, batch_size, rep_dim, k, weight_decay, device, n_jobs_dataloader, w_rec, w_feat, cfg)
trainer.train()
def set_embedding(self, dataset, embedding_size=100, pretrained_word_vectors=None, embedding_reduction='mean',
use_tfidf_weights=False, normalize_embedding=False, device: str = 'cpu'):
"""Sets the word embedding for the text data."""
self.embedding = build_network('embedding',
dataset,
embedding_size=embedding_size,
pretrained_model=pretrained_word_vectors,
update_embedding=False,
embedding_reduction=embedding_reduction,
use_tfidf_weights=use_tfidf_weights,
normalize_embedding=normalize_embedding)
self.embedding = self.embedding.to(device)
def set_network(self, net_name):
"""Builds the neural network \phi."""
self.net_name = net_name
self.net = build_network(net_name)
def set_network(self, net_name):
"""Builds the neural network."""
self.net_name = net_name
self.net = build_network(net_name,
ae_net=self.vae_net) # full M1+M2 model
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 set_network(self, net_name, n_features=9):
"""Builds the neural networks ."""
self.net_name = net_name
self.net = build_network(net_name, n_features=9)
def set_network(self, net_name, rep_dim=64, bias_terms=False):
"""Builds the neural network."""
self.net_name = net_name
self.net = build_network(net_name,
rep_dim=rep_dim,
bias_terms=bias_terms)
def set_network(self, net_name, rep_dim):
"""Builds the neural network phi."""
self.net_name = net_name
self.net = build_network(net_name, rep_dim=rep_dim)
