def evaluate():
net.eval()
test_loss = 0
targets, outputs = [], []
with torch.no_grad():
for batch_id, (data, target) in enumerate(test_loader):
data, target = data.cuda(), target.cuda()
output = net(data)
batch_loss = criterion(output, target)
targets += [target]
outputs += [output]
test_loss += batch_loss
test_loss /= (batch_id + 1)
test_acc = compute_accuracy(torch.cat(targets), torch.cat(outputs))
targets_temp = torch.cat(targets).cpu().numpy()
outputs_temp = np.argmax(torch.cat(outputs).cpu().numpy(), axis=1)
log_string('Glomerulus Level Classification Confusion Matrix and Accuracy: ')
log_string(str(confusion_matrix(targets_temp, outputs_temp)))
# display
log_string("validation_loss: {0:.4f}, validation_accuracy: {1:.02%}"
.format(test_loss, test_acc))
return outputs, targets, test_loss
def evaluate(**kwargs):
best_loss = kwargs['best_loss']
best_acc = kwargs['best_acc']
global_step = kwargs['global_step']
net.eval()
test_loss = 0
targets, outputs = [], []
with torch.no_grad():
for batch_id, (data, target) in enumerate(test_loader):
data, target = data.cuda(), target.cuda()
output = net(data)
batch_loss = criterion(output, target)
targets += [target]
outputs += [output]
test_loss += batch_loss
test_loss /= (batch_id + 1)
test_acc = compute_accuracy(torch.cat(targets), torch.cat(outputs))
# check for improvement
loss_str, acc_str = '', ''
if test_loss <= best_loss:
loss_str, best_loss = '(improved)', test_loss
if test_acc >= best_acc:
acc_str, best_acc = '(improved)', test_acc
# display
log_string(
"validation_loss: {0:.4f} {1}, validation_accuracy: {2:.02%}{3}".
format(test_loss, loss_str, test_acc, acc_str))
# write to TensorBoard
info = {'loss': test_loss, 'accuracy': test_acc}
for tag, value in info.items():
test_logger.scalar_summary(tag, value, global_step)
# save checkpoint model
state_dict = net.state_dict()
for key in state_dict.keys():
state_dict[key] = state_dict[key].cpu()
save_path = os.path.join(model_dir, '{}.ckpt'.format(global_step))
torch.save(
{
'global_step': global_step,
'loss': test_loss,
'acc': test_acc,
'save_dir': model_dir,
'state_dict': state_dict
}, save_path)
log_string('Model saved at: {}'.format(save_path))
log_string('--' * 30)
return best_loss, best_acc
def train():
global_step = 0
best_loss = 100
best_acc = 0
for epoch in range(options.epochs):
log_string('**' * 30)
log_string('Training Epoch %03d, Learning Rate %g' %
(epoch + 1, optimizer.param_groups[0]['lr']))
net.train()
train_loss = 0
targets, outputs = [], []
for batch_id, (data, target) in enumerate(train_loader):
global_step += 1
data = data.cuda()
target = target.cuda()
# Forward pass
output = net(data)
batch_loss = criterion(output, target)
targets += [target]
outputs += [output]
train_loss += batch_loss.item()
# Backward and optimize
optimizer.zero_grad()
batch_loss.backward()
optimizer.step()
if (batch_id + 1) % options.disp_freq == 0:
train_loss /= options.disp_freq
train_acc = compute_accuracy(torch.cat(targets),
torch.cat(outputs))
log_string(
"epoch: {0}, step: {1}, train_loss: {2:.4f} train_accuracy: {3:.02%}"
.format(epoch + 1, batch_id + 1, train_loss, train_acc))
info = {'loss': train_loss, 'accuracy': train_acc}
for tag, value in info.items():
train_logger.scalar_summary(tag, value, global_step)
train_loss = 0
targets, outputs = [], []
if (batch_id + 1) % options.val_freq == 0:
log_string('--' * 30)
log_string('Evaluating at step #{}'.format(global_step))
best_loss, best_acc = evaluate(best_loss=best_loss,
best_acc=best_acc,
global_step=global_step)
net.train()
def evaluate():
net.eval()
test_loss = 0
targets, outputs = [], []
with torch.no_grad():
for batch_id, (data, target) in enumerate(test_loader):
data, target = data.cuda(), target.cuda()
output = net(data)
batch_loss = criterion(output, target)
targets += [target]
outputs += [output]
test_loss += batch_loss
test_loss /= (batch_id + 1)
return outputs, targets, test_loss
def evaluate():
net.eval()
test_loss = 0
targets, outputs = [], []
with torch.no_grad():
for batch_id, (data, target) in enumerate(test_loader):
data, target = data.cuda(), target.cuda()
output = net(data)
batch_loss = criterion(output, target)
targets += [target]
outputs += [output]
test_loss += batch_loss
test_loss /= (batch_id + 1)
test_acc = compute_accuracy(torch.cat(targets), torch.cat(outputs))
# display
log_string(
"validation_loss: {0:.4f}, validation_accuracy: {1:.02%}".format(
test_loss, test_acc))
def mc_evaluate():
net.eval()
# if options.MC:
# net.apply(apply_dropout)
test_loss = 0
targets, outputs, probs = [], [], []
with torch.no_grad():
for batch_id, (data, target) in enumerate(test_loader):
data, target = data.cuda(), target.cuda()
output = net(data)
prob = F.softmax(output)
batch_loss = criterion(output, target)
targets += [target]
outputs += [output]
probs += [prob]
test_loss += batch_loss
test_loss /= (batch_id + 1)
return torch.cat(probs).unsqueeze(0).cpu().numpy(), F.one_hot(torch.cat(targets), options.num_classes).cpu().numpy(), test_loss