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()
# 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 = []
optimizer.zero_grad()
for ds in range(args.num_datasets):
args.ind = ds
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)
output = model(input)
output_i = output[args.ind]
loss = criterion(torch.log(output_i).double(), target.double())
l_loss.append(loss.item())
loss.backward()
losses.update(sum(l_loss), input.size(0))
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'.format(
epoch,
i,
batch_iters,
batch_time=batch_time,
data_time=data_time,
loss=losses))
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 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))