def evaluate(self, model, print_frequency=10):
'''
Evaluate the accuracy of the model
Input:
`model`: model to be evaluated.
`print_frequency`: how often to print evaluation info.
Output:
accuracy: (float) (0~100)
'''
model = model.cuda()
model.eval()
acc = .0
num_samples = .0
with torch.no_grad():
for i, (input, target) in enumerate(self.val_loader):
input, target = input.cuda(), target.cuda()
pred = model(input)
pred = pred.argmax(dim=1)
batch_acc = torch.sum(target == pred)
acc += batch_acc.item()
num_samples += pred.shape[0]
if i % print_frequency == 0:
fns.update_progress(i, len(self.val_loader))
print(' ')
print(' ')
print('Test accuracy: {:4.2f}% '.format(float(acc / num_samples *
100)))
print(
'==================================================================='
)
return acc / num_samples * 100
def eval(test_loader, model, args):
batch_time = AverageMeter()
acc = AverageMeter()
# switch to eval mode
model.eval()
end = time.time()
for i, (images, target) in enumerate(test_loader):
if not args.no_cuda:
images = images.cuda()
target = target.cuda()
output = model(images)
batch_acc = compute_accuracy(output, target)
acc.update(batch_acc, images.size(0))
batch_time.update(time.time() - end)
end = time.time()
# Update statistics
estimated_time_remained = batch_time.get_avg()*(len(test_loader)-i-1)
fns.update_progress(i, len(test_loader),
ESA='{:8.2f}'.format(estimated_time_remained)+'s',
acc='{:4.2f}'.format(float(batch_acc))
)
print()
print('Test accuracy: {:4.2f}% (time = {:8.2f}s)'.format(
float(acc.get_avg()), batch_time.get_avg()*len(test_loader)))
print('===================================================================')
return float(acc.get_avg())
def evaluate(self, model, val_loader, print_frequency=10):
'''
Evaluate the accuracy of the model
Input:
`model`: model to be evaluated.
`print_frequency`: how often to print evaluation info.
Output:
accuracy: (float) (0~100)
'''
evaluate_begin = datetime.datetime.now()
model = model.cuda()
model.eval()
acc = .0
num_samples = .0
iterations = 0
with torch.no_grad():
for i, data in enumerate(val_loader):
input = data[0]["data"].cuda(non_blocking=True)
target = data[0]["label"].squeeze().long().cuda(
non_blocking=True)
# input, target = input.cuda(), target.cuda()
pred = model(input)
pred = pred.argmax(dim=1)
batch_acc = torch.sum(target == pred)
acc += batch_acc.item()
num_samples += pred.shape[0]
if i % print_frequency == 0:
fns.update_progress(i, 10010)
print(' ')
iterations += 1
# TODO(zhaoyx): for large dataset
if iterations > 400:
break
print(' ')
#TODO(zhaoyx): fix bug
if num_samples < 1:
print('no data, accuracy set to -1')
return -1
evaluate_end = datetime.datetime.now()
print('Evaluate time: {} seconds, {} interations'.format(
(evaluate_end - evaluate_begin).seconds, iterations))
print('Test accuracy: {:4.2f}% '.format(float(acc / num_samples *
100)))
print(
'==================================================================='
)
return acc / num_samples * 100
def save_progress(block, addresses, new_addresses, progress_file, with_db):
"""
Saves the work we've completed. If with_db is 1, we will write the
new_addresses to the database.
"""
print("Saving progress... do not close/power off computer until process is"
" complete.")
update_progress(block, addresses, progress_file)
if with_db == 1:
print("Updating database...")
update_db(new_addresses)
else:
print("Skipping database update.")
print("Progress saved. Last block scanned was {}.".format(block))
def evaluate(self, model, print_frequency=10):
'''
Evaluate the accuracy of the model
Input:
`model`: model to be evaluated.
`print_frequency`: how often to print evaluation info.
Output:
accuracy: (float) (0~100)
'''
model = model.cuda()
model.eval()
acc = .0
num_samples = .0
with torch.no_grad():
for i, (input, target) in enumerate(self.val_loader):
input, target = input.cuda(), target.cuda()
pred = model(input)
# pred = pred.argmax(dim=1)
# batch_acc = torch.sum(target == pred)
# acc += batch_acc.item()
# num_samples += pred.shape[0]
valid_mask = ((target > 0) + (pred > 0)) > 0
metric_output = 1e3 * pred[valid_mask]
metric_target = 1e3 * target[valid_mask]
maxRatio = torch.max(metric_output / metric_target, metric_target / metric_output)
delta1 = float((maxRatio < 1.25).float().mean())
# inv_output = 1.0 / pred
# inv_target = 1.0 / target
# abs_inv_diff = (inv_output - inv_target).abs()
# irmse = math.sqrt((torch.pow(abs_inv_diff, 2)).mean())
if i % print_frequency == 0:
fns.update_progress(i, len(self.val_loader))
print(' ')
print(' ')
print('Test delta1: {:4.2f}% '.format(float(delta1)))
print('===================================================================')
return delta1
def device_train(train_loader, model, args):
batch_time = AverageMeter()
losses = AverageMeter()
acc = AverageMeter()
# switch to train mode
model = model.cuda()
model.train()
criterion = torch.nn.BCEWithLogitsLoss()
if args.dataset == 'imagenet':
criterion = torch.nn.CrossEntropyLoss()
criterion.cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
print('===================================================================')
for k in range(args.local_epochs):
for i, (images, target) in enumerate(train_loader):
target.unsqueeze_(1)
target_onehot = torch.FloatTensor(target.shape[0], get_cls_num(args.dataset))
target_onehot.zero_()
target_onehot.scatter_(1, target, 1)
target.squeeze_(1)
images = images.cuda()
target_onehot = target_onehot.cuda()
target = target.cuda()
output = model(images)
if args.dataset == 'imagenet':
loss = criterion(output, target)
else:
loss = criterion(output, target_onehot)
# measure accuracy and record loss
batch_acc = compute_accuracy(output, target)
losses.update(loss.item(), images.size(0))
acc.update(batch_acc, images.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
# Update statistics
estimated_time_remained = batch_time.get_avg()*(len(train_loader)-i-1)
fns.update_progress(i, len(train_loader),
ESA='{:8.2f}'.format(estimated_time_remained)+'s',
loss='{:4.2f}'.format(loss.item()),
acc='{:4.2f}%'.format(float(batch_acc))
)
return model
def train(train_loader, model, criterion, optimizer, epoch, num_classes, args):
batch_time = AverageMeter()
losses = AverageMeter()
acc = AverageMeter()
# switch to train mode
model = model.cuda()
model.train()
print('===================================================================')
end = time.time()
for i, (images, target) in enumerate(train_loader):
target.unsqueeze_(1)
target_onehot = torch.FloatTensor(target.shape[0], num_classes)
target_onehot.zero_()
target_onehot.scatter_(1, target, 1)
target.squeeze_(1)
if not args.no_cuda:
images = images.cuda()
target_onehot = target_onehot.cuda()
target = target.cuda()
# compute output and loss
output = model(images)
if args.dataset == 'imagenet':
loss = criterion(output, target)
else:
loss = criterion(output, target_onehot)
# measure accuracy and record loss
batch_acc = compute_accuracy(output, target)
losses.update(loss.item(), images.size(0))
acc.update(batch_acc, images.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
# Update statistics
estimated_time_remained = batch_time.get_avg()*(len(train_loader)-i-1)
fns.update_progress(i, len(train_loader),
ESA='{:8.2f}'.format(estimated_time_remained)+'s',
loss='{:4.2f}'.format(loss.item()),
acc='{:4.2f}%'.format(float(batch_acc))
)
# if i > 500:
# break
print()
print('Finish epoch {}: time = {:8.2f}s, loss = {:4.2f}, acc = {:4.2f}%'.format(
epoch+1, batch_time.get_avg()*len(train_loader),
float(losses.get_avg()), float(acc.get_avg())))
print('===================================================================')
return
