def confidnet_score(model, test_loader, args):
model.eval() # eval mode (batchnorm uses moving mean/variance instead of mini-batch mean/variance)
with torch.no_grad():
if args.adv == False:
correct, total = 0, 0
uncertainties, pred, groundtruth = list(), list(), list()
for i, (x, y) in enumerate(Bar(test_loader)):
x, y = x.to(args.device), y.to(args.device, dtype=torch.long)
outputs, uncertainty = model(x)
pred.append(outputs)
groundtruth.append(y)
uncertainties.append(uncertainty)
pred = torch.cat(pred).cpu().detach().numpy()
predict_label = np.argmax(pred, axis=1)
groundtruth = torch.cat(groundtruth).cpu().detach().numpy()
uncertainties = torch.cat(uncertainties).cpu().detach().numpy().flatten().tolist()
binary_predicted_true = convert_predict_and_true_to_binary(predicted=predict_label, true=groundtruth)
binary_predicted_true = [True if b == 1 else False for b in binary_predicted_true]
return uncertainties, binary_predicted_true
if args.adv == True:
uncertainties = list()
for x, _ in Bar(test_loader):
x = x.to(args.device)
outputs, uncertainty = model(x)
uncertainties.append(uncertainty)
uncertainties = torch.cat(uncertainties).cpu().detach().numpy().flatten().tolist()
return uncertainties
def train2(_model, _criterion, _optimizer, _eval_data, full_adj, full_rel,
_device, args):
eval_loss = 0
eval_pred, eval_true = np.zeros(0), np.zeros(0)
data = Rating(_eval_data)
data_loader = DataLoader(data, batch_size=args.batch_size, shuffle=True)
_model.train()
for data in Bar(data_loader):
users, items, labels = data['user'].to(_device), data['item'].to(
_device), data['label'].type(torch.float32).to(_device)
_optimizer.zero_grad()
outputs = _model(users,
items,
adj=full_adj,
rel=full_rel,
train_mode=False)
loss = _criterion(outputs, labels)
loss.backward()
_optimizer.step()
eval_loss += loss.item()
# detach outputs and labels
eval_pred = np.concatenate((eval_pred, outputs.detach().cpu().numpy()))
eval_true = np.concatenate((eval_true, labels.detach().cpu().numpy()))
logging.info(f'Eval loss: {eval_loss / len(data_loader)}')
score = utils.auc_score(eval_pred, eval_true, 'micro')
logging.info(f'Eval AUC : {score} micro')
def train(self):
"""Training the DAGMM model"""
self.model = DAGMMTS(
self.args.nin,
self.args.nh,
self.args.nout,
self.args.nlayers,
self.args.do,
self.args.n_gmm,
self.args.latent_dim,
self.args.folded
).to(self.device)
self.model.apply(weights_init_normal)
optimizer = optim.Adam(self.model.parameters(), lr=self.args.lr)
self.compute = ComputeLoss(self.model, self.args.lambda_gmm,
self.device, self.args.n_gmm)
self.model.train()
for epoch in range(self.args.num_epochs):
total_loss = 0
recon_loss = 0
gmm_loss = 0
ce_loss = 0
for batch in Bar(self.train_loader):
optimizer.zero_grad()
x = batch[0].float().to(self.device)
y = batch[1].long().to(self.device)
m = batch[2].float().to(self.device)
s = batch[3].float().to(self.device)
if self.args.folded:
p = batch[4].float().to(self.device)
_, x_hat, z, gamma = self.model(x, m, s, p)
else:
_, x_hat, z, gamma = self.model(x, m, s)
loss, reconst_loss, sample_energy, cross_entropy = self.compute.forward(x, y, x_hat, z, gamma)
loss.backward(retain_graph=True)
# torch.nn.utils.clip_grad_norm_(self.model.parameters(), 5)
optimizer.step()
total_loss += loss.item()
recon_loss += reconst_loss.item()
gmm_loss += sample_energy.item()
ce_loss += cross_entropy.item()
total_loss /= len(self.train_loader)
recon_loss /= len(self.train_loader)
gmm_loss /= len(self.train_loader)
ce_loss /= len(self.train_loader)
total_loss_val = 0
recon_loss_val = 0
gmm_loss_val = 0
ce_loss_val = 0
print('Training DAGMMTS... Epoch: {}, Loss: {:.3f}'.format(epoch, total_loss))
self.writer.add_scalars("total", {"train": total_loss, "val": total_loss_val}, global_step=epoch)
self.writer.add_scalars("recon", {"train": recon_loss, "val": recon_loss_val}, global_step=epoch)
self.writer.add_scalars("gmm", {"train": gmm_loss, "val": gmm_loss_val}, global_step=epoch)
self.writer.add_scalars("cross_entropy", {"train": ce_loss, "val": ce_loss_val}, global_step=epoch)
return
def train(self):
"""Training the autoencoder"""
self.model = ae(self.args.latent_dim).to(self.device)
self.model.apply(weights_init_normal)
optimizer = optim.Adam(self.model.parameters(), lr=self.args.lr)
scheduler = optim.lr_scheduler.MultiStepLR(
optimizer, milestones=self.args.lr_milestones, gamma=0.1)
self.reconst = []
self.reconst_t = []
for epoch in range(self.args.num_epochs):
total_loss = 0
self.model.train()
for x, _, _ in Bar(self.train_loader):
x = x.float().to(self.device)
optimizer.zero_grad()
x_hat, _ = self.model(x)
reconst_loss = F.mse_loss(x_hat, x, reduction='mean')
reconst_loss.backward()
optimizer.step()
total_loss += reconst_loss.item()
scheduler.step()
print('Training Autoencoder... Epoch: {}, Loss: {:.3f}'.format(
epoch, total_loss / len(self.train_loader)))
self.reconst.append(total_loss / len(self.train_loader))
loss_test, stop = self.test(epoch)
self.reconst_t.append(loss_test)
if stop:
break
self.load_weights()
def train(self):
"""Training the DAGMM model"""
self.model = DAGMM(self.args.n_gmm,
self.args.latent_dim).to(self.device)
self.model.apply(weights_init_normal)
optimizer = optim.Adam(self.model.parameters(), lr=self.args.lr)
self.compute = ComputeLoss(self.model, self.args.lambda_energy,
self.args.lambda_cov, self.device,
self.args.n_gmm)
self.model.train()
for epoch in range(self.args.num_epochs):
total_loss = 0
for x, _ in Bar(self.train_loader):
x = x.float().to(self.device)
optimizer.zero_grad()
_, x_hat, z, gamma = self.model(x)
loss = self.compute.forward(x, x_hat, z, gamma)
loss.backward(retain_graph=True)
torch.nn.utils.clip_grad_norm_(self.model.parameters(), 5)
optimizer.step()
total_loss += loss.item()
print('Training DAGMM... Epoch: {}, Loss: {:.3f}'.format(
epoch, total_loss / len(self.train_loader)))
def _train_epoch(self, dataloader):
self.train()
t_l1, t_ssim, t_huber = 0, 0, 0
for i, batch in enumerate(Bar(dataloader)):
self.optimizer.zero_grad()
spectrs, slen, phonemes, plen, text, durations = batch
out, pred_durations = self.forward((phonemes, plen, durations))
l1 = self.loss_l1(out, spectrs, slen)
ssim = self.loss_ssim(out, spectrs, slen)
durations[durations < 1] = 1 # needed to prevent log(0)
huber = self.loss_huber(pred_durations,
torch.log(durations.float()), plen)
loss = l1 + ssim + huber
loss.backward()
torch.nn.utils.clip_grad_norm_(self.parameters(), self.grad_clip)
self.optimizer.step()
self.step += 1
t_l1 += l1.item()
t_ssim += ssim.item()
t_huber += huber.item()
self.logger.add_scalar('batch/total', loss.item(),
self.epoch * len(dataloader) + i)
# report average cost per batch
self.logger.add_scalar('train/l1', t_l1 / i, self.epoch)
self.logger.add_scalar('train/ssim', t_ssim / i, self.epoch)
self.logger.add_scalar('train/log(durations)_huber', t_huber / i,
self.epoch)
return t_l1, t_ssim, t_huber
def pretrain(self):
""" Pretraining the weights for the deep SVDD network using autoencoder"""
ae = autoencoder(self.args.latent_dim).to(self.device)
ae.apply(weights_init_normal)
optimizer = optim.Adam(ae.parameters(),
lr=self.args.lr_ae,
weight_decay=self.args.weight_decay_ae)
scheduler = optim.lr_scheduler.MultiStepLR(
optimizer, milestones=self.args.lr_milestones, gamma=0.1)
ae.train()
for epoch in range(self.args.num_epochs_ae):
total_loss = 0
for x, _ in Bar(self.train_loader):
x = x.float().to(self.device)
optimizer.zero_grad()
x_hat = ae(x)
reconst_loss = torch.mean(
torch.sum((x_hat - x)**2, dim=tuple(range(1,
x_hat.dim()))))
reconst_loss.backward()
optimizer.step()
total_loss += reconst_loss.item()
scheduler.step()
print('Pretraining Autoencoder... Epoch: {}, Loss: {:.3f}'.format(
epoch, total_loss / len(self.train_loader)))
self.save_weights_for_DeepSVDD(ae, self.train_loader)
def pretrain(self):
"""Here we train an stacked autoencoder which will be used as the initialization for the VaDE.
This initialization is usefull because reconstruction in VAEs would be weak at the begining
and the models are likely to get stuck in local minima.
"""
ae = Autoencoder(latent_dim=self.args.latent_dim,
n_classes=self.n_classes).to(self.device)
ae.apply(weights_init_normal)
ae.apply(weights_init_normal)
optimizer = optim.Adam(ae.parameters(), lr=self.args.lr_ae)
scheduler = optim.lr_scheduler.MultiStepLR(optimizer,
milestones=self.args.lr_milestones_ae, gamma=0.1)
ae.train()
for epoch in range(self.args.num_epochs_ae):
total_loss = 0
for x, _, _ in Bar(self.dataloader_train):
x = x.float().to(self.device)
optimizer.zero_grad()
x_hat = ae(x)
reconst_loss = F.mse_loss(x_hat, x, reduction='mean')
reconst_loss.backward()
optimizer.step()
total_loss += reconst_loss.item()
scheduler.step()
print('Pretraining Autoencoder... Epoch: {}, Loss: {:.3f}'.format(
epoch, total_loss/len(self.dataloader_train)))
torch.save({'model': ae.state_dict()}, 'vade/weights/pretrained_parameters_{}.pth'.format(
self.args.anormal_class))
def test_model(dataloader, model, device):
#Initialize and accumalate ground truth, predictions, and image indices
GT = np.array(0)
Predictions = np.array(0)
running_corrects = 0
model.eval()
# Iterate over data.
with torch.no_grad():
for idx, (inputs, labels) in enumerate(Bar(dataloader)):
inputs = inputs.to(device)
labels = labels.to(device)
# forward
outputs = model(inputs.float())
_, preds = torch.max(outputs, 1)
#If validation, accumulate labels for confusion matrix
GT = np.concatenate((GT, labels.detach().cpu().numpy()), axis=None)
Predictions = np.concatenate(
(Predictions, preds.detach().cpu().numpy()), axis=None)
running_corrects += torch.sum(preds == labels.data.long())
test_acc = running_corrects.double() / len(dataloader.dataset)
print()
print('Test Accuracy: {:4f}'.format(test_acc))
return GT[1:], Predictions[1:]
def _train_epoch(self, dataloader):
self.train()
t_l1, t_att = 0, 0
for i, batch in enumerate(Bar(dataloader)):
self.optimizer.zero_grad()
spectrs, slen, phonemes, plen, text = batch
s = add_random_noise(spectrs, hp.noise)
s = degrade_some(self, s, phonemes, plen, hp.feed_ratio, repeat=hp.feed_repeat)
s = frame_dropout(s, hp.replace_ratio)
out, att_weights = self.forward(phonemes, s, plen)
l1 = self.loss_l1(out, spectrs, slen)
l_att = self.loss_att(att_weights, slen, plen)
loss = l1 + l_att
loss.backward()
torch.nn.utils.clip_grad_norm_(self.parameters(), self.grad_clip)
self.optimizer.step()
self.step += 1
t_l1 += l1.item()
t_att += l_att.item()
self.logger.add_scalar(
'batch/total', loss.item(), self.step
)
# report average cost per batch
self.logger.add_scalar('train/l1', t_l1 / i, self.epoch)
self.logger.add_scalar('train/guided_att', t_att / i, self.epoch)
return t_l1 / i, t_att / i
def train(model, dataloader, optimizer, criterion, device):
''' Runs one epoch of training for a model. '''
# Prepare the model
model.to(device)
model.train()
# Creates metrics recorder
metrics = Metrics()
# Iterates over batches
for (id_imgs, inputs, labels) in Bar(dataloader):
# Clean gradients in the optimizer
optimizer.zero_grad()
# Transforming inputs
inputs, labels = inputs.to(device), labels.to(device)
# Forward Pass
outputs = model(inputs)
# Get loss
loss = criterion(outputs, labels)
# Backward Pass, updates weights and optimizer
loss.backward()
optimizer.step()
# Register on metrics
_, predicted = torch.max(outputs.data, 1)
metrics.batch(labels=labels, preds=predicted, loss=loss.item())
# Print training metrics
metrics.print_one_liner()
def train_model(net):
total = 0
correct = 0
for epoch in range(num_epochs):
print(f'Epoch: {epoch+1}')
running_loss = 0.0
for batch_id, (inputs, labels) in enumerate(Bar(train_loader)):
# Send input tensors to device (needed for GPU support)
inputs, labels = inputs.to(device), labels.to(device)
# zero the paramater gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
# Normalizing the loss by the total number of train batches
running_loss /= len(train_loader)
# Calculate training set Accuracy
_, predicted = outputs.max(1)
total += labels.size(0)
correct += predicted.eq(labels).sum().item()
train_accuracy = 100.*correct/total
print(f"Epoch: {epoch+1} | Loss: {running_loss} | Training Accuracy: {train_accuracy}")
def validate(model, dataloader, criterion, device):
''' Runs one epoch of validation for a model. '''
# Prepare the model
model.to(device)
model.eval()
# Creates metrics recorder
metrics = Metrics()
with torch.no_grad():
# Iterates over batches
for (id_imgs, inputs, labels) in Bar(dataloader):
# Transforming inputs
inputs, labels = inputs.to(device), labels.to(device)
# Forward Pass
outputs = model(inputs)
# Get loss
loss = criterion(outputs, labels)
# Register on metrics
_, predicted = torch.max(outputs.data, 1)
metrics.batch(labels=labels, preds=predicted, loss=loss.item())
# Print and return validation metrics
return metrics.print_one_liner()
def test(self, e=None):
self.model.eval()
total_loss = 0
for x, y in Bar(self.test_generator):
y_pred = self.model(x)
loss = self.loss_fn(y_pred, y)
total_loss += float(loss.detach().numpy())
self.writer.add_scalar('Loss/test', total_loss, e)
def save_as_tensors(args, images, mean, std):
tensor_saver = TensorSaverDataset(images, args.data_dir, mean, std,
args.resize_dim)
saver_dataloader = DataLoader(tensor_saver,
batch_size=32,
shuffle=False,
num_workers=8)
for idx, data in enumerate(Bar(saver_dataloader)):
batch = data.get('image')
def run_inference(cfg: omegaconf.DictConfig) -> None:
logger.info(" .. Testing Will Be Starting in few seconds .. ")
test_df = pd.read_csv(cfg.testing.test_csv)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
checkpoints = glob.glob(
os.path.join(
cfg.general.logs_dir, "checkpoints",
f"{cfg.model.architecture_name}{cfg.classifiermode.num_classes}",
"*.ckpt"))
num_models = len(checkpoints)
if num_models == 0:
sys.exit()
if cfg.classifiermode.num_classes == 1:
test_preds = np.zeros(len(test_df))
else:
test_preds = np.zeros((len(test_df), 3))
for checkpoint_id, checkpoint_path in enumerate(checkpoints):
output_name = checkpoint_path.split("/")[2]
seed = int(checkpoint_path.split("/")[3].split(".")[0].split("_")[1])
utils.setup_environment(random_seed=seed,
gpu_list=cfg.general.gpu_list)
model = TuniziDialectClassifier.load_from_checkpoint(checkpoint_path,
hydra_config=cfg)
model.eval().to(device)
test_predictions = []
with torch.no_grad():
for batch_idx, batch in enumerate(Bar(model.test_dataloader())):
input_ids = batch["input_ids"]
attention_mask = batch["attention_mask"]
input_ids = input_ids.to(device, dtype=torch.long)
attention_mask = attention_mask.to(device, dtype=torch.long)
outputs = model.forward(input_ids,
attention_mask=attention_mask)
if cfg.classifiermode.num_classes == 1:
outputs = torch.sigmoid(outputs).detach().cpu().numpy()
test_predictions.append(outputs)
else:
outputs = torch.softmax(outputs, 1).detach().cpu().numpy()
test_predictions.append(outputs)
test_predictions = np.concatenate(test_predictions, axis=0)
if cfg.classifiermode.num_classes == 1:
test_predictions = test_predictions.reshape(
test_predictions.shape[0])
gc.collect()
torch.cuda.empty_cache()
utils.create_submission(test_df, output_name + str(seed),
test_predictions,
cfg.classifiermode.num_classes)
def eval(model, test_loader, args):
model.eval() # eval mode (batchnorm uses moving mean/variance instead of mini-batch mean/variance)
with torch.no_grad():
correct, total = 0, 0
for i, (x, y) in enumerate(Bar(test_loader)):
x, y = x.to(args.device), y.to(args.device, dtype=torch.long)
outputs, uncertainty = model(x)
_, predicted = torch.max(outputs.data, 1)
total += y.size(0)
correct += (predicted == y).sum().item()
return 100 * correct / total
def train(_model, _criterion, _optimizer, _minibatch, _train_data, _device,
_args):
global phase_iter
phase_iter += 1
logging.info(
f'\n----- Starting training phase {phase_iter} ------ Estimator Epoch: {_minibatch.num_training_batches()}'
)
epoch = 0
while not _minibatch.end():
_model.train()
logging.info(f'\n------------- Epoch: {epoch} -------------')
epoch += 1
_t0 = time.time()
node, adj, rel = _minibatch.one_batch('train')
node_tensor = torch.from_numpy(np.array(node)).to('cpu')
adj = torch.from_numpy(adj).to('cpu')
rel = torch.from_numpy(rel).to('cpu')
reserve_node = {j: i for i, j in enumerate(node)}
_t1 = time.time()
logging.info(f'Sampling sub graph in {_t1-_t0: .3f} seconds')
subgraph_rating = SubgraphRating(node, _train_data)
data_loader = DataLoader(subgraph_rating,
batch_size=_args.batch_size,
drop_last=False,
shuffle=True)
_t2 = time.time()
logging.info(f'Building DataLoader in {_t2-_t1: .3f} seconds')
train_loss, eval_loss = 0, 0
train_auc, eval_auc = [], []
train_pred, train_true = np.zeros(0), np.zeros(0)
for data in Bar(data_loader):
users, items, labels = data['user'].to(_device), data['item'].to(
_device), data['label'].type(torch.float32).to(_device)
_optimizer.zero_grad()
outputs = _model(users, items, reserve_node, node_tensor, adj, rel)
loss = _criterion(outputs, labels)
loss.backward()
_optimizer.step()
train_loss += loss.item()
# detach outputs and labels
train_pred = np.concatenate(
(train_pred, outputs.detach().cpu().numpy()))
train_true = np.concatenate(
(train_true, labels.detach().cpu().numpy()))
logging.info(f'Train loss: {train_loss / len(data_loader)}')
score = utils.auc_score(train_pred, train_true, 'micro')
logging.info(f'Train AUC : {score} micro')
def train(args):
check_paths(args)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# construct data loader
dataset = MyDataset(args.image_path, args.message_path)
loader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, num_workers=4, pin_memory=True, drop_last=False)
# construct neural networks
encoder = nets.CSFE()
decoder = nets.CSFD()
if args.cuda:
encoder.cuda()
decoder.cuda()
# construct optimizer
params = list(encoder.parameters())+list(decoder.parameters())
optimizer = torch.optim.Adam(params, lr=args.lr, betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)
# define loss
l2 = torch.nn.MSELoss()
# training loop
for e in range(args.epochs):
for img, code in Bar(loader):
# encode image and code
enc = encoder(img, code)
# channel
#nothing for now
# decode encoded image
output = decoder(enc)
# calculate loss
ber_loss = l2(output, code)
img_loss = l2(enc, img)
total_loss = ber_loss + img_loss
# occasionally print
#print(total_loss)
#backprop
optimizer.zero_grad()
total_loss.backward()
optimizer.step()
def train(args):
if args.d == 'imagenet' and args.train_uncertainty:
train_dir = '../datasets/ilsvrc2012/images/train/'
test_dir = '../datasets/ilsvrc2012/images/val_loader/'
train_loader, test_loader = load_train_and_test_loader(train_dir, test_dir, args)
if args.model == 'efficientnet-b7':
from efficientnet_pytorch_model.model import EfficientNet as efn
model = efn.from_name(args.model).to(args.device)
state_dict = EfficientNet.from_pretrained(args.model).to(args.device).state_dict()
model.load_state_dict(state_dict, strict=False)
# model = freeze_layers(model=model, freeze_uncertainty_layers=False)
# for param in model.named_parameters():
# print(param[0], param[1].requires_grad)
# exit()
# accuracy = eval(model, test_loader, args)
# print('Accuracy on testing data: %.2f' % (accuracy))
model = freeze_layers(model=model, freeze_uncertainty_layers=False)
# for param in model.named_parameters():
# print(param[0], param[1].requires_grad)
# exit()
# Loss and optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=0.00001)
for epoch in range(args.epoch):
total_loss = 0
for i, (x, y) in enumerate(Bar(train_loader)):
x, y = x.to(args.device), y.to(args.device, dtype=torch.long)
# Backward and optimize
optimizer.zero_grad()
# Forward pass
outputs, uncertainty = model(x)
loss = confid_mse_loss((outputs, uncertainty), y, args=args)
loss.backward()
total_loss += loss
optimizer.step()
# break
print('Running evaluation for uncertainty')
accuracy, roc_score = eval_uncertainty(model=model, test_loader=test_loader, args=args)
print('Epoch %i / %i -- Total loss: %f -- Accuracy on testing data: %.2f -- AUC on testing data: %.2f' % (epoch, args.epoch, total_loss, accuracy, roc_score))
path_save = './model_confidnet/%s_%s/train_uncertainty/' % (args.d, args.model)
if not os.path.exists(path_save):
os.makedirs(path_save)
torch.save(model.state_dict(), path_save + 'epoch_%i_acc-%.2f_auc-%.2f.pt' % (epoch, accuracy, roc_score))
def eval_model(model, data_loader, loss_fn, device, n_examples):
model = model.eval()
losses = []
correct_predictions = 0
with torch.no_grad():
for d in Bar(data_loader):
input_ids = d["input_ids"].to(device)
attention_mask = d["attention_mask"].to(device)
targets = d["targets"].to(device)
outputs = model(input_ids=input_ids, attention_mask=attention_mask)
_, preds = torch.max(outputs, dim=1)
loss = loss_fn(outputs, targets)
correct_predictions += torch.sum(preds == targets)
losses.append(loss.item())
return correct_predictions.double() / n_examples, np.mean(losses)
def test(self, epoch):
self.model.eval()
total_loss = 0
with torch.no_grad():
for x, _, _ in Bar(self.val_loader):
x = x.float().to(self.device)
x_hat, _ = self.model(x)
reconst_loss = F.mse_loss(x_hat, x, reduction='mean')
total_loss += reconst_loss.item()
loss = total_loss / len(self.val_loader)
print('Testing Autoencoder... Epoch: {}, Loss: {:.3}'.format(
epoch, loss))
stop = self.es.count(loss, self.model)
return loss, stop
def save_alignments_as_fertilities(model, dataloader, folder, durations_filename):
"""Save extracted alignments as durations
Use the duration_Extraction model checkpoint to extract alignments and convert them into durations.
For dataloader, use get_dataloader(64, 'cuda', start_idx=0, end_idx=13099, shuffle=False, sampler=SequentialSampler)
"""
with open(os.path.join(folder, durations_filename), 'w') as file:
for i, batch in enumerate(Bar(dataloader)):
spectrs, slen, phonemes, plen, text = batch
# supervised generation to get more reliable alignments
out, alignment = model.generate(phonemes, plen, window=1, spectrograms=spectrs)
fert = get_fertilities(alignment.cpu(), plen, slen)
for f in fert:
file.write(', '.join(str(x) for x in f) + '\n')
def test_result(model, test_loader, device):
# testing the model by turning model "Eval" mode
model.eval()
preds = []
names = []
for data, name in Bar(test_loader):
# move-tensors-to-GPU
data = data.to(device)
output = model(data)
pred = torch.sigmoid(output)
names.extend(list(name))
preds.extend(pred.tolist())
test_result = pd.DataFrame({'image_name': names, 'target': preds})
test_result.to_csv('testing.csv')
return (test_result)
def train(self):
self.model.train()
for e in range(self.n_epochs):
print("Epoch: {} of {}".format(e, self.n_epochs))
total_loss = 0
for x, y in Bar(self.training_generator):
self.model.zero_grad()
y_pred = self.model(x)
loss = self.loss_fn(y_pred, y)
loss.backward()
self.optimizer.step()
total_loss += float(loss.detach().numpy())
self.writer.add_scalar('Loss/train', total_loss, e)
if e % 10 == 0:
self.test(e)
def test(self, epoch):
self.net.eval()
total_loss = 0
with torch.no_grad():
for x, _, _ in Bar(self.dataloader_val):
x = x.float().to(self.device)
z = self.net(x)
loss = torch.mean(torch.sum((z - self.c)**2, dim=1))
total_loss += loss.item()
loss = total_loss / len(self.dataloader_val)
print('Testing Deep SVDD... Epoch: {}, Loss: {:.3}'.format(
epoch, loss))
stop = self.es.count(loss, self.net, self.c, self.args)
return loss, stop
def test_model(net):
print("Testing the model...")
global best_acc
net.eval()
correct = 0
total = 0
with torch.no_grad():
for batch_id, (inputs, targets) in enumerate(Bar(test_loader)):
# Send input tensors to device (needed for GPU support)
inputs, targets = inputs.to(device), targets.to(device)
outputs = net(inputs)
_, predicted = outputs.max(1)
total += targets.size(0)
correct += (predicted == targets).sum().item()
acc = 100.*correct/total
print(f'The test accuracy of the model is: {acc}')
def train_epoch(model, data_loader, loss_fn, optimizer, device, scheduler,
n_examples):
model = model.train()
losses = []
correct_predictions = 0
for d in Bar(data_loader):
input_ids = d["input_ids"].to(device)
attention_mask = d["attention_mask"].to(device)
targets = d["targets"].to(device)
outputs = model(input_ids=input_ids, attention_mask=attention_mask)
_, preds = torch.max(outputs, dim=1)
loss = loss_fn(outputs, targets)
correct_predictions += torch.sum(preds == targets)
losses.append(loss.item())
loss.backward()
nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()
scheduler.step()
optimizer.zero_grad()
return correct_predictions.double() / n_examples, np.mean(losses)
def train(self):
"""Training the ClasSVDD model"""
if self.args.pretrain == True:
self.load_pretrained_weights()
else:
self.net.apply(weights_init_normal)
self.c = torch.randn(self.args.latent_dim).to(self.device)
self.es = EarlyStopping(patience=self.args.patience)
optimizer = optim.Adam(self.net.parameters(),
lr=self.args.lr,
weight_decay=self.args.weight_decay)
scheduler = optim.lr_scheduler.MultiStepLR(
optimizer, milestones=self.args.lr_milestones, gamma=0.1)
self.loss = []
self.loss_t = []
for epoch in range(self.args.num_epochs):
total_loss = 0
self.net.train()
for x, y, _ in Bar(self.dataloader_train):
x = x.float().to(self.device)
y = y.long()
optimizer.zero_grad()
z = self.net(x)
loss = torch.mean(torch.sum((z - self.c[y])**2, dim=1))
loss.backward()
optimizer.step()
total_loss += loss.item()
scheduler.step()
print('Training ClasSVDD... Epoch: {}, Loss: {:.3f}'.format(
epoch, total_loss / len(self.dataloader_train)))
self.loss.append(total_loss / len(self.dataloader_train))
loss_test, stop = self.test(epoch)
self.loss_t.append(loss_test)
if stop:
break
self.load_weights()
def test_model(dataloader, model, device):
#Initialize and accumalate ground truth, predictions, and image indices
GT = np.array(0)
Predictions = np.array(0)
Index = np.array(0)
running_corrects = 0
model.eval()
# Iterate over data
print('Testing Model...')
with torch.no_grad():
for idx, (inputs, labels, index) in enumerate(Bar(dataloader)):
inputs = inputs.to(device)
labels = labels.to(device)
index = index.to(device)
# forward
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
#If test, accumulate labels for confusion matrix
GT = np.concatenate((GT, labels.detach().cpu().numpy()), axis=None)
Predictions = np.concatenate(
(Predictions, preds.detach().cpu().numpy()), axis=None)
Index = np.concatenate((Index, index.detach().cpu().numpy()),
axis=None)
running_corrects += torch.sum(preds == labels.data)
test_acc = running_corrects.double() / (len(dataloader.sampler))
print('Test Accuracy: {:4f}'.format(test_acc))
test_dict = {
'GT': GT[1:],
'Predictions': Predictions[1:],
'Index': Index[1:],
'test_acc': np.round(test_acc.cpu().numpy() * 100, 2)
}
return test_dict
