def main(): """Create the model and start the evaluation process.""" args = get_arguments() update_config(config, args) print (args) if not os.path.exists(args.save_dir): os.makedirs(args.save_dir) 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) model = get_cls_net(config=config, num_classes=20, is_train=False) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) 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) restore_from = args.restore_from state_dict = model.state_dict().copy() state_dict_old = torch.load(restore_from) state_dict_old = state_dict_old['state_dict'] for key, nkey in zip(state_dict_old.keys(), state_dict.keys()): if key != nkey: # remove the 'module.' in the 'key' 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,time_list= 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) # write_results(parsing_preds, scales, centers, args.data_dir, 'val', args.save_dir, input_size=input_size) # write_logits(parsing_logits, scales, centers, args.data_dir, 'val', args.save_dir, input_size=input_size) print(mIoU) print('total time is ',sum(time_list)) print('avg time is ',sum(time_list)/len(time_list))
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 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) model = Res_Deeplab(num_classes=args.num_classes) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) 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) restore_from = args.restore_from state_dict = model.state_dict().copy() state_dict_old = torch.load(restore_from) for key, nkey in zip(state_dict_old.keys(), state_dict.keys()): if key != nkey: # remove the 'module.' in the 'key' 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) print(mIoU)
def main(): """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) model = EAGRNet(args.num_classes, InPlaceABN) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) dataset = HelenDataSet(args.data_dir, args.dataset, crop_size=input_size, transform=transform) num_samples = len(dataset) valloader = data.DataLoader(dataset, batch_size=args.batch_size, shuffle=False, pin_memory=True) restore_from = args.restore_from state_dict_old = torch.load(restore_from, map_location='cuda:0') model.load_state_dict(state_dict_old) model.cuda() model.eval() save_path = os.path.join(args.data_dir, 'full') if not os.path.exists(save_path): os.makedirs(save_path) parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, save_path) mIoU, f1 = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, 'test', reverse=True) print(mIoU) print(f1)
def main(): """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(',')] if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu h, w = map(int, args.input_size.split(',')) input_size = [h, w] NUM_CLASSES = 7 # parsing NUM_HEATMAP = 15 # pose NUM_PAFS = 28 # pafs model = ParsingNet(num_classes=NUM_CLASSES, num_heatmaps=NUM_HEATMAP, num_pafs=NUM_PAFS) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) valdataset = VOCSegmentation(DATA_DIRECTORY, args.dataset, crop_size=input_size, transform=transform) num_samples = len(valdataset) num_classes = NUM_CLASSES valloader = data.DataLoader( valdataset, batch_size=args.batch_size * len(gpus), #batchsize shuffle=False, pin_memory=True) restore_from = args.restore_from try: state_dict = torch.load(restore_from)['state_dict'] load_state(model, state_dict) model.eval() model.cuda() parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, gpus) mIoU = compute_mean_ioU(parsing_preds, scales, centers, num_classes, args.data_dir, input_size) print(str(mIoU)) except: print("load model error")
def main(): """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(',')] print(args.gpu) h, w = map(int, args.input_size.split(',')) input_size = (h, w) cudnn.benchmark = True cudnn.enabled = True model = dml_csr.DML_CSR(args.num_classes, InPlaceABN, False) normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) dataset = datasets.FaceDataSet(args.data_dir, args.dataset, \ crop_size=input_size, transform=transform) num_samples = len(dataset) valloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, \ shuffle=False, pin_memory=True) restore_from = args.restore_from print(restore_from) state_dict = torch.load(restore_from, map_location='cuda:0') model.load_state_dict(state_dict) model.cuda() model.eval() save_path = os.path.join(args.out_dir, args.dataset, 'parsing') if not os.path.exists(save_path): os.makedirs(save_path) parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples, save_path) mIoU, f1 = miou.compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, \ input_size, args.dataset, reverse=True) print(mIoU) print(f1)
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 evaluation process.""" args = get_arguments() multi_scales = [float(i) for i in args.multi_scales.split(',')] gpus = [int(i) for i in args.gpu.split(',')] assert len(gpus) == 1 if not args.gpu == 'None': os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu cudnn.benchmark = True cudnn.enabled = True h, w = map(int, args.input_size.split(',')) input_size = [h, w] model = networks.init_model(args.arch, num_classes=args.num_classes, pretrained=None) IMAGE_MEAN = model.mean IMAGE_STD = model.std INPUT_SPACE = model.input_space print('image mean: {}'.format(IMAGE_MEAN)) print('image std: {}'.format(IMAGE_STD)) print('input space:{}'.format(INPUT_SPACE)) if INPUT_SPACE == 'BGR': print('BGR Transformation') transform = transforms.Compose([ transforms.ToTensor(), transforms.Normalize(mean=IMAGE_MEAN, std=IMAGE_STD), ]) if INPUT_SPACE == 'RGB': print('RGB Transformation') transform = transforms.Compose([ transforms.ToTensor(), BGR2RGB_transform(), transforms.Normalize(mean=IMAGE_MEAN, std=IMAGE_STD), ]) # Data loader lip_test_dataset = LIPDataValSet(args.data_dir, 'val', crop_size=input_size, transform=transform, flip=args.flip) num_samples = len(lip_test_dataset) print('Totoal testing sample numbers: {}'.format(num_samples)) testloader = data.DataLoader(lip_test_dataset, batch_size=args.batch_size, shuffle=False, pin_memory=True) # Load model weight state_dict = torch.load(args.model_restore)['state_dict'] from collections import OrderedDict new_state_dict = OrderedDict() for k, v in state_dict.items(): name = k[7:] # remove `module.` new_state_dict[name] = v model.load_state_dict(new_state_dict) model.cuda() model.eval() sp_results_dir = os.path.join(args.log_dir, 'sp_results') if not os.path.exists(sp_results_dir): os.makedirs(sp_results_dir) palette = get_palette(20) parsing_preds = [] scales = np.zeros((num_samples, 2), dtype=np.float32) centers = np.zeros((num_samples, 2), dtype=np.int32) with torch.no_grad(): for idx, batch in enumerate(tqdm(testloader)): image, meta = batch if (len(image.shape) > 4): image = image.squeeze() im_name = meta['name'][0] c = meta['center'].numpy()[0] s = meta['scale'].numpy()[0] w = meta['width'].numpy()[0] h = meta['height'].numpy()[0] scales[idx, :] = s centers[idx, :] = c parsing, logits = multi_scale_testing(model, image.cuda(), crop_size=input_size, flip=args.flip, multi_scales=multi_scales) if args.save_results: parsing_result = transform_parsing(parsing, c, s, w, h, input_size) parsing_result_path = os.path.join(sp_results_dir, im_name + '.png') output_im = PILImage.fromarray( np.asarray(parsing_result, dtype=np.uint8)) output_im.putpalette(palette) output_im.save(parsing_result_path) parsing_preds.append(parsing) assert len(parsing_preds) == num_samples mIoU = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size) print(mIoU) return
def main(): """Create the model and start the training.""" if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) h, w = map(int, args.input_size.split(',')) input_size = [h, w] best_f1 = 0 torch.cuda.set_device(args.local_rank) try: world_size = int(os.environ['WORLD_SIZE']) distributed = world_size > 1 except: distributed = False world_size = 1 if distributed: dist.init_process_group(backend=args.dist_backend, init_method='env://') rank = 0 if not distributed else dist.get_rank() writer = SummaryWriter(osp.join(args.snapshot_dir, TIMESTAMP)) if rank == 0 else None 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.type == 'Helen': train_dataset = HelenDataSet('dataset/Helen_align_with_hair', args.dataset, crop_size=input_size, transform=transform) val_dataset = HelenDataSet('dataset/Helen_align_with_hair', 'test', crop_size=input_size, transform=transform) args.num_classes = 11 elif args.type == 'LaPa': train_dataset = LapaDataset('dataset/LaPa/origin', args.dataset, crop_size=input_size, transform=transform) val_dataset = LapaDataset('dataset/LaPa/origin', 'test', crop_size=input_size, transform=transform) args.num_classes = 11 elif args.type == 'Celeb': train_dataset = CelebAMaskHQDataSet('dataset/CelebAMask-HQ', args.dataset, crop_size=input_size, transform=transform) val_dataset = CelebAMaskHQDataSet('dataset/CelebAMask-HQ', 'test', crop_size=input_size, transform=transform) args.num_classes = 19 elif args.type == 'LIP': train_dataset = LIPDataSet('dataset/LIP', args.dataset, crop_size=input_size, transform=transform) val_dataset = LIPDataSet('dataset/LIP', 'val', crop_size=input_size, transform=transform) args.num_classes = 20 if distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( train_dataset) else: train_sampler = None trainloader = data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=False, num_workers=2, pin_memory=True, drop_last=True, sampler=train_sampler) num_samples = len(val_dataset) valloader = data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, pin_memory=True, drop_last=False) cudnn.enabled = True # cudnn related setting cudnn.benchmark = True torch.backends.cudnn.deterministic = False torch.backends.cudnn.enabled = True if distributed: model = AGRNet(args.num_classes) else: model = AGRNet(args.num_classes, InPlaceABN) if args.restore_from is not None: model.load_state_dict( torch.load(args.restore_from, map_location='cuda:{}'.format(args.local_rank)), True) else: resnet_params = torch.load( os.path.join(args.snapshot_dir, 'resnet101-imagenet.pth')) new_params = model.state_dict().copy() for i in resnet_params: i_parts = i.split('.') # print(i_parts) if not i_parts[0] == 'fc': new_params['.'.join(i_parts[0:])] = resnet_params[i] model.load_state_dict(new_params) model.cuda() if distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.local_rank], output_device=args.local_rank, find_unused_parameters=True) else: model = SingleGPU(model) # CriterionCrossEntropyEdgeParsing_boundary_agrnet_loss for AGRNet, CriterionCrossEntropyEdgeParsing_boundary_eagrnet_loss for EAGRNet criterion = CriterionCrossEntropyEdgeParsing_boundary_agrnet_loss( loss_weight=[args.l1, args.l2, args.l3, args.l4], num_classes=args.num_classes) criterion.cuda() 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() if distributed: train_sampler.set_epoch(epoch) 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() with torch.no_grad(): loss = loss.detach() * labels.shape[0] count = labels.new_tensor([labels.shape[0]], dtype=torch.long) if dist.is_initialized(): dist.all_reduce(count, dist.ReduceOp.SUM) dist.all_reduce(loss, dist.ReduceOp.SUM) loss /= count.item() if not dist.is_initialized() or dist.get_rank() == 0: if i_iter % 50 == 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], args.save_num_images, args.num_classes, is_pred=True) pred_edges = decode_parsing(preds[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('Edge/', edge, i_iter) writer.add_image('Pred_edge/', pred_edge, i_iter) print('iter = {} of {} completed, loss = {}'.format( i_iter, total_iters, loss.data.cpu().numpy())) if not dist.is_initialized() or dist.get_rank() == 0: save_path = os.path.join(args.data_dir, TIMESTAMP) if not os.path.exists(save_path): os.makedirs(save_path) parsing_preds, scales, centers = valid( model, valloader, input_size, num_samples, osp.join(args.snapshot_dir, save_path)) mIoU, f1 = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, val_dataset, input_size, 'test', True, type=args.type) if f1['mean'] > best_f1: torch.save(model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth')) best_f1 = f1['mean'] print(mIoU) print(f1) writer.add_scalars('mIoU', mIoU, epoch) writer.add_scalars('f1', f1, epoch) if epoch % args.test_fre == 0: torch.save( model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'epoch_' + str(epoch) + '.pth')) 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) 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 = [int(i) for i in args.input_size.split(',')] input_size = [h, w] cudnn.enabled = True # cudnn related setting cudnn.benchmark = False torch.backends.cudnn.deterministic = False ##为何使用了非确定性的卷积 torch.backends.cudnn.enabled = True NUM_CLASSES = 7 # parsing NUM_HEATMAP = 15 # pose NUM_PAFS = 28 # pafs normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) transform = transforms.Compose([ transforms.ToTensor(), normalize, ]) # load dataset num_samples = 0 trainloader = data.DataLoader(VOCSegmentation(args.data_dir, args.dataset, crop_size=input_size, stride=args.stride, transform=transform), batch_size=args.batch_size * len(gpus), shuffle=True, num_workers=2, pin_memory=True) valloader = None if args.print_val != 0: valdataset = VOCSegmentation(args.data_dir, 'val', crop_size=input_size, transform=transform) num_samples = len(valdataset) valloader = data.DataLoader( valdataset, batch_size=8 * len(gpus), # batchsize shuffle=False, pin_memory=True) parsingnet = ParsingNet(num_classes=NUM_CLASSES, num_heatmaps=NUM_HEATMAP, num_pafs=NUM_PAFS) criterion_parsing = Criterion() criterion_parsing = DataParallelCriterion(criterion_parsing) criterion_parsing.cuda() optimizer_parsing = optim.SGD(parsingnet.parameters(), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) optimizer_parsing.zero_grad() # 加载预训练参数 print(args.train_continue) if not args.train_continue: checkpoint = torch.load(RESNET_IMAGENET) load_state(parsingnet, checkpoint) else: checkpoint = torch.load(args.restore_from_parsing) if 'current_epoch' in checkpoint: current_epoch = checkpoint['current_epoch'] args.start_epoch = current_epoch if 'state_dict' in checkpoint: checkpoint = checkpoint['state_dict'] load_state(parsingnet, checkpoint) parsingnet = DataParallelModel(parsingnet).cuda() total_iters = args.epochs * len(trainloader) for epoch in range(args.start_epoch, args.epochs): parsingnet.train() for i_iter, batch in enumerate(trainloader): i_iter += len(trainloader) * epoch lr = adjust_parsing_lr(optimizer_parsing, i_iter, total_iters) images, labels, edges, heatmap, pafs, heatmap_mask, pafs_mask, _ = batch images = images.cuda() labels = labels.long().cuda(non_blocking=True) edges = edges.long().cuda(non_blocking=True) heatmap = heatmap.cuda() pafs = pafs.cuda() heatmap_mask = heatmap_mask.cuda() pafs_mask = pafs_mask.cuda() preds = parsingnet(images) loss_parsing = criterion_parsing( preds, [labels, edges, heatmap, pafs, heatmap_mask, pafs_mask], writer, i_iter, total_iters) optimizer_parsing.zero_grad() loss_parsing.backward() optimizer_parsing.step() if i_iter % 100 == 0: writer.add_scalar('parsing_lr', lr, i_iter) writer.add_scalar('loss_total', loss_parsing.item(), i_iter) if i_iter % 500 == 0: if len(gpus) > 1: preds = preds[0] images_inv = inv_preprocess(images, args.save_num_images) parsing_labels_c = decode_parsing(labels, args.save_num_images, is_pred=False) preds_colors = decode_parsing(preds[0][-1], args.save_num_images, is_pred=True) edges_colors = decode_parsing(edges, args.save_num_images, is_pred=False) pred_edges = decode_parsing(preds[1][-1], args.save_num_images, is_pred=True) img = vutils.make_grid(images_inv, normalize=False, scale_each=True) parsing_lab = vutils.make_grid(parsing_labels_c, normalize=False, scale_each=True) pred_v = vutils.make_grid(preds_colors, normalize=False, scale_each=True) edge = vutils.make_grid(edges_colors, normalize=False, scale_each=True) pred_edges = vutils.make_grid(pred_edges, normalize=False, scale_each=True) writer.add_image('Images/', img, i_iter) writer.add_image('Parsing_labels/', parsing_lab, i_iter) writer.add_image('Parsing_Preds/', pred_v, i_iter) writer.add_image('Edges/', edge, i_iter) writer.add_image('Edges_preds/', pred_edges, i_iter) if (epoch + 1) % 15 == 0: if args.print_val != 0: parsing_preds, scales, centers = valid(parsingnet, valloader, input_size, num_samples, gpus) mIoU = compute_mean_ioU(parsing_preds, scales, centers, NUM_CLASSES, args.data_dir, input_size) f = open(os.path.join(args.snapshot_dir, "val_res.txt"), "a+") f.write(str(epoch) + str(mIoU) + '\n') f.close() snapshot_name_parsing = osp.join( args.snapshot_dir, 'PASCAL_parsing_' + str(epoch) + '' + '.pth') torch.save( { 'state_dict': parsingnet.state_dict(), 'optimizer': optimizer_parsing.state_dict(), 'current_epoch': epoch }, snapshot_name_parsing) end = timeit.default_timer() print(end - start, 'seconds')
def main(): """Create the model and start the training.""" cycle_n = 0 start_epoch = args.start_epoch writer = SummaryWriter(osp.join(args.snapshot_dir, TIMESTAMP)) if not os.path.exists(args.snapshot_dir): os.makedirs(args.snapshot_dir) h, w = map(int, args.input_size.split(',')) input_size = [h, w] best_f1 = 0 torch.cuda.set_device(args.local_rank) try: world_size = int(os.environ['WORLD_SIZE']) distributed = world_size > 1 except: distributed = False world_size = 1 if distributed: dist.init_process_group(backend=args.dist_backend, init_method='env://') rank = 0 if not distributed else dist.get_rank() log_file = args.snapshot_dir + '/' + TIMESTAMP + 'output.log' logger = get_root_logger(log_file=log_file, log_level='INFO') logger.info(f'Distributed training: {distributed}') cudnn.enabled = True cudnn.benchmark = True torch.backends.cudnn.deterministic = False torch.backends.cudnn.enabled = True if distributed: model = dml_csr.DML_CSR(args.num_classes) schp_model = dml_csr.DML_CSR(args.num_classes) else: model = dml_csr.DML_CSR(args.num_classes, InPlaceABN) schp_model = dml_csr.DML_CSR(args.num_classes, InPlaceABN) if args.restore_from is not None: print('Resume training from {}'.format(args.restore_from)) model.load_state_dict(torch.load(args.restore_from), True) start_epoch = int(float( args.restore_from.split('.')[0].split('_')[-1])) + 1 else: resnet_params = torch.load(RESTORE_FROM) new_params = model.state_dict().copy() for i in resnet_params: i_parts = i.split('.') if not i_parts[0] == 'fc': new_params['.'.join(i_parts[0:])] = resnet_params[i] model.load_state_dict(new_params) model.cuda() args.schp_restore = osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth') if os.path.exists(args.schp_restore): print('Resume schp checkpoint from {}'.format(args.schp_restore)) schp_model.load_state_dict(torch.load(args.schp_restore), True) else: schp_resnet_params = torch.load(RESTORE_FROM) schp_new_params = schp_model.state_dict().copy() for i in schp_resnet_params: i_parts = i.split('.') if not i_parts[0] == 'fc': schp_new_params['.'.join(i_parts[0:])] = schp_resnet_params[i] schp_model.load_state_dict(schp_new_params) schp_model.cuda() if distributed: model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.local_rank], output_device=args.local_rank, find_unused_parameters=True) schp_model = torch.nn.parallel.DistributedDataParallel( schp_model, device_ids=[args.local_rank], output_device=args.local_rank, find_unused_parameters=True) else: model = SingleGPU(model) schp_model = SingleGPU(schp_model) criterion = Criterion(loss_weight=[1, 1, 1, 4, 1], lambda_1=args.lambda_s, lambda_2=args.lambda_e, lambda_3=args.lambda_c, num_classes=args.num_classes) 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]) train_dataset = FaceDataSet(args.data_dir, args.train_dataset, crop_size=input_size, transform=transform) if distributed: train_sampler = torch.utils.data.distributed.DistributedSampler( train_dataset) else: train_sampler = None trainloader = data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=False, num_workers=2, pin_memory=True, drop_last=True, sampler=train_sampler) val_dataset = datasets[str(args.model_type)](args.data_dir, args.valid_dataset, crop_size=input_size, transform=transform) num_samples = len(val_dataset) valloader = data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, pin_memory=True, drop_last=False) # 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) optimizer.zero_grad() total_iters = args.epochs * len(trainloader) start = timeit.default_timer() for epoch in range(start_epoch, args.epochs): model.train() if distributed: train_sampler.set_epoch(epoch) for i_iter, batch in enumerate(trainloader): i_iter += len(trainloader) * epoch if epoch < args.schp_start: lr = adjust_learning_rate(optimizer, i_iter, total_iters) else: lr = lr_scheduler.get_lr()[0] images, labels, edges, semantic_edges, _ = batch labels = labels.long().cuda(non_blocking=True) edges = edges.long().cuda(non_blocking=True) semantic_edges = semantic_edges.long().cuda(non_blocking=True) preds = model(images) if cycle_n >= 1: with torch.no_grad(): soft_preds, soft_edges, soft_semantic_edges = schp_model( images) else: soft_preds = None soft_edges = None soft_semantic_edges = None loss = criterion(preds, [ labels, edges, semantic_edges, soft_preds, soft_edges, soft_semantic_edges ], cycle_n) optimizer.zero_grad() loss.backward() optimizer.step() lr_scheduler.step() with torch.no_grad(): loss = loss.detach() * labels.shape[0] count = labels.new_tensor([labels.shape[0]], dtype=torch.long) if dist.is_initialized(): dist.all_reduce(count, dist.ReduceOp.SUM) dist.all_reduce(loss, dist.ReduceOp.SUM) loss /= count.item() if not dist.is_initialized() or dist.get_rank() == 0: if i_iter % 50 == 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) semantic_edges_colors = decode_parsing( semantic_edges, args.save_num_images, args.num_classes, is_pred=False) if isinstance(preds, list): preds = preds[0] preds_colors = decode_parsing(preds[0], args.save_num_images, args.num_classes, is_pred=True) pred_edges = decode_parsing(preds[1], args.save_num_images, 2, is_pred=True) pred_semantic_edges_colors = decode_parsing( preds[2], args.save_num_images, args.num_classes, 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) pred_semantic_edges = vutils.make_grid( pred_semantic_edges_colors, 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('Edge/', edge, i_iter) writer.add_image('Pred_edge/', pred_edge, i_iter) cur_loss = loss.data.cpu().numpy() logger.info( f'iter = {i_iter} of {total_iters} completed, loss = {cur_loss}, lr = {lr}' ) if (epoch + 1) % (args.eval_epochs) == 0: parsing_preds, scales, centers = valid(model, valloader, input_size, num_samples) mIoU, f1 = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, args.valid_dataset, True) if not dist.is_initialized() or dist.get_rank() == 0: torch.save( model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'checkpoint_{}.pth'.format(epoch + 1))) if 'Helen' in args.data_dir: if f1['overall'] > best_f1: torch.save( model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth')) best_f1 = f1['overall'] else: if f1['Mean_F1'] > best_f1: torch.save( model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth')) best_f1 = f1['Mean_F1'] writer.add_scalars('mIoU', mIoU, epoch) writer.add_scalars('f1', f1, epoch) logger.info( f'mIoU = {mIoU}, and f1 = {f1} of epoch = {epoch}, util now, best_f1 = {best_f1}' ) if (epoch + 1) >= args.schp_start and ( epoch + 1 - args.schp_start) % args.cycle_epochs == 0: logger.info(f'Self-correction cycle number {cycle_n}') schp.moving_average(schp_model, model, 1.0 / (cycle_n + 1)) cycle_n += 1 schp.bn_re_estimate(trainloader, schp_model) parsing_preds, scales, centers = valid(schp_model, valloader, input_size, num_samples) mIoU, f1 = compute_mean_ioU(parsing_preds, scales, centers, args.num_classes, args.data_dir, input_size, args.valid_dataset, True) if not dist.is_initialized() or dist.get_rank() == 0: torch.save( schp_model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'schp_{}_checkpoint.pth'.format(cycle_n))) if 'Helen' in args.data_dir: if f1['overall'] > best_f1: torch.save( schp_model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth')) best_f1 = f1['overall'] else: if f1['Mean_F1'] > best_f1: torch.save( schp_model.module.state_dict(), osp.join(args.snapshot_dir, TIMESTAMP, 'best.pth')) best_f1 = f1['Mean_F1'] writer.add_scalars('mIoU', mIoU, epoch) writer.add_scalars('f1', f1, epoch) logger.info( f'mIoU = {mIoU}, and f1 = {f1} of epoch = {epoch}, util now, best_f1 = {best_f1}' ) 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(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) timestramp = args.date writer = SummaryWriter(os.path.join(args.snapshot_dir, timestramp)) 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) model = DataParallelModel(deeplab) if args.resume: # when restore form the same network, it is useful here checkpoint = torch.load(args.restore_from) model.load_state_dict(checkpoint['net']) args.start_epoch = checkpoint['epoch'] else: 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) 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) log = Logger(os.path.join(args.log_dir, '{}_train.log'.format(timestramp)), level='debug') for epoch in range(args.start_epoch, args.epochs): model.train() #lr = adjust_learning_rate_pose(optimizer, epoch) for i_iter, batch in enumerate(trainloader): i_iter += len(trainloader) * epoch lr = adjust_learning_rate(optimizer, i_iter, total_iters) images, labels, r1, r2, r3, r4, l0, l1, l2, l3, l4, l5, _ = batch labels = labels.long().cuda(non_blocking=True) r1 = r1.long().cuda(non_blocking=True) r2 = r2.long().cuda(non_blocking=True) r3 = r3.long().cuda(non_blocking=True) r4 = r4.long().cuda(non_blocking=True) l0 = l0.long().cuda(non_blocking=True) l1 = l1.long().cuda(non_blocking=True) l2 = l2.long().cuda(non_blocking=True) l3 = l3.long().cuda(non_blocking=True) l4 = l4.long().cuda(non_blocking=True) l5 = l5.long().cuda(non_blocking=True) preds = model(images) loss = criterion( preds, [[labels], [r1, r2, r3, r4], [l0, l1, l2, l3, l4, l5]]) 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 % 10 == 0: log.logger.info( 'epoch = {} iter = {} of {} completed, lr = {}, loss = {}'. format(epoch, i_iter, total_iters, lr, loss.data.cpu().numpy())) 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) log.logger.info('epoch = {}'.format(epoch)) log.logger.info(str(mIoU)) writer.add_scalars('mIoU', mIoU, epoch) # save the model snapshot state = {"net": model.module.state_dict(), "epoch": epoch} torch.save( state, osp.join(args.snapshot_dir, timestramp, 'LIP_epoch_' + str(epoch) + '.pth')) 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) 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')