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))
python类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] == 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, 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, 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)
