def main(): torch.multiprocessing.set_start_method("spawn", force=True) """Create the model and start the evaluation process.""" args = get_arguments() os.environ["CUDA_VISIBLE_DEVICES"]=args.gpu gpus = [int(i) for i in args.gpu.split(',')] h, w = map(int, args.input_size.split(',')) input_size = (h, w) deeplab = CorrPM_Model(args.num_classes, args.num_points) if len(gpus) > 1: model = DataParallelModel(deeplab) else: model = deeplab if not os.path.exists(args.save_dir): os.makedirs(args.save_dir) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) if args.data_name == 'lip': lip_dataset = LIPDataSet(args.data_dir, VAL_POSE_ANNO_FILE, args.dataset, crop_size=input_size, transform=transform) num_samples = len(lip_dataset) valloader = data.DataLoader(lip_dataset, batch_size=args.batch_size * len(gpus), shuffle=False, num_workers=4, pin_memory=True) restore_from = args.restore_from state_dict = model.state_dict().copy() state_dict_old = torch.load(restore_from) for key in state_dict.keys(): if key not in state_dict_old.keys(): print(key) for key, nkey in zip(state_dict_old.keys(), state_dict.keys()): if key != nkey: state_dict[key[7:]] = deepcopy(state_dict_old[key]) else: state_dict[key] = deepcopy(state_dict_old[key]) model.load_state_dict(state_dict) model.eval() model.cuda() parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, len(gpus)) mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, args.dataset) print(mIoU) end = datetime.datetime.now() print(end - start, 'seconds') print(end)
def main(): """Create the model and start the training.""" if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) writer = SummaryWriter(args.snapshot_dir) gpus = [int(i) for i in args.gpu.split(',')] if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu h, w = map(int, args.input_size.split(',')) input_size = [h, w] cudnn.enabled = True # cudnn related setting cudnn.benchmark = True torch.backends.cudnn.deterministic = False torch.backends.cudnn.enabled = True deeplab = Res_Deeplab(num_classes=args.num_classes) # dump_input = torch.rand((args.batch_size, 3, input_size[0], input_size[1])) # writer.add_graph(deeplab.cuda(), dump_input.cuda(), verbose=False) saved_state_dict = torch.load(args.restore_from) new_params = deeplab.state_dict().copy() for i in saved_state_dict: i_parts = i.split('.') # print(i_parts) if not i_parts[0] == 'fc': new_params['.'.join(i_parts[0:])] = saved_state_dict[i] deeplab.load_state_dict(new_params) model = DataParallelModel(deeplab) model.cuda() criterion = CriterionAll() criterion = DataParallelCriterion(criterion) criterion.cuda() normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) trainloader = data.DataLoader(LIPDataSet(args.data_dir, args.dataset, crop_size=input_size, transform=transform), batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=2, pin_memory=True) #lip_dataset = LIPDataSet(args.data_dir, 'val', crop_size=input_size, transform=transform) #num_samples = len(lip_dataset) #valloader = data.DataLoader(lip_dataset, batch_size=args.batch_size * len(gpus), # shuffle=False, pin_memory=True) optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) optimizer.zero_grad() total_iters = args.epochs * len(trainloader) for epoch in range(args.start_epoch, args.epochs): model.train() for i_iter, batch in enumerate(trainloader): i_iter += len(trainloader) * epoch lr = adjust_learning_rate(optimizer, i_iter, total_iters) images, labels, edges, _ = batch labels = labels.long().cuda(non_blocking=True) edges = edges.long().cuda(non_blocking=True) preds = model(images) loss = criterion(preds, [labels, edges]) optimizer.zero_grad() loss.backward() optimizer.step() if i_iter % 100 == 0: writer.add_scalar('learning_rate', lr, i_iter) writer.add_scalar('loss', loss.data.cpu().numpy(), i_iter) if i_iter % 500 == 0: images_inv = inv_preprocess(images, args.save_num_images) labels_colors = decode_parsing(labels, args.save_num_images, args.num_classes, is_pred=False) edges_colors = decode_parsing(edges, args.save_num_images, 2, is_pred=False) if isinstance(preds, list): preds = preds[0] preds_colors = decode_parsing(preds[0][-1], args.save_num_images, args.num_classes, is_pred=True) pred_edges = decode_parsing(preds[1][-1], args.save_num_images, 2, is_pred=True) img = vutils.make_grid(images_inv, normalize=False, scale_each=True) lab = vutils.make_grid(labels_colors, normalize=False, scale_each=True) pred = vutils.make_grid(preds_colors, normalize=False, scale_each=True) edge = vutils.make_grid(edges_colors, normalize=False, scale_each=True) pred_edge = vutils.make_grid(pred_edges, normalize=False, scale_each=True) writer.add_image('Images/', img, i_iter) writer.add_image('Labels/', lab, i_iter) writer.add_image('Preds/', pred, i_iter) writer.add_image('Edges/', edge, i_iter) writer.add_image('PredEdges/', pred_edge, i_iter) print('iter = {} of {} completed, loss = {}'.format( i_iter, total_iters, loss.data.cpu().numpy())) torch.save( model.state_dict(), osp.join(args.snapshot_dir, 'LIP_epoch_' + str(epoch) + '.pth')) #parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, len(gpus)) #mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size) #print(mIoU) #writer.add_scalars('mIoU', mIoU, epoch) end = timeit.default_timer() print(end - start, 'seconds')
def main(): """start multiprocessing method""" try: mp.set_start_method('spawn') except RuntimeError: pass """Create the model and start the training.""" if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) gpus = [int(i) for i in args.gpu.split(',')] if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu h, w = map(int, args.input_size.split(',')) input_size = [h, w] cudnn.enabled = True # cudnn related setting cudnn.benchmark = True torch.backends.cudnn.deterministic = True #False torch.backends.cudnn.enabled = True torch.cuda.empty_cache() deeplab = CorrPM_Model(num_classes=args.num_classes) saved_state_dict = torch.load(args.restore_from) new_params = deeplab.state_dict().copy() i = 0 print("Now is loading pre-trained res101 model!") for i in saved_state_dict: i_parts = i.split('.') if not i_parts[0] == 'fc': new_params['.'.join(i_parts[0:])] = saved_state_dict[i] deeplab.load_state_dict(new_params) criterion = CriterionPoseEdge() criterion = DataParallelCriterion(criterion) criterion.cuda() snapshot_fname = osp.join(args.snapshot_dir, 'LIP_epoch_') snapshot_best_fname = osp.join(args.snapshot_dir, 'LIP_best.pth') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) dataset_lip = LIPDataSet(args.data_dir, args.pose_anno_file, args.dataset, crop_size=input_size, dataset_list=args.dataset_list, transform=transform) trainloader = data.DataLoader(dataset_lip, batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=1, pin_memory=True) lip_dataset = LIPDataSet(args.data_dir, VAL_ANNO_FILE, 'val', crop_size=input_size, dataset_list=args.dataset_list, transform=transform) num_samples = len(lip_dataset) valloader = data.DataLoader(lip_dataset, batch_size=args.batch_size * len(gpus), shuffle=False, num_workers=0, pin_memory=True) optimizer = optim.SGD(deeplab.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) model = DataParallelModel(deeplab) model.cuda() optimizer.zero_grad() total_iters = args.epochs * len(trainloader) total_iter_per_batch = len(trainloader) print("total iters:", total_iters) best_iou = 0 i_iter = 0 temp = time.time() for epoch in range(args.start_epoch, args.epochs): model.train() for i_iter, batch in enumerate(trainloader): iter_lr = i_iter + epoch * len(trainloader) lr = adjust_learning_rate(optimizer, iter_lr, total_iters) images, labels, pose, edge, _ = batch labels = labels.long().cuda(non_blocking=True) edge = edge.long().cuda(non_blocking=True) pose = pose.float().cuda(non_blocking=True) preds = model(images) loss = criterion(preds, [labels, edge, pose]) optimizer.zero_grad() loss.backward() optimizer.step() if i_iter % 500 == 0: tim = time.time() print('iter:{}/{},loss:{:.3f},lr:{:.3e},time:{:.1f}'.format( i_iter, total_iter_per_batch, loss.data.cpu().numpy(), lr, tim - temp)) temp = tim h = time.time() if epoch % 5 == 0: print("----->Epoch:", epoch) parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, len(gpus), criterion, args) if args.dataset_list == '_id.txt': mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size) miou = mIoU['Mean IU'] is_best_iou = miou > best_iou best_iou = max(miou, best_iou) torch.save(model.state_dict(), snapshot_fname + '.pth') if is_best_iou: print("Best iou epoch: ", epoch) shutil.copyfile(snapshot_fname + '.pth', snapshot_best_fname) end = datetime.datetime.now() print(end - start, 'seconds') print(end)
def main(): """Create the model and start the training.""" print(args) if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) writer = SummaryWriter(args.snapshot_dir) gpus = [int(i) for i in args.gpu.split(',')] if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu h, w = map(int, args.input_size.split(',')) input_size = [h, w] cudnn.enabled = True # cudnn related setting cudnn.benchmark = True torch.backends.cudnn.deterministic = False torch.backends.cudnn.enabled = True deeplab = get_cls_net(config=config, num_classes=args.num_classes, is_train=True) model = DataParallelModel(deeplab) saved_state_dict = torch.load(args.restore_from) if args.start_epoch > 0: model = DataParallelModel(deeplab) model.load_state_dict(saved_state_dict['state_dict']) else: new_params = model.state_dict().copy() state_dict_pretrain = saved_state_dict['state_dict'] for state_name in state_dict_pretrain: if state_name in new_params: new_params[state_name] = state_dict_pretrain[state_name] #print ('LOAD',state_name) else: print('NOT LOAD', state_name) model.load_state_dict(new_params) print('-------Load Weight', args.restore_from) model.cuda() criterion = CriterionAll2() criterion = DataParallelCriterion(criterion) criterion.cuda() normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) trainloader = data.DataLoader(LIPDataSet(args.data_dir, args.dataset, crop_size=input_size, transform=transform), batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=4, pin_memory=True) num_samples = 5000 ''' list_map = [] for part in deeplab.path_list: list_map = list_map + list(map(id, part.parameters())) base_params = filter(lambda p: id(p) not in list_map, deeplab.parameters()) params_list = [] params_list.append({'params': base_params, 'lr':args.learning_rate*0.1}) for part in deeplab.path_list: params_list.append({'params': part.parameters()}) print ('len(params_list)',len(params_list)) ''' list_map = [] for part in deeplab.path_list: list_map = list_map + list(map(id, part.parameters())) base_params = filter(lambda p: id(p) not in list_map, deeplab.parameters()) params_list = [] params_list.append({'params': base_params, 'lr': 1e-6}) for part in deeplab.path_list: params_list.append({'params': part.parameters()}) print('len(params_list)', len(params_list)) optimizer = torch.optim.SGD(params_list, lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) if args.start_epoch > 0: optimizer.load_state_dict(saved_state_dict['optimizer']) print('========Load Optimizer', args.restore_from) optimizer.zero_grad() total_iters = args.epochs * len(trainloader) for epoch in range(args.start_epoch, args.epochs): model.train() for i_iter, batch in enumerate(trainloader): i_iter += len(trainloader) * epoch #lr = adjust_learning_rate(optimizer, i_iter, total_iters) lr = adjust_learning_rate_parsing(optimizer, epoch) images, labels, _ = batch labels = labels.long().cuda(non_blocking=True) preds = model(images) loss = criterion(preds, labels) optimizer.zero_grad() loss.backward() optimizer.step() if i_iter % 100 == 0: writer.add_scalar('learning_rate', lr, i_iter) writer.add_scalar('loss', loss.data.cpu().numpy(), i_iter) print('epoch = {}, iter = {} of {} completed,lr={}, loss = {}'. format(epoch, i_iter, total_iters, lr, loss.data.cpu().numpy())) if epoch % 2 == 0 or epoch == args.epochs: time.sleep(10) save_checkpoint(model, epoch, optimizer) # parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, len(gpus)) # mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size) # print(mIoU) # writer.add_scalars('mIoU', mIoU, epoch) time.sleep(10) save_checkpoint(model, epoch, optimizer) end = timeit.default_timer() print(end - start, 'seconds')
def main(): """Create the model and start the training.""" if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) f = open('./tlip.txt','w') f.write(str(args)+'\n') gpus = [int(i) for i in args.gpu.split(',')] if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu h, w = map(int, args.input_size.split(',')) input_size = [h, w] cudnn.enabled = True #cudnn.benchmark = False torch.backends.cudnn.deterministic = False torch.backends.cudnn.enabled = True deeplab = EEN(num_classes=args.num_classes) # Initialize the model with resnet101-imagenet.pth saved_state_dict = torch.load(args.restore_from) new_params = deeplab.state_dict().copy() for i in saved_state_dict: i_parts = i.split('.') if not i_parts[0] == 'fc': new_params['.'.join(i_parts[0:])] = saved_state_dict[i] deeplab.load_state_dict(new_params) # Initialize the model with cihp_11.pth """args.start_epoch = 11 res = './scihp/cihp_11.pth' state_dict = deeplab.state_dict().copy() state_dict_old = torch.load(res) for key, nkey in zip(state_dict_old.keys(), state_dict.keys()): if key != nkey: state_dict[key[7:]] = deepcopy(state_dict_old[key]) else: state_dict[key] = deepcopy(state_dict_old[key]) deeplab.load_state_dict(state_dict)""" ######### model = DataParallelModel(deeplab) model.cuda() criterion = CriterionAll() criterion = DataParallelCriterion(criterion) criterion.cuda() normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) trainloader = data.DataLoader(HumanDataSet(args.data_dir, args.dataset, crop_size=input_size, transform=transform), batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=2, pin_memory=True) optimizer = optim.SGD( model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay ) optimizer.zero_grad() total_iters = args.epochs * len(trainloader) print(len(trainloader)) for epoch in range(args.start_epoch, args.epochs): start_time = timeit.default_timer() model.train() for i_iter, batch in enumerate(trainloader): i_iter += len(trainloader) * epoch lr = adjust_learning_rate(optimizer, i_iter, total_iters) images, labels, edges, _ = batch #pdb.set_trace() labels = labels.long().cuda(non_blocking=True) edges = edges.long().cuda(non_blocking=True) preds = model(images) #pdb.set_trace() loss = criterion(preds, [labels, edges]) optimizer.zero_grad() loss.backward() optimizer.step() if i_iter % 100 ==0: print('iter = {} of {} completed, loss = {}'.format(i_iter, total_iters, loss.data.cpu().numpy())) f.write('iter = '+str(i_iter)+', loss = '+str(loss.data.cpu().numpy())+', lr = '+str(lr)+'\n') torch.save(model.state_dict(), osp.join(args.snapshot_dir, 'lip_' + str(epoch) + '.pth')) end_time = timeit.default_timer() print('epoch: ', epoch ,', the time is: ',(end_time-start_time)) end = timeit.default_timer() print(end - start, 'seconds') f.close()
def main(): """Create the model and start the training.""" if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) writer = SummaryWriter(args.snapshot_dir) gpus = [int(i) for i in args.gpu.split(',')] if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu h, w = map(int, args.input_size.split(',')) input_size = [h, w] cudnn.enabled = True # cudnn related setting cudnn.benchmark = True torch.backends.cudnn.deterministic = False torch.backends.cudnn.enabled = True deeplab = Res_Deeplab(num_classes=args.num_classes) print(type(deeplab)) # dump_input = torch.rand((args.batch_size, 3, input_size[0], input_size[1])) # writer.add_graph(deeplab.cuda(), dump_input.cuda(), verbose=False) """ HOW DOES IT LOAD ONLY RESNET101 AND NOT THE RSTE OF THE NET ? """ # UNCOMMENT THE FOLLOWING COMMENTARY TO INITIALYZE THE WEIGHTS # Load resnet101 weights trained on imagenet and copy it in new_params saved_state_dict = torch.load(args.restore_from) new_params = deeplab.state_dict().copy() # CHECK IF WEIGHTS BELONG OR NOT TO THE MODEL # belongs = 0 # doesnt_b = 0 # for key in saved_state_dict: # if key in new_params: # belongs+=1 # print('key=', key) # else: # doesnt_b+=1 # # print('key=', key) # print('belongs = ', belongs, 'doesnt_b=', doesnt_b) # print('res101 len',len(saved_state_dict)) # print('new param len',len(new_params)) for i in saved_state_dict: i_parts = i.split('.') # print('i_parts:', i_parts) # exp : i_parts: ['layer2', '3', 'bn2', 'running_mean'] # The deeplab weight modules have diff name than args.restore_from weight modules if i_parts[0] == 'module' and not i_parts[1] == 'fc' : if new_params['.'.join(i_parts[1:])].size() == saved_state_dict[i].size(): new_params['.'.join(i_parts[1:])] = saved_state_dict[i] else: if not i_parts[0] == 'fc': if new_params['.'.join(i_parts[0:])].size() == saved_state_dict[i].size(): new_params['.'.join(i_parts[0:])] = saved_state_dict[i] deeplab.load_state_dict(new_params) # UNCOMMENT UNTIL HERE model = DataParallelModel(deeplab) model.cuda() criterion = CriterionAll() criterion = DataParallelCriterion(criterion) criterion.cuda() normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) trainloader = data.DataLoader(cartoonDataSet(args.data_dir, args.dataset, crop_size=input_size, transform=transform), batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=8, pin_memory=True) #mIoU for Val set val_dataset = cartoonDataSet(args.data_dir, 'val', crop_size=input_size, transform=transform) numVal_samples = len(val_dataset) valloader = data.DataLoader(val_dataset, batch_size=args.batch_size * len(gpus), shuffle=False, pin_memory=True) #mIoU for trainTest set trainTest_dataset = cartoonDataSet(args.data_dir, 'trainTest', crop_size=input_size, transform=transform) numTest_samples = len(trainTest_dataset) testloader = data.DataLoader(trainTest_dataset, batch_size=args.batch_size * len(gpus), shuffle=False, pin_memory=True) optimizer = optim.SGD( model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay ) optimizer.zero_grad() # valBatch_idx = 0 total_iters = args.epochs * len(trainloader) for epoch in range(args.start_epoch, args.epochs): model.train() for i_iter, batch in enumerate(trainloader): i_iter += len(trainloader) * epoch lr = adjust_learning_rate(optimizer, i_iter, total_iters) images, labels, _, _ = batch labels = labels.long().cuda(non_blocking=True) preds = model(images) # print('preds size in batch', len(preds)) # print('Size of Segmentation1 tensor output:',preds[0][0].size()) # print('Segmentation2 tensor output:',preds[0][-1].size()) # print('Size of Edge tensor output:',preds[1][-1].size()) loss = criterion(preds, [labels]) optimizer.zero_grad() loss.backward() optimizer.step() if i_iter % 100 == 0: writer.add_scalar('learning_rate', lr, i_iter) writer.add_scalar('loss', loss.data.cpu().numpy(), i_iter) if i_iter % 500 == 0: # print('In iter%500 Size of Segmentation2 GT: ', labels.size()) # print('In iter%500 Size of edges GT: ', edges.size()) images_inv = inv_preprocess(images, args.save_num_images) # print(labels[0]) labels_colors = decode_parsing(labels, args.save_num_images, args.num_classes, is_pred=False) # if isinstance(preds, list): # print(len(preds)) # preds = preds[0] # val_images, _ = valloader[valBatch_idx] # valBatch_idx += 1 # val_sampler = torch.utils.data.RandomSampler(val_dataset,replacement=True, num_samples=args.batch_size * len(gpus)) # sample_valloader = data.DataLoader(val_dataset, batch_size=args.batch_size * len(gpus), # shuffle=False, sampler=val_sampler , pin_memory=True) # val_images, _ = sample_valloader # preds_val = model(val_images) # With multiple GPU, preds return a list, therefore we extract the tensor in the list if len(gpus)>1: preds= preds[0] # preds_val = preds_val[0] # print('In iter%500 Size of Segmentation2 tensor output:',preds[0][0][-1].size()) # preds[0][-1] cause model returns [[seg1, seg2], [edge]] preds_colors = decode_parsing(preds[0][-1], args.save_num_images, args.num_classes, is_pred=True) # preds_val_colors = decode_parsing(preds_val[0][-1], args.save_num_images, args.num_classes, is_pred=True) # print("preds type:",type(preds)) #list # print("preds shape:", len(preds)) #2 # hello = preds[0][-1] # print("preds type [0][-1]:",type(hello)) #<class 'torch.Tensor'> # print("preds len [0][-1]:", len(hello)) #12 # print("preds len [0][-1]:", hello.shape)#torch.Size([12, 8, 96, 96]) # print("preds color's type:",type(preds_colors))#torch.tensor # print("preds color's shape:",preds_colors.shape) #([2,3,96,96]) # print('IMAGE', images_inv.size()) img = vutils.make_grid(images_inv, normalize=False, scale_each=True) lab = vutils.make_grid(labels_colors, normalize=False, scale_each=True) pred = vutils.make_grid(preds_colors, normalize=False, scale_each=True) # print("preD type:",type(pred)) #<class 'torch.Tensor'> # print("preD len:", len(pred))# 3 # print("preD shape:", pred.shape)#torch.Size([3, 100, 198]) # 1=head red, 2=body green , 3=left_arm yellow, 4=right_arm blue, 5=left_leg pink # 6=right_leg skuBlue, 7=tail grey writer.add_image('Images/', img, i_iter) writer.add_image('Labels/', lab, i_iter) writer.add_image('Preds/', pred, i_iter) print('iter = {} of {} completed, loss = {}'.format(i_iter, total_iters, loss.data.cpu().numpy())) print('end epoch:', epoch) if epoch%99 == 0: torch.save(model.state_dict(), osp.join(args.snapshot_dir, 'DFPnet_epoch_' + str(epoch) + '.pth')) if epoch%5 == 0 and epoch<500: # mIou for Val set parsing_preds, scales, centers = valid(model, valloader, input_size, numVal_samples, len(gpus)) ''' Insert a sample of prediction of a val image on tensorboard ''' # generqte a rand number between len(parsing_preds) sample = random.randint(0, len(parsing_preds)-1) #loader resize and convert to tensor the image loader = transforms.Compose([ transforms.Resize(input_size), transforms.ToTensor() ]) # get val segmentation path and open the file list_path = os.path.join(args.data_dir, 'val' + '_id.txt') val_id = [i_id.strip() for i_id in open(list_path)] gt_path = os.path.join(args.data_dir, 'val' + '_segmentations', val_id[sample] + '.png') gt =Image.open(gt_path) gt = loader(gt) #put gt back from 0 to 255 gt = (gt*255).int() # convert pred from ndarray to PIL image then to tensor display_preds = Image.fromarray(parsing_preds[sample]) tensor_display_preds = transforms.ToTensor()(display_preds) #put gt back from 0 to 255 tensor_display_preds = (tensor_display_preds*255).int() # color them val_preds_colors = decode_parsing(tensor_display_preds, num_images=1, num_classes=args.num_classes, is_pred=False) gt_color = decode_parsing(gt, num_images=1, num_classes=args.num_classes, is_pred=False) # put in grid pred_val = vutils.make_grid(val_preds_colors, normalize=False, scale_each=True) gt_val = vutils.make_grid(gt_color, normalize=False, scale_each=True) writer.add_image('Preds_val/', pred_val, epoch) writer.add_image('Gt_val/', gt_val, epoch) mIoUval = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'val') print('For val set', mIoUval) writer.add_scalars('mIoUval', mIoUval, epoch) # mIou for trainTest set parsing_preds, scales, centers = valid(model, testloader, input_size, numTest_samples, len(gpus)) mIoUtest = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'trainTest') print('For trainTest set', mIoUtest) writer.add_scalars('mIoUtest', mIoUtest, epoch) else: if epoch%20 == 0 and epoch>=500: # mIou for Val set parsing_preds, scales, centers = valid(model, valloader, input_size, numVal_samples, len(gpus)) ''' Insert a sample of prediction of a val image on tensorboard ''' # generqte a rand number between len(parsing_preds) sample = random.randint(0, len(parsing_preds)-1) #loader resize and convert to tensor the image loader = transforms.Compose([ transforms.Resize(input_size), transforms.ToTensor() ]) # get val segmentation path and open the file list_path = os.path.join(args.data_dir, 'val' + '_id.txt') val_id = [i_id.strip() for i_id in open(list_path)] gt_path = os.path.join(args.data_dir, 'val' + '_segmentations', val_id[sample] + '.png') gt =Image.open(gt_path) gt = loader(gt) #put gt back from 0 to 255 gt = (gt*255).int() # convert pred from ndarray to PIL image then to tensor display_preds = Image.fromarray(parsing_preds[sample]) tensor_display_preds = transforms.ToTensor()(display_preds) #put gt back from 0 to 255 tensor_display_preds = (tensor_display_preds*255).int() # color them val_preds_colors = decode_parsing(tensor_display_preds, num_images=1, num_classes=args.num_classes, is_pred=False) gt_color = decode_parsing(gt, num_images=1, num_classes=args.num_classes, is_pred=False) # put in grid pred_val = vutils.make_grid(val_preds_colors, normalize=False, scale_each=True) gt_val = vutils.make_grid(gt_color, normalize=False, scale_each=True) writer.add_image('Preds_val/', pred_val, epoch) writer.add_image('Gt_val/', gt_val, epoch) mIoUval = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'val') print('For val set', mIoUval) writer.add_scalars('mIoUval', mIoUval, epoch) # mIou for trainTest set parsing_preds, scales, centers = valid(model, testloader, input_size, numTest_samples, len(gpus)) mIoUtest = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'trainTest') print('For trainTest set', mIoUtest) writer.add_scalars('mIoUtest', mIoUtest, epoch) end = timeit.default_timer() print(end - start, 'seconds')
def main(): args = get_arguments() print(args) start_epoch = 0 cycle_n = 0 if not os.path.exists(args.log_dir): os.makedirs(args.log_dir) with open(os.path.join(args.log_dir, 'args.json'), 'w') as opt_file: json.dump(vars(args), opt_file) gpus = [int(i) for i in args.gpu.split(',')] if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu input_size = list(map(int, args.input_size.split(','))) cudnn.enabled = True cudnn.benchmark = True # Model Initialization AugmentCE2P = networks.init_model(args.arch, num_classes=args.num_classes, pretrained=args.imagenet_pretrain) model = DataParallelModel(AugmentCE2P) model.cuda() IMAGE_MEAN = AugmentCE2P.mean IMAGE_STD = AugmentCE2P.std INPUT_SPACE = AugmentCE2P.input_space print('image mean: {}'.format(IMAGE_MEAN)) print('image std: {}'.format(IMAGE_STD)) print('input space:{}'.format(INPUT_SPACE)) restore_from = args.model_restore if os.path.exists(restore_from): print('Resume training from {}'.format(restore_from)) checkpoint = torch.load(restore_from) model.load_state_dict(checkpoint['state_dict']) start_epoch = checkpoint['epoch'] SCHP_AugmentCE2P = networks.init_model(args.arch, num_classes=args.num_classes, pretrained=args.imagenet_pretrain) schp_model = DataParallelModel(SCHP_AugmentCE2P) schp_model.cuda() if os.path.exists(args.schp_restore): print('Resuming schp checkpoint from {}'.format(args.schp_restore)) schp_checkpoint = torch.load(args.schp_restore) schp_model_state_dict = schp_checkpoint['state_dict'] cycle_n = schp_checkpoint['cycle_n'] schp_model.load_state_dict(schp_model_state_dict) # Loss Function criterion = CriterionAll(lambda_1=args.lambda_s, lambda_2=args.lambda_e, lambda_3=args.lambda_c, num_classes=args.num_classes) criterion = DataParallelCriterion(criterion) criterion.cuda() # Data Loader if INPUT_SPACE == 'BGR': print('BGR Transformation') transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=IMAGE_MEAN, std=IMAGE_STD), ]) elif INPUT_SPACE == 'RGB': print('RGB Transformation') transform = transforms.Compose([ transforms.ToTensor(), BGR2RGB_transform(), transforms.Normalize(mean=IMAGE_MEAN, std=IMAGE_STD), ]) train_dataset = LIPDataSet(args.data_dir, args.split_name, crop_size=input_size, transform=transform) train_loader = data.DataLoader(train_dataset, batch_size=args.batch_size * len(gpus), num_workers=16, shuffle=True, pin_memory=True, drop_last=True) print('Total training samples: {}'.format(len(train_dataset))) # Optimizer Initialization optimizer = optim.SGD(model.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) lr_scheduler = SGDRScheduler(optimizer, total_epoch=args.epochs, eta_min=args.learning_rate / 100, warmup_epoch=10, start_cyclical=args.schp_start, cyclical_base_lr=args.learning_rate / 2, cyclical_epoch=args.cycle_epochs) total_iters = args.epochs * len(train_loader) start = timeit.default_timer() for epoch in range(start_epoch, args.epochs): lr_scheduler.step(epoch=epoch) lr = lr_scheduler.get_lr()[0] model.train() for i_iter, batch in enumerate(train_loader): i_iter += len(train_loader) * epoch images, labels, _ = batch labels = labels.cuda(non_blocking=True) edges = generate_edge_tensor(labels) labels = labels.type(torch.cuda.LongTensor) edges = edges.type(torch.cuda.LongTensor) preds = model(images) # Online Self Correction Cycle with Label Refinement if cycle_n >= 1: with torch.no_grad(): soft_preds = schp_model(images) soft_parsing = [] soft_edge = [] for soft_pred in soft_preds: soft_parsing.append(soft_pred[0][-1]) soft_edge.append(soft_pred[1][-1]) soft_preds = torch.cat(soft_parsing, dim=0) soft_edges = torch.cat(soft_edge, dim=0) else: soft_preds = None soft_edges = None loss = criterion(preds, [labels, edges, soft_preds, soft_edges], cycle_n) optimizer.zero_grad() loss.backward() optimizer.step() if i_iter % 100 == 0: print('iter = {} of {} completed, lr = {}, loss = {}'.format( i_iter, total_iters, lr, loss.data.cpu().numpy())) if (epoch + 1) % (args.eval_epochs) == 0: schp.save_checkpoint( { 'epoch': epoch + 1, 'state_dict': model.state_dict(), }, False, args.log_dir, filename='checkpoint_{}.pth.tar'.format(epoch + 1)) # Self Correction Cycle with Model Aggregation if (epoch + 1) >= args.schp_start and ( epoch + 1 - args.schp_start) % args.cycle_epochs == 0: print('Self-correction cycle number {}'.format(cycle_n)) schp.moving_average(schp_model, model, 1.0 / (cycle_n + 1)) cycle_n += 1 schp.bn_re_estimate(train_loader, schp_model) schp.save_schp_checkpoint( { 'state_dict': schp_model.state_dict(), 'cycle_n': cycle_n, }, False, args.log_dir, filename='schp_{}_checkpoint.pth.tar'.format(cycle_n)) torch.cuda.empty_cache() end = timeit.default_timer() print('epoch = {} of {} completed using {} s'.format( epoch, args.epochs, (end - start) / (epoch - start_epoch + 1))) end = timeit.default_timer() print('Training Finished in {} seconds'.format(end - start))