def validate(val_loader, model, criterion, epoch, tracking=None):
val_loader = tqdm.tqdm(val_loader)
batch_time = utils.AverageMeter()
losses = utils.AverageMeter()
top1 = utils.AverageMeter()
top5 = utils.AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
for i, (input, target) in enumerate(val_loader):
target = target.cuda(async=True)
input_var = torch.autograd.Variable(input, volatile=True)
target_var = torch.autograd.Variable(target, volatile=True)
# compute output
output = model(input_var)
loss = criterion(output, target_var)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.data[0], input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
if tracking is not None:
result = OrderedDict()
result['timestamp'] = datetime.now()
result['batch_duration'] = batch_time.val
result['epoch'] = epoch
result['batch'] = i
result['batch_size'] = input.size(0)
result['top1_accuracy'] = prec1[0]
result['top5_accuracy'] = prec5[0]
result['loss'] = loss.data[0]
utils.save_result(result, tracking)
desc = ('Epoch {0} (Val): '
' Loss {loss.val:.4f} ({loss.avg:.4f})'
' Prec@1 {top1.val:.3f} ({top1.avg:.3f})'
' Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
epoch,
i,
len(val_loader),
batch_time=batch_time,
loss=losses,
top1=top1,
top5=top5))
val_loader.set_description(desc)
end = time.time()
print("Evaluation: Prec@1 {top1.avg:.3f} Prec@5 {top5.avg:.3f}".format(
top1=top1, top5=top5))
return top1.avg, top5.avg
def infer_cifar10(dataset,
engine,
start=1,
end=128,
repeat=100,
log2=True,
output=None):
if log2:
start = int(np.floor(np.log2(start)))
end = int(np.ceil(np.log2(end)))
assert start >= 0
assert end >= start
batch_sizes = map(lambda x: 2**x, range(start, end + 1))
else:
batch_sizes = range(start, end + 1)
results = []
for batch_size in batch_sizes:
times = time_batch_size(dataset,
batch_size,
engine.pred,
engine.use_cuda,
repeat=repeat)
result = OrderedDict()
result['nodename'] = os.uname().nodename
result['model'] = engine.arch
result['use_cuda'] = engine.use_cuda
result['batch_size'] = batch_size
result['mean'] = np.mean(times)
result['std'] = np.std(times)
result['throughput'] = batch_size / np.mean(times)
result['path'] = engine.path
if output is not None:
save_result(result, output)
print('batch_size: {batch_size:4d}'
' - mean: {mean:.4f}'
' - std: {std:.4f}'
' - throughput: {throughput:.4f}'.format(**result))
results.append(result)
return results
def run(epoch,
model,
loader,
criterion=None,
optimizer=None,
top=(1, 5),
use_cuda=False,
tracking=None,
train=True,
half=False):
accuracies = [utils.AverageMeter() for _ in top]
assert criterion is not None or not train, 'Need criterion to train model'
assert optimizer is not None or not train, 'Need optimizer to train model'
loader = tqdm.tqdm(loader)
if train:
model.train()
losses = utils.AverageMeter()
else:
model.eval()
start = datetime.now()
for batch_index, (inputs, targets) in enumerate(loader):
inputs = Variable(inputs, requires_grad=False, volatile=not train)
targets = Variable(targets, requires_grad=False, volatile=not train)
batch_size = targets.size(0)
assert batch_size < 2**32, 'Size is too large! correct will overflow'
if use_cuda:
inputs = inputs.cuda()
targets = targets.cuda()
if half:
inputs = inputs.half()
outputs = model(inputs)
if train:
loss = criterion(outputs, targets)
optimizer.zero_grad()
loss.backward()
optimizer.step()
losses.update(loss.data[0], batch_size)
_, predictions = torch.max(outputs.data, 1)
top_correct = correct(outputs, targets, top=top)
for i, count in enumerate(top_correct):
accuracies[i].update(count * (100. / batch_size), batch_size)
end = datetime.now()
if tracking is not None:
result = OrderedDict()
result['timestamp'] = datetime.now()
result['batch_duration'] = end - start
result['epoch'] = epoch
result['batch'] = batch_index
result['batch_size'] = batch_size
for i, k in enumerate(top):
result['top{}_correct'.format(k)] = top_correct[i]
result['top{}_accuracy'.format(k)] = accuracies[i].val
if train:
result['loss'] = loss.data[0]
utils.save_result(result, tracking)
desc = 'Epoch {} {}'.format(epoch, '(Train):' if train else '(Val): ')
if train:
desc += ' Loss {loss.val:.4f} ({loss.avg:.4f})'.format(loss=losses)
for k, acc in zip(top, accuracies):
desc += ' Prec@{} {acc.val:.3f} ({acc.avg:.3f})'.format(k, acc=acc)
loader.set_description(desc)
start = datetime.now()
if train:
message = 'Training accuracy of'
else:
message = 'Validation accuracy of'
for i, k in enumerate(top):
message += ' top-{}: {}'.format(k, accuracies[i].avg)
print(message)
return accuracies[0].avg
def train_one_epoch(train_loader,
model,
criterion,
optimizer,
epoch,
tracking=None):
train_loader = tqdm.tqdm(train_loader)
batch_time = utils.AverageMeter()
data_time = utils.AverageMeter()
losses = utils.AverageMeter()
top1 = utils.AverageMeter()
top5 = utils.AverageMeter()
# switch to train mode
model.train()
end = time.time()
for i, (input, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
target = target.cuda(async=True)
input_var = torch.autograd.Variable(input)
target_var = torch.autograd.Variable(target)
# compute output
output = model(input_var)
loss = criterion(output, target_var)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.data[0], input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# compute gradient and do SGD step
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
if tracking is not None:
result = OrderedDict()
result['timestamp'] = datetime.now()
result['batch_duration'] = batch_time.val
result['epoch'] = epoch
result['batch'] = i
result['batch_size'] = input.size(0)
result['top1_accuracy'] = prec1[0]
result['top5_accuracy'] = prec5[0]
result['loss'] = loss.data[0]
result['data_duration'] = data_time.val
utils.save_result(result, tracking)
desc = ('Epoch {0} (Train):'
' Loss {loss.val:.4f} ({loss.avg:.4f})'
' Prec@1 {top1.val:.3f} ({top1.avg:.3f})'
' Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
top5=top5))
train_loader.set_description(desc)
end = time.time()
return top1.avg, top5.avg