我们从Python开源项目中，提取了以下11个代码示例，用于说明如何使用utils.AverageMeter()。
def train(train_loader, net, criterion, optimizer, epoch, train_args): train_loss = AverageMeter() curr_iter = (epoch - 1) * len(train_loader) for i, data in enumerate(train_loader): inputs, labels = data assert inputs.size()[2:] == labels.size()[1:] N = inputs.size(0) inputs = Variable(inputs).cuda() labels = Variable(labels).cuda() optimizer.zero_grad() outputs = net(inputs) assert outputs.size()[2:] == labels.size()[1:] assert outputs.size()[1] == cityscapes.num_classes loss = criterion(outputs, labels) / N loss.backward() optimizer.step() train_loss.update(loss.data[0], N) curr_iter += 1 writer.add_scalar('train_loss', train_loss.avg, curr_iter) if (i + 1) % train_args['print_freq'] == 0: print('[epoch %d], [iter %d / %d], [train loss %.5f]' % ( epoch, i + 1, len(train_loader), train_loss.avg))
def train(train_loader, net, criterion, optimizer, epoch, train_args): train_loss = AverageMeter() curr_iter = (epoch - 1) * len(train_loader) for i, data in enumerate(train_loader): inputs, labels = data assert inputs.size()[2:] == labels.size()[1:] N = inputs.size(0) inputs = Variable(inputs).cuda() labels = Variable(labels).cuda() optimizer.zero_grad() outputs = net(inputs) assert outputs.size()[2:] == labels.size()[1:] assert outputs.size()[1] == voc.num_classes loss = criterion(outputs, labels) / N loss.backward() optimizer.step() train_loss.update(loss.data[0], N) curr_iter += 1 writer.add_scalar('train_loss', train_loss.avg, curr_iter) if (i + 1) % train_args['print_freq'] == 0: print('[epoch %d], [iter %d / %d], [train loss %.5f]' % ( epoch, i + 1, len(train_loader), train_loss.avg ))
def train(train_loader, net, criterion, optimizer, curr_epoch, train_args, val_loader, visualize): while True: train_main_loss = AverageMeter() train_aux_loss = AverageMeter() curr_iter = (curr_epoch - 1) * len(train_loader) for i, data in enumerate(train_loader): optimizer.param_groups[0]['lr'] = 2 * train_args['lr'] * (1 - float(curr_iter) / train_args['max_iter'] ) ** train_args['lr_decay'] optimizer.param_groups[1]['lr'] = train_args['lr'] * (1 - float(curr_iter) / train_args['max_iter'] ) ** train_args['lr_decay'] inputs, gts, _ = data assert len(inputs.size()) == 5 and len(gts.size()) == 4 inputs.transpose_(0, 1) gts.transpose_(0, 1) assert inputs.size()[3:] == gts.size()[2:] slice_batch_pixel_size = inputs.size(1) * inputs.size(3) * inputs.size(4) for inputs_slice, gts_slice in zip(inputs, gts): inputs_slice = Variable(inputs_slice).cuda() gts_slice = Variable(gts_slice).cuda() optimizer.zero_grad() outputs, aux = net(inputs_slice) assert outputs.size()[2:] == gts_slice.size()[1:] assert outputs.size()[1] == cityscapes.num_classes main_loss = criterion(outputs, gts_slice) aux_loss = criterion(aux, gts_slice) loss = main_loss + 0.4 * aux_loss loss.backward() optimizer.step() train_main_loss.update(main_loss.data[0], slice_batch_pixel_size) train_aux_loss.update(aux_loss.data[0], slice_batch_pixel_size) curr_iter += 1 writer.add_scalar('train_main_loss', train_main_loss.avg, curr_iter) writer.add_scalar('train_aux_loss', train_aux_loss.avg, curr_iter) writer.add_scalar('lr', optimizer.param_groups[1]['lr'], curr_iter) if (i + 1) % train_args['print_freq'] == 0: print('[epoch %d], [iter %d / %d], [train main loss %.5f], [train aux loss %.5f]. [lr %.10f]' % ( curr_epoch, i + 1, len(train_loader), train_main_loss.avg, train_aux_loss.avg, optimizer.param_groups[1]['lr'])) if curr_iter >= train_args['max_iter']: return if curr_iter % train_args['val_freq'] == 0: validate(val_loader, net, criterion, optimizer, curr_epoch, i + 1, train_args, visualize) curr_epoch += 1
def train(train_loader, net, criterion, optimizer, curr_epoch, train_args, val_loader, visualize): while True: train_main_loss = AverageMeter() train_aux_loss = AverageMeter() curr_iter = (curr_epoch - 1) * len(train_loader) for i, data in enumerate(train_loader): optimizer.param_groups[0]['lr'] = 2 * train_args['lr'] * (1 - float(curr_iter) / train_args['max_iter'] ) ** train_args['lr_decay'] optimizer.param_groups[1]['lr'] = train_args['lr'] * (1 - float(curr_iter) / train_args['max_iter'] ) ** train_args['lr_decay'] inputs, gts, _ = data assert len(inputs.size()) == 5 and len(gts.size()) == 4 inputs.transpose_(0, 1) gts.transpose_(0, 1) assert inputs.size()[3:] == gts.size()[2:] slice_batch_pixel_size = inputs.size(1) * inputs.size(3) * inputs.size(4) for inputs_slice, gts_slice in zip(inputs, gts): inputs_slice = Variable(inputs_slice).cuda() gts_slice = Variable(gts_slice).cuda() optimizer.zero_grad() outputs, aux = net(inputs_slice) assert outputs.size()[2:] == gts_slice.size()[1:] assert outputs.size()[1] == voc.num_classes main_loss = criterion(outputs, gts_slice) aux_loss = criterion(aux, gts_slice) loss = main_loss + 0.4 * aux_loss loss.backward() optimizer.step() train_main_loss.update(main_loss.data[0], slice_batch_pixel_size) train_aux_loss.update(aux_loss.data[0], slice_batch_pixel_size) curr_iter += 1 writer.add_scalar('train_main_loss', train_main_loss.avg, curr_iter) writer.add_scalar('train_aux_loss', train_aux_loss.avg, curr_iter) writer.add_scalar('lr', optimizer.param_groups[1]['lr'], curr_iter) if (i + 1) % train_args['print_freq'] == 0: print('[epoch %d], [iter %d / %d], [train main loss %.5f], [train aux loss %.5f]. [lr %.10f]' % ( curr_epoch, i + 1, len(train_loader), train_main_loss.avg, train_aux_loss.avg, optimizer.param_groups[1]['lr'])) if curr_iter >= train_args['max_iter']: return validate(val_loader, net, criterion, optimizer, curr_epoch, train_args, visualize) curr_epoch += 1
def test(model, test_loader, epoch, margin, threshlod, is_cuda=True, log_interval=1000): model.eval() test_loss = AverageMeter() accuracy = 0 num_p = 0 total_num = 0 batch_num = len(test_loader) for batch_idx, (data_a, data_p, data_n,target) in enumerate(test_loader): if is_cuda: data_a = data_a.cuda() data_p = data_p.cuda() data_n = data_n.cuda() target = target.cuda() data_a = Variable(data_a, volatile=True) data_p = Variable(data_p, volatile=True) data_n = Variable(data_n, volatile=True) target = Variable(target) out_a = model(data_a) out_p = model(data_p) out_n = model(data_n) loss = F.triplet_margin_loss(out_a,out_p,out_n, margin) dist1 = F.pairwise_distance(out_a,out_p) dist2 = F.pairwise_distance(out_a,out_n) num = ((dist1 < threshlod).float().sum() + (dist2 > threshlod).float().sum()).data[0] num_p += num num_p = 1.0 * num_p total_num += data_a.size()[0] * 2 #print('num--num_p -- total', num, num_p , total_num) test_loss.update(loss.data[0]) if (batch_idx + 1) % log_interval == 0: accuracy_tmp = num_p / total_num print('Test- Epoch {:04d}\tbatch:{:06d}/{:06d}\tAccuracy:{:.04f}\tloss:{:06f}'\ .format(epoch, batch_idx+1, batch_num, accuracy_tmp, test_loss.avg)) test_loss.reset() accuracy = num_p / total_num return accuracy
def test_vis(model, test_loader, model_path, threshlod,\ margin=1.0, is_cuda=True, output_dir='output',is_visualization=True): if not model_path is None: model.load_full_weights(model_path) print('loaded model file: {:s}'.format(model_path)) if is_cuda: model = model.cuda() model.eval() test_loss = AverageMeter() accuracy = 0 num_p = 0 total_num = 0 batch_num = len(test_loader) for batch_idx, (data_a, data_p, data_n,target, img_paths) in enumerate(test_loader): #for batch_idx, (data_a, data_p, data_n, target) in enumerate(test_loader): if is_cuda: data_a = data_a.cuda() data_p = data_p.cuda() data_n = data_n.cuda() target = target.cuda() data_a = Variable(data_a, volatile=True) data_p = Variable(data_p, volatile=True) data_n = Variable(data_n, volatile=True) target = Variable(target) out_a = model(data_a) out_p = model(data_p) out_n = model(data_n) loss = F.triplet_margin_loss(out_a,out_p,out_n, margin) dist1 = F.pairwise_distance(out_a,out_p) dist2 = F.pairwise_distance(out_a,out_n) batch_size = data_a.size()[0] pos_flag = (dist1 <= threshlod).float() neg_flag = (dist2 > threshlod).float() if is_visualization: for k in torch.arange(0, batch_size): k = int(k) if pos_flag[k].data[0] == 0: combine_and_save(img_paths[0][k], img_paths[1][k], dist1[k], output_dir, '1-1') if neg_flag[k].data[0] == 0: combine_and_save(img_paths[0][k], img_paths[2][k], dist2[k], output_dir, '1-0') num = (pos_flag.sum() + neg_flag.sum()).data[0] print('{:f}, {:f}, {:f}'.format(num, pos_flag.sum().data[0], neg_flag.sum().data[0])) num_p += num total_num += data_a.size()[0] * 2 print('num_p = {:f}, total = {:f}'.format(num_p, total_num)) print('dist1 = {:f}, dist2 = {:f}'.format(dist1[0].data[0], dist2[0].data[0])) accuracy = num_p / total_num return accuracy
def train(trainloader, model, criterion, optimizer, epoch, use_cuda): # switch to train mode model.train() batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() end = time.time() bar = Bar('Processing', max=len(trainloader)) for batch_idx, (inputs, targets) in enumerate(trainloader): # measure data loading time data_time.update(time.time() - end) if use_cuda: inputs, targets = inputs.cuda(), targets.cuda(async=True) inputs, targets = torch.autograd.Variable(inputs), torch.autograd.Variable(targets) # compute output outputs = model(inputs) loss = criterion(outputs, targets) # measure accuracy and record loss prec1, prec5 = accuracy(outputs.data, targets.data, topk=(1, 5)) losses.update(loss.data[0], inputs.size(0)) top1.update(prec1[0], inputs.size(0)) top5.update(prec5[0], inputs.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() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | top1: {top1: .4f} | top5: {top5: .4f}'.format( batch=batch_idx + 1, size=len(trainloader), data=data_time.avg, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, top1=top1.avg, top5=top5.avg, ) bar.next() bar.finish() return (losses.avg, top1.avg)
def test(testloader, model, criterion, epoch, use_cuda): global best_acc batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() # switch to evaluate mode model.eval() end = time.time() bar = Bar('Processing', max=len(testloader)) for batch_idx, (inputs, targets) in enumerate(testloader): # measure data loading time data_time.update(time.time() - end) if use_cuda: inputs, targets = inputs.cuda(), targets.cuda() inputs, targets = torch.autograd.Variable(inputs, volatile=True), torch.autograd.Variable(targets) # compute output outputs = model(inputs) loss = criterion(outputs, targets) # measure accuracy and record loss prec1, prec5 = accuracy(outputs.data, targets.data, topk=(1, 5)) losses.update(loss.data[0], inputs.size(0)) top1.update(prec1[0], inputs.size(0)) top5.update(prec5[0], inputs.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | top1: {top1: .4f} | top5: {top5: .4f}'.format( batch=batch_idx + 1, size=len(testloader), data=data_time.avg, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, top1=top1.avg, top5=top5.avg, ) bar.next() bar.finish() return (losses.avg, top1.avg)
def train(train_loader, model, criterion, optimizer, epoch, use_cuda): # switch to train mode model.train() batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() end = time.time() bar = Bar('Processing', max=len(train_loader)) for batch_idx, (inputs, targets) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) if use_cuda: inputs, targets = inputs.cuda(), targets.cuda(async=True) inputs, targets = torch.autograd.Variable(inputs), torch.autograd.Variable(targets) # compute output outputs = model(inputs) loss = criterion(outputs, targets) # measure accuracy and record loss prec1, prec5 = accuracy(outputs.data, targets.data, topk=(1, 5)) losses.update(loss.data[0], inputs.size(0)) top1.update(prec1[0], inputs.size(0)) top5.update(prec5[0], inputs.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() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | top1: {top1: .4f} | top5: {top5: .4f}'.format( batch=batch_idx + 1, size=len(train_loader), data=data_time.val, bt=batch_time.val, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, top1=top1.avg, top5=top5.avg, ) bar.next() bar.finish() return (losses.avg, top1.avg)
def test(val_loader, model, criterion, epoch, use_cuda): global best_acc batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() top1 = AverageMeter() top5 = AverageMeter() # switch to evaluate mode model.eval() end = time.time() bar = Bar('Processing', max=len(val_loader)) for batch_idx, (inputs, targets) in enumerate(val_loader): # measure data loading time data_time.update(time.time() - end) if use_cuda: inputs, targets = inputs.cuda(), targets.cuda() inputs, targets = torch.autograd.Variable(inputs, volatile=True), torch.autograd.Variable(targets) # compute output outputs = model(inputs) loss = criterion(outputs, targets) # measure accuracy and record loss prec1, prec5 = accuracy(outputs.data, targets.data, topk=(1, 5)) losses.update(loss.data[0], inputs.size(0)) top1.update(prec1[0], inputs.size(0)) top5.update(prec5[0], inputs.size(0)) # measure elapsed time batch_time.update(time.time() - end) end = time.time() # plot progress bar.suffix = '({batch}/{size}) Data: {data:.3f}s | Batch: {bt:.3f}s | Total: {total:} | ETA: {eta:} | Loss: {loss:.4f} | top1: {top1: .4f} | top5: {top5: .4f}'.format( batch=batch_idx + 1, size=len(val_loader), data=data_time.avg, bt=batch_time.avg, total=bar.elapsed_td, eta=bar.eta_td, loss=losses.avg, top1=top1.avg, top5=top5.avg, ) bar.next() bar.finish() return (losses.avg, top1.avg)
