def train(train_loader, model, optimizer, epoch, train_writer): global n_iter, args batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() flow2_EPEs = AverageMeter() epoch_size = len(train_loader) if args.epoch_size == 0 else min( len(train_loader), args.epoch_size) # switch to train mode model.train() end = time.time() #import ipdb; ipdb.set_trace() for i, (input, target) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) target = target.to(device) input = torch.cat(input, 1).to(device) # compute output output = model(input) if args.sparse: # Since Target pooling is not very precise when sparse, # take the highest resolution prediction and upsample it instead of downsampling target h, w = target.size()[-2:] output = [F.interpolate(output[0], (h, w)), *output[1:]] loss = multiscaleEPE(output, target, weights=args.multiscale_weights, sparse=args.sparse) flow2_EPE = args.div_flow * realEPE( output[0], target, sparse=args.sparse) # record loss and EPE losses.update(loss.item(), target.size(0)) train_writer.add_scalar('train_loss', loss.item(), n_iter) flow2_EPEs.update(flow2_EPE.item(), target.size(0)) # compute gradient and do optimization 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( 'Epoch: [{0}][{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}' .format(epoch, i, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if i >= epoch_size: break return losses.avg, flow2_EPEs.avg
def train(train_loader, model, optimizer, epoch, train_writer): global n_iter, args batch_time = AverageMeter()#个人习惯?? data_time = AverageMeter() losses = AverageMeter() flow2_EPEs = AverageMeter() epoch_size = len(train_loader) if args.epoch_size == 0 else min(len(train_loader), args.epoch_size) # switch to train mode model.train() end = time.time() for i, (input, target) in enumerate(train_loader):#len(train_loader)= 22 (170 / batch_size = 22 ) # measure data loading time data_time.update(time.time() - end) target = target.to(device) input = torch.cat(input,1).to(device) # compute output #------------------- output = model(input)# while train n*[b,2,h,w] #------------------- if args.sparse:#数据集gt为稀疏型(比如kitti这种来自真实场景而不是虚拟数据集) # Since Target pooling is not very precise when sparse, # take the highest resolution prediction and upsample it instead of downsampling target #output[0] is flow2, 1 is flow3, so on h, w = target.size()[-2:] output = [F.interpolate(output[0], (h,w)), *output[1:]] #in trainning model, outputs is a list loss = multiscaleEPE(output, target, weights=args.multiscale_weights, sparse=args.sparse) #default as 20 flow2_EPE = args.div_flow * realEPE(output[0], target, sparse=args.sparse) # record loss and EPE losses.update(loss.item(), target.size(0)) train_writer.add_scalar('train_loss', loss.item(), n_iter) flow2_EPEs.update(flow2_EPE.item(), target.size(0)) # compute gradient and do optimization 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('Epoch: [{0}]\nTrain:[{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}' .format(epoch, i, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if i >= epoch_size:#epoch_size default as 1000 break return losses.avg, flow2_EPEs.avg# every epoch has a losses.avg, EPE
def train(train_loader, model, optimizer, epoch, train_writer): global n_iter, args batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() flow2_EPEs = AverageMeter() epoch_size = len(train_loader) if args.epoch_size == 0 else min( len(train_loader), args.epoch_size) # 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 = [j.cuda() for j in input] input_var = torch.autograd.Variable(torch.cat(input, 1)) target_var = torch.autograd.Variable(target) # compute output output = model(input_var) loss = multiscaleEPE(output, target_var, weights=args.multiscale_weights) flow2_EPE = args.div_flow * realEPE(output[0], target_var) # record loss and EPE losses.update(loss.data[0], target.size(0)) train_writer.add_scalar('train_loss', loss.data[0], n_iter) flow2_EPEs.update(flow2_EPE.data[0], target.size(0)) # compute gradient and do optimization 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( 'Epoch: [{0}][{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}' .format(epoch, i, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if i >= epoch_size: break return losses.avg, flow2_EPEs.avg
def train(train_loader, model, optimizer, epoch, train_writer): global n_iter, args batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() flow2_EPEs = AverageMeter() if args.data_loader == "torch": epoch_size = (len(train_loader) if args.epoch_size == 0 else min( len(train_loader), args.epoch_size)) if args.data_loader == "dali": epoch_size = (9999 if args.epoch_size == 0 else min( len(train_loader), args.epoch_size)) # switch to train mode model.train() end = time.time() for i, data in enumerate(train_loader): if args.data_loader == "torch": (input, target) = data if args.data_loader == "dali": input = [ data[0]["images"][:, 0:3, :, :], data[0]["images"][:, 3:6, :, :], ] target = data[0]["flow"] if args.show_train_images: for k in range(len(input[0].cpu())): f, axarr = plt.subplots(2, 2) axarr[0, 0].imshow(np.moveaxis(np.array(input[0].cpu()[k]), 0, 2)) axarr[0, 1].imshow(np.moveaxis(np.array(input[1].cpu()[k]), 0, 2)) axarr[1, 0].imshow( np.moveaxis( flow2rgb(args.div_flow * np.squeeze(target.cpu()[k]), max_value=10), 0, 2, )) plt.show() # measure data loading time data_time.update(time.time() - end) target = target.to(device) input = torch.cat(input, 1).to(device) # compute output output = model(input) # [0], input[1]) if args.sparse: # Since Target pooling is not very precise when sparse, # take the highest resolution prediction and upsample it instead of downsampling target h, w = target.size()[-2:] output = [F.interpolate(output[0], (h, w)), *output[1:]] loss = multiscaleEPE(output, target, weights=args.multiscale_weights, sparse=args.sparse) flow2_EPE = args.div_flow * realEPE( output, target, sparse=args.sparse) # output[0] if using multi-scale loss # record loss and EPE losses.update(loss.item(), target.size(0)) train_writer.add_scalar("train_loss", loss.item(), n_iter) flow2_EPEs.update(flow2_EPE.item(), target.size(0)) # compute gradient and do optimization 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( "Epoch: [{0}][{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}" .format(epoch, i, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if i >= epoch_size: break return losses.avg, flow2_EPEs.avg
def train(train_loader, model, optimizer, epoch, train_writer): global n_iter, args batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() flow2_EPEs = AverageMeter() epoch_size = len(train_loader) if args.epoch_size == 0 else min(len(train_loader), args.epoch_size) # switch to train mode model.train() end = time.time() #rot = flow_transforms.RandomRotate(30) #trans = flow_transforms.RandomTranslate(5) for i, (input, target) in enumerate(train_loader): ######Data Augmentation############# #input, target = rot(input, target) #input, target = trans(input, target) # measure data loading time data_time.update(time.time() - end) target = target.to(device) #????? #input = torch.cat(input,1).to(device) input = input.to(device) #print("input is: ", input) #print("input[0] is: ", input[0]) #print("input[0] size: ",input[0].size()) if False: print("time input:") print(input[0,1,75:85,150:160]) print("boolean input") print(input[0, 0, 75:85, 150:160]) # compute output output = model(input) if args.sparse: # Since Target pooling is not very precise when sparse, # take the highest resolution prediction and upsample it instead of downsampling target h, w = target.size()[-2:] output = [F.interpolate(output[0], (h,w)), *output[1:]] loss = multiscaleEPE(output, target, weights=args.multiscale_weights, sparse=args.sparse) flow2_EPE = args.div_flow * realEPE(output[0], target, sparse=args.sparse) if False: print("type: ", type(output)) print("length: ",len(output)) print("it is: ",output[0]) print("nextddddddddddddddddddddddd") print("it is: ", output[1]) print("nextddddddddddddddddddddddd") print("it is: ", output[2]) print("EPEEEEEEEEEEEEEEEEEEEEEEE") print(flow2_EPE) # record loss and EPE losses.update(loss.item(), target.size(0)) train_writer.add_scalar('train_loss', loss.item(), n_iter) flow2_EPEs.update(flow2_EPE.item(), target.size(0)) # compute gradient and do optimization 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('Epoch: [{0}][{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}' .format(epoch, i, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if i >= epoch_size: break #if i > 5: # break return losses.avg, flow2_EPEs.avg
patht = patht.to(device) #inputv = Variable(input) # using unsqueeze is import for with out bactch situation #inputv = Variable(input.unsqueeze(0)) #labelv = Variable(patht) #inputv = input #labelv = patht inputv = Variable(input) #inputv = Variable(input.unsqueeze(0)) #patht =patht.view(-1, 1).squeeze(1) target = Variable(patht.unsqueeze(2).unsqueeze(1)) output = netD(inputv) loss = multiscaleEPE(output, target, multi_scale_weight, False) #output = output.view(Batch_size,Path_length).squeeze(1) save_out = output netD.zero_grad() #errD_real = criterion(output, labelv) #errD_real.backward() loss.backward() D_x = loss.data.mean() optimizerD.step() # train with fake if cv2.waitKey(12) & 0xFF == ord('q'): break
def train(train_loader, model, optimizer, epoch, train_writer, config): global n_iter batch_time = AverageMeter() data_time = AverageMeter() losses = AverageMeter() flow2_EPEs = AverageMeter() epoch_size = len(train_loader) if args.epoch_size == 0 else min(len(train_loader), args.epoch_size) # switch to train mode model.train() end = time.time() if not args.self_supervised_loss: # use old loss for i, (input, target) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) target = target.to(device) input = torch.cat(input,1).to(device) # compute output output = model(input) if args.sparse: # Since Target pooling is not very precise when sparse, # take the highest resolution prediction and upsample it instead of downsampling target h, w = target.size()[-2:] output = [F.interpolate(output[0], (h,w)), *output[1:]] loss = multiscaleEPE(output, target, weights=args.multiscale_weights, sparse=args.sparse) flow2_EPE = args.div_flow * realEPE(output[0], target, sparse=args.sparse) # record loss and EPE losses.update(loss.item(), target.size(0)) train_writer.add_scalar('train_loss', loss.item(), n_iter) flow2_EPEs.update(flow2_EPE.item(), target.size(0)) # compute gradient and do optimization 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('Epoch: [{0}][{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}' .format(epoch, i, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if i >= epoch_size: break return losses.avg, flow2_EPEs.avg elif args.unflow: weights = [0.005, 0.01, 0.02, 0.08, 0.32] for it, (input, target) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) target = target.to(device) im1 = input[0].to(device) im2 = input[1].to(device) input_fw = torch.cat(input, 1).to(device) pred_fw = model(input_fw) input_bw = torch.cat((im2, im1), 1).to(device) pred_bw = model(input_bw) census_loss = 0 census_loss_list = [] if config['census']: #weights = [1, 0.34, 0.31, 0.27, 0.09] #max_dist = [3, 2, 2, 1, 1] for i in range(len(pred_fw)): flow_fw = pred_fw[i] * args.div_flow flow_bw = pred_bw[i] * args.div_flow loss = ternary_loss(im2, im1, flow_fw, max_distance=1) +\ ternary_loss(im1, im2, flow_bw,max_distance=1) census_loss += loss census_loss_list.append(loss.item()) if not config['multiscale_census_loss']: break train_writer.add_scalar('train_loss_census', census_loss.item(), n_iter) sl_loss = 0 sl_loss_list = [] if config['sl']: for i in range(len(pred_fw)): flow_fw = pred_fw[i] * args.div_flow flow_bw = pred_bw[i] * args.div_flow loss = smoothness_loss(flow_fw,config) + smoothness_loss(flow_bw,config) #loss = smoothness_loss(flow_bw, config) sl_loss += loss sl_loss_list.append(loss.item()) if not config['multiscale_sl_loss']: break train_writer.add_scalar('train_loss_sl', sl_loss.item(), n_iter) ssim_loss = 0 ssim_loss_list = [] if config['ssim']: for i in range(len(pred_bw)): flow_bw = pred_bw[i] * args.div_flow loss = ssim(im1,im2,flow_bw) ssim_loss += loss ssim_loss_list.append(loss.item()) if not config['multiscale_ssim_loss']: break train_writer.add_scalar('train_loss_ssim', ssim_loss.item(), n_iter) fb_loss = 0 fb_loss_list = [] if config['fb']: for i in range(len(pred_bw)): flow_fw = pred_fw[i] * args.div_flow flow_bw = pred_bw[i] * args.div_flow loss = forward_backward_loss(im1=im1, im2=im2, flow_fw=flow_fw, flow_bw=flow_bw, config=config) fb_loss += loss fb_loss_list.append(loss.item()) if not config['multiscale_fb_loss']: break train_writer.add_scalar('train_loss_fb', fb_loss.item(), n_iter) # to check the magnitude of both losses if it % 500 == 0: print("[DEBUG] census_loss:", str(census_loss_list)) print("[DEBUG] sl_loss:", str(sl_loss_list)) print("[DEBUG] ssim_loss:", str(ssim_loss_list)) print("[DEBUG] fb_loss:", str(fb_loss_list)) loss = census_loss + sl_loss + ssim_loss + 0.001*fb_loss # record loss and EPE flow = pred_bw[0] losses.update(loss.item(), target.size(0)) flow2_EPE = args.div_flow * realEPE(flow, target, sparse=args.sparse) train_writer.add_scalar('train_loss', loss.item(), n_iter) flow2_EPEs.update(flow2_EPE.item(), target.size(0)) # compute gradient and do optimization step optimizer.zero_grad() loss.backward() optimizer.step() # measure elapsed time batch_time.update(time.time() - end) end = time.time() if it % args.print_freq == 0: print('Epoch: [{0}][{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}' .format(epoch, it, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if it >= epoch_size: break return losses.avg, flow2_EPEs.avg else: # use self-supervised loss for it, (input, target) in enumerate(train_loader): # measure data loading time data_time.update(time.time() - end) target = target.to(device) im1 = input[0].to(device) im2 = input[1].to(device) input = torch.cat(input,1).to(device) pred = model(input) pl_loss = 0 pl_loss_list = [] for i in range(len(pred)): flow = pred[i] * args.div_flow loss = photometric_loss(im1, im2, flow, config) pl_loss += loss pl_loss_list.append(loss.item()) if not config['multiscale_pl_loss']: break sl_loss = 0 sl_loss_list = [] if config['weighted_sl_loss']: for i in range(len(pred)): flow = pred[i] * args.div_flow loss = weighted_smoothness_loss(im1, im2, flow, config) sl_loss += loss sl_loss_list.append(loss.item()) if not config['multiscale_sl_loss']: break else: # smoothness loss for multi resolution flow pyramid for i in range(len(pred)): flow = pred[i] * args.div_flow loss = smoothness_loss(flow, config) sl_loss += loss sl_loss_list.append(loss.item()) if not config['multiscale_sl_loss']: break # to check the magnitude of both losses if it % 500 == 0: print("[DEBUG] pl_loss:", str(pl_loss_list)) print("[DEBUG] sl_loss:", str(sl_loss_list)) loss = pl_loss + sl_loss # record loss and EPE flow = pred[0] losses.update(loss.item(), target.size(0)) flow2_EPE = args.div_flow * realEPE(flow, target, sparse=args.sparse) train_writer.add_scalar('train_loss', loss.item(), n_iter) train_writer.add_scalar('train_loss_pl', pl_loss.item(), n_iter) train_writer.add_scalar('train_loss_sl', sl_loss.item(), n_iter) flow2_EPEs.update(flow2_EPE.item(), target.size(0)) # compute gradient and do optimization step optimizer.zero_grad() loss.backward() optimizer.step() # measure elapsed time batch_time.update(time.time() - end) end = time.time() if it % args.print_freq == 0: print('Epoch: [{0}][{1}/{2}]\t Time {3}\t Data {4}\t Loss {5}\t EPE {6}' .format(epoch, it, epoch_size, batch_time, data_time, losses, flow2_EPEs)) n_iter += 1 if it >= epoch_size: break return losses.avg, flow2_EPEs.avg