def train(train_loader, model, criterion, optimizer, epoch, args, print_func):
batch_time = CNN_utils.AverageMeter()
data_time = CNN_utils.AverageMeter()
losses = CNN_utils.AverageMeter()
top1 = CNN_utils.AverageMeter()
top5 = CNN_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)
if args.gpu is not None:
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
kout = 5
if args.num_classes < kout * 2:
kout = args.num_classes // 2
if kout < 1:
kout = 1
prec1, prec5 = CNN_utils.accuracy(output, target, topk=(1, kout))
losses.update(loss.item(), 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)
end = time.time()
if i % args.print_freq == 0:
print_func('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@{kout} {top5.val:.3f} ({top5.avg:.3f})'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
kout=kout,
top5=top5))
def train(train_loader, model, criterion, optimizer, epoch, args, print_func):
batch_time = CNN_utils.AverageMeter()
data_time = CNN_utils.AverageMeter()
losses = CNN_utils.AverageMeter()
top1 = CNN_utils.AverageMeter()
top5 = CNN_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)
if args.gpu is not None:
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# target_idx = target.nonzero() [:,1]
# compute output
output = model(input)
# log_softmax_output = F.log_softmax(output, dim=1)
#
# loss = - torch.sum(log_softmax_output * target) / output.shape[0]
loss = criterion(output, target)
losses.update(loss.item(), input.size(0))
prec1 = CNN_utils.accuracy(output, target, topk=(1, 1))
top1.update(prec1[0].item(), input.size(0))
# top5.update(prec5[0], input.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print_func('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@{kout} {top5.val:.3f} ({top5.avg:.3f})'.format(
epoch,
i,
len(train_loader),
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
kout=5,
top5=top5))
def train(train_loader, model, criterion, optimizer, epoch, args, print_func):
batch_time = CNN_utils.AverageMeter()
data_time = CNN_utils.AverageMeter()
losses = CNN_utils.AverageMeter()
top1 = CNN_utils.AverageMeter()
topX = CNN_utils.AverageMeter()
kout = args.topX or args.num_classes // 2
# switch to train mode
model.train()
if args.fix_BN:
CNN_utils.fix_BN(model)
end = time.time()
for i, (input, target) in enumerate(train_loader):
# measure data loading time
data_time.update(time.time() - end)
if args.gpu is not None:
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# target_idx = target.nonzero() [:,1]
# compute output
output = model(input)
loss = criterion(output, target)
losses.update(loss.item(), input.size(0))
prec1, precX = CNN_utils.accuracy(output, target, topk=(1, kout))
top1.update(prec1[0], input.size(0))
topX.update(precX[0], input.size(0))
optimizer.zero_grad()
loss.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print_func('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@{kout} {topX.val:.3f} ({topX.avg:.3f})'.format(
epoch, i, len(train_loader), batch_time=batch_time,
data_time=data_time, loss=losses, top1=top1, kout=kout, topX=topX))
def validate(val_loader, model, criterion, args, print_func):
if val_loader is None:
return 0, 0
batch_time = CNN_utils.AverageMeter()
losses = CNN_utils.AverageMeter()
top1 = CNN_utils.AverageMeter()
topX = CNN_utils.AverageMeter()
kout = args.topX or args.num_classes // 2
# switch to evaluate mode
model.eval()
with torch.no_grad():
end = time.time()
for i, (input, target) in enumerate(val_loader):
if args.gpu is not None:
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# compute output
output = model(input)
loss = criterion(output, target)
losses.update(loss.item(), input.size(0))
prec1, precX = CNN_utils.accuracy(output, target, topk=(1, kout))
top1.update(prec1[0], input.size(0))
topX.update(precX[0], input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print_func('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@{kout} {topX.val:.3f} ({topX.avg:.3f})'.format(
i, len(val_loader), batch_time=batch_time, loss=losses,
top1=top1, kout=kout, topX = topX))
print_func(' * Prec@1 {top1.avg:.3f}'
.format(top1=top1))
return top1.avg, losses.avg
def validate(val_loader, model, criterion, args, print_func):
if val_loader is None:
return 0, 0
batch_time = CNN_utils.AverageMeter()
losses = CNN_utils.AverageMeter()
top1 = CNN_utils.AverageMeter()
# top5 = CNN_utils.AverageMeter()
# switch to evaluate mode
model.eval()
with torch.no_grad():
end = time.time()
for i, (input, target) in enumerate(val_loader):
if args.gpu is not None:
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# compute output
output = model(input)
loss = criterion(output, target)
# log_softmax_output = F.log_softmax(output, dim=1)
#
# loss = - torch.sum(log_softmax_output * target)/ output.shape[0]
# measure accuracy and record loss
prec1 = CNN_utils.accuracy(output, target, topk=(1, 1))
losses.update(loss.item(), input.size(0))
top1.update(prec1[0].item(), input.size(0))
# top5.update(prec5[0], input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print_func('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})'.format(
i,
len(val_loader),
batch_time=batch_time,
loss=losses,
top1=top1))
print_func(' * Prec@1 {top1.avg:.3f}'.format(top1=top1))
return top1.avg, losses.avg
def train(train_loads_iter, train_loaders, model, criterion, optimizer, epoch,
args, print_func):
batch_time = CNN_utils.AverageMeter()
data_time = CNN_utils.AverageMeter()
losses = CNN_utils.AverageMeter()
top1 = CNN_utils.AverageMeter()
topX = CNN_utils.AverageMeter()
# switch to train mode
model.train()
if args.fix_BN:
CNN_utils.fix_BN(model)
#args.lam = 2 / (1 + math.exp(-epoch / 100)) - 1
batch_iters = math.ceil(args.num_iter / args.batch_size)
for i in range(batch_iters):
start = time.time()
l_loss = []
l_top1 = []
l_topX = []
optimizer.zero_grad()
for ds in range(args.num_datasets):
args.ind = ds
kout = args.topX or args.class_len[args.ind] // 2
end = time.time()
try:
(input, target) = train_loads_iter[ds].next()
except StopIteration:
train_loads_iter[ds] = iter(train_loaders[ds])
(input, target) = train_loads_iter[ds].next()
# measure data loading time
data_time.update(time.time() - end)
if args.gpu is not None:
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# compute output
output = model(input)
output_i = output[(args.class_len[args.ind] // 2) % 3]
output_dom = output[-1].squeeze().cuda(args.gpu, non_blocking=True)
loss = criterion(output_i, target)
dom_target = torch.tensor(
np.array([args.ind for _ in range(list(target.size())[0])]),
dtype=torch.float).cuda(args.gpu, non_blocking=True)
dtarget = dom_target.cuda(args.gpu, non_blocking=True)
domain_loss = F.binary_cross_entropy_with_logits(
dom_target, dtarget)
total_loss = loss + domain_loss
total_loss.backward()
l_loss.append(loss.item() - args.lam * domain_loss.item())
prec1, precX = CNN_utils.accuracy(output_i, target, topk=(1, kout))
l_top1.append(prec1.item())
l_topX.append(precX.item())
losses.update(l_loss[-1], input.size(0))
top1.update(sum(l_top1) / len(l_top1), input.size(0))
topX.update(sum(l_topX) / len(l_topX), input.size(0))
#optimizer.zero_grad()
#allloss_var.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - start)
if i % args.print_freq == 0:
print_func('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@X {topX.val:.3f} ({topX.avg:.3f})'.format(
epoch,
i,
batch_iters,
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
topX=topX))
def train(train_loads_iter, train_loaders, model, criterion, optimizer, epoch,
args, print_func):
batch_time = CNN_utils.AverageMeter()
data_time = CNN_utils.AverageMeter()
losses = CNN_utils.AverageMeter()
top1 = CNN_utils.AverageMeter()
topX = CNN_utils.AverageMeter()
# switch to train mode
model.train()
if args.fix_BN:
CNN_utils.fix_BN(model)
batch_iters = math.ceil(args.num_iter / args.batch_size)
for i in range(batch_iters):
start = time.time()
l_loss = []
l_top1 = []
l_topX = []
#allloss_var = 0
optimizer.zero_grad()
for ds in range(args.num_datasets):
args.ind = ds
kout = args.topX or args.class_len[args.ind] // 2
end = time.time()
try:
(input, target) = train_loads_iter[ds].next()
except StopIteration:
train_loads_iter[ds] = iter(train_loaders[ds])
(input, target) = train_loads_iter[ds].next()
# measure data loading time
data_time.update(time.time() - end)
if args.gpu is not None:
input = input.cuda(args.gpu, non_blocking=True)
target = target.cuda(args.gpu, non_blocking=True)
# target_idx = target.nonzero() [:,1]
# if torch.max(target) >= 0 and torch.max(target) < args.class_len[args.ind]:
# compute output
#print("Input shape {}".format(input.shape))
output = model(input)
output_i = output[args.ind]
#print("Output_i device {}".format(output_i.device))
loss = criterion(output_i, target)
l_loss.append(loss.item())
#allloss_var += loss
loss.backward()
prec1, precX = CNN_utils.accuracy(output_i.detach(),
target,
topk=(1, kout))
l_top1.append(prec1.item())
l_topX.append(precX.item())
losses.update(sum(l_loss), input.size(0))
top1.update(sum(l_top1) / len(l_top1), input.size(0))
topX.update(sum(l_topX) / len(l_topX), input.size(0))
#optimizer.zero_grad()
#allloss_var.backward()
optimizer.step()
# measure elapsed time
batch_time.update(time.time() - start)
if i % args.print_freq == 0:
print_func('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@X {topX.val:.3f} ({topX.avg:.3f})'.format(
epoch,
i,
batch_iters,
batch_time=batch_time,
data_time=data_time,
loss=losses,
top1=top1,
topX=topX))
