def main(args):
  assert torch.cuda.is_available(), 'CUDA is not available.'
  torch.backends.cudnn.enabled   = True
  torch.backends.cudnn.benchmark = True
  prepare_seed(args.rand_seed)

  logstr = 'seed-{:}-time-{:}'.format(args.rand_seed, time_for_file())
  logger = Logger(args.save_path, logstr)
  logger.log('Main Function with logger : {:}'.format(logger))
  logger.log('Arguments : -------------------------------')
  for name, value in args._get_kwargs():
    logger.log('{:16} : {:}'.format(name, value))
  logger.log("Python  version : {}".format(sys.version.replace('\n', ' ')))
  logger.log("Pillow  version : {}".format(PIL.__version__))
  logger.log("PyTorch version : {}".format(torch.__version__))
  logger.log("cuDNN   version : {}".format(torch.backends.cudnn.version()))

  # General Data Argumentation
  mean_fill   = tuple( [int(x*255) for x in [0.485, 0.456, 0.406] ] )
  normalize   = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                      std=[0.229, 0.224, 0.225])
  assert args.arg_flip == False, 'The flip is : {}, rotate is {}'.format(args.arg_flip, args.rotate_max)
  train_transform  = [transforms.PreCrop(args.pre_crop_expand)]
  train_transform += [transforms.TrainScale2WH((args.crop_width, args.crop_height))]
  train_transform += [transforms.AugScale(args.scale_prob, args.scale_min, args.scale_max)]
  #if args.arg_flip:
  #  train_transform += [transforms.AugHorizontalFlip()]
  if args.rotate_max:
    train_transform += [transforms.AugRotate(args.rotate_max)]
  train_transform += [transforms.AugCrop(args.crop_width, args.crop_height, args.crop_perturb_max, mean_fill)]
  train_transform += [transforms.ToTensor(), normalize]
  train_transform  = transforms.Compose( train_transform )

  eval_transform  = transforms.Compose([transforms.PreCrop(args.pre_crop_expand), transforms.TrainScale2WH((args.crop_width, args.crop_height)),  transforms.ToTensor(), normalize])
  assert (args.scale_min+args.scale_max) / 2 == args.scale_eval, 'The scale is not ok : {},{} vs {}'.format(args.scale_min, args.scale_max, args.scale_eval)
  
  # Model Configure Load
  model_config = load_configure(args.model_config, logger)
  args.sigma   = args.sigma * args.scale_eval
  logger.log('Real Sigma : {:}'.format(args.sigma))

  # Training Dataset
  train_data   = Dataset(train_transform, args.sigma, model_config.downsample, args.heatmap_type, args.data_indicator)
  train_data.load_list(args.train_lists, args.num_pts, True)
  train_loader = torch.utils.data.DataLoader(train_data, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True)


  # Evaluation Dataloader
  eval_loaders = []
  if args.eval_vlists is not None:
    for eval_vlist in args.eval_vlists:
      eval_vdata = Dataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, args.data_indicator)
      eval_vdata.load_list(eval_vlist, args.num_pts, True)
      eval_vloader = torch.utils.data.DataLoader(eval_vdata, batch_size=args.batch_size, shuffle=False,
                                                 num_workers=args.workers, pin_memory=True)
      eval_loaders.append((eval_vloader, True))

  if args.eval_ilists is not None:
    for eval_ilist in args.eval_ilists:
      eval_idata = Dataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, args.data_indicator)
      eval_idata.load_list(eval_ilist, args.num_pts, True)
      eval_iloader = torch.utils.data.DataLoader(eval_idata, batch_size=args.batch_size, shuffle=False,
                                                 num_workers=args.workers, pin_memory=True)
      eval_loaders.append((eval_iloader, False))

  # Define network
  logger.log('configure : {:}'.format(model_config))
  net = obtain_model(model_config, args.num_pts + 1)
  assert model_config.downsample == net.downsample, 'downsample is not correct : {} vs {}'.format(model_config.downsample, net.downsample)
  logger.log("=> network :\n {}".format(net))

  logger.log('Training-data : {:}'.format(train_data))
  for i, eval_loader in enumerate(eval_loaders):
    eval_loader, is_video = eval_loader
    logger.log('The [{:2d}/{:2d}]-th testing-data [{:}] = {:}'.format(i, len(eval_loaders), 'video' if is_video else 'image', eval_loader.dataset))
    
  logger.log('arguments : {:}'.format(args))

  opt_config = load_configure(args.opt_config, logger)

  if hasattr(net, 'specify_parameter'):
    net_param_dict = net.specify_parameter(opt_config.LR, opt_config.Decay)
  else:
    net_param_dict = net.parameters()

  optimizer, scheduler, criterion = obtain_optimizer(net_param_dict, opt_config, logger)
  logger.log('criterion : {:}'.format(criterion))
  net, criterion = net.cuda(), criterion.cuda()
  net = torch.nn.DataParallel(net)

  last_info = logger.last_info()
  if last_info.exists():
    logger.log("=> loading checkpoint of the last-info '{:}' start".format(last_info))
    last_info = torch.load(last_info)
    start_epoch = last_info['epoch'] + 1
    checkpoint  = torch.load(last_info['last_checkpoint'])
    assert last_info['epoch'] == checkpoint['epoch'], 'Last-Info is not right {:} vs {:}'.format(last_info, checkpoint['epoch'])
    net.load_state_dict(checkpoint['state_dict'])
    optimizer.load_state_dict(checkpoint['optimizer'])
    scheduler.load_state_dict(checkpoint['scheduler'])
    logger.log("=> load-ok checkpoint '{:}' (epoch {:}) done" .format(logger.last_info(), checkpoint['epoch']))
  else:
    logger.log("=> do not find the last-info file : {:}".format(last_info))
    start_epoch = 0


  if args.eval_once:
    logger.log("=> only evaluate the model once")
    eval_results = eval_all(args, eval_loaders, net, criterion, 'eval-once', logger, opt_config)
    logger.close() ; return


  # Main Training and Evaluation Loop
  start_time = time.time()
  epoch_time = AverageMeter()
  for epoch in range(start_epoch, opt_config.epochs):

    scheduler.step()
    need_time = convert_secs2time(epoch_time.avg * (opt_config.epochs-epoch), True)
    epoch_str = 'epoch-{:03d}-{:03d}'.format(epoch, opt_config.epochs)
    LRs       = scheduler.get_lr()
    logger.log('\n==>>{:s} [{:s}], [{:s}], LR : [{:.5f} ~ {:.5f}], Config : {:}'.format(time_string(), epoch_str, need_time, min(LRs), max(LRs), opt_config))

    # train for one epoch
    train_loss, train_nme = train(args, train_loader, net, criterion, optimizer, epoch_str, logger, opt_config)
    # log the results    
    logger.log('==>>{:s} Train [{:}] Average Loss = {:.6f}, NME = {:.2f}'.format(time_string(), epoch_str, train_loss, train_nme*100))

    # remember best prec@1 and save checkpoint
    save_path = save_checkpoint({
          'epoch': epoch,
          'args' : deepcopy(args),
          'arch' : model_config.arch,
          'state_dict': net.state_dict(),
          'scheduler' : scheduler.state_dict(),
          'optimizer' : optimizer.state_dict(),
          }, logger.path('model') / '{:}-{:}.pth'.format(model_config.arch, epoch_str), logger)

    last_info = save_checkpoint({
          'epoch': epoch,
          'last_checkpoint': save_path,
          }, logger.last_info(), logger)

    eval_results = eval_all(args, eval_loaders, net, criterion, epoch_str, logger, opt_config)
    
    # measure elapsed time
    epoch_time.update(time.time() - start_time)
    start_time = time.time()

  logger.close()
def main(args):
    assert torch.cuda.is_available(), 'CUDA is not available.'
    torch.backends.cudnn.enabled = True
    torch.backends.cudnn.benchmark = True
    prepare_seed(args.rand_seed)

    logstr = 'seed-{:}-time-{:}'.format(args.rand_seed, time_for_file())
    logger = Logger(args.save_path, logstr)
    logger.log('Main Function with logger : {:}'.format(logger))
    logger.log('Arguments : -------------------------------')
    for name, value in args._get_kwargs():
        logger.log('{:16} : {:}'.format(name, value))
    logger.log("Python  version : {}".format(sys.version.replace('\n', ' ')))
    logger.log("Pillow  version : {}".format(PIL.__version__))
    logger.log("PyTorch version : {}".format(torch.__version__))
    logger.log("cuDNN   version : {}".format(torch.backends.cudnn.version()))

    # General Data Argumentation
    mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
    normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                     std=[0.229, 0.224, 0.225])
    assert args.arg_flip == False, 'The flip is : {}, rotate is {}'.format(
        args.arg_flip, args.rotate_max)
    train_transform = [transforms.PreCrop(args.pre_crop_expand)]
    train_transform += [
        transforms.TrainScale2WH((args.crop_width, args.crop_height))
    ]
    train_transform += [
        transforms.AugScale(args.scale_prob, args.scale_min, args.scale_max)
    ]
    #if args.arg_flip:
    #  train_transform += [transforms.AugHorizontalFlip()]
    if args.rotate_max:
        train_transform += [transforms.AugRotate(args.rotate_max)]
    train_transform += [
        transforms.AugCrop(args.crop_width, args.crop_height,
                           args.crop_perturb_max, mean_fill)
    ]
    train_transform += [transforms.ToTensor(), normalize]
    train_transform = transforms.Compose(train_transform)

    eval_transform = transforms.Compose([
        transforms.PreCrop(args.pre_crop_expand),
        transforms.TrainScale2WH((args.crop_width, args.crop_height)),
        transforms.ToTensor(), normalize
    ])
    assert (
        args.scale_min + args.scale_max
    ) / 2 == args.scale_eval, 'The scale is not ok : {},{} vs {}'.format(
        args.scale_min, args.scale_max, args.scale_eval)

    # Model Configure Load
    model_config = load_configure(args.model_config, logger)
    args.sigma = args.sigma * args.scale_eval
    logger.log('Real Sigma : {:}'.format(args.sigma))

    # Training Dataset
    train_data = VDataset(train_transform, args.sigma, model_config.downsample,
                          args.heatmap_type, args.data_indicator,
                          args.video_parser)
    train_data.load_list(args.train_lists, args.num_pts, True)
    train_loader = torch.utils.data.DataLoader(train_data,
                                               batch_size=args.batch_size,
                                               shuffle=True,
                                               num_workers=args.workers,
                                               pin_memory=True)

    # Evaluation Dataloader
    eval_loaders = []
    if args.eval_vlists is not None:
        for eval_vlist in args.eval_vlists:
            eval_vdata = IDataset(eval_transform, args.sigma,
                                  model_config.downsample, args.heatmap_type,
                                  args.data_indicator)
            eval_vdata.load_list(eval_vlist, args.num_pts, True)
            eval_vloader = torch.utils.data.DataLoader(
                eval_vdata,
                batch_size=args.batch_size,
                shuffle=False,
                num_workers=args.workers,
                pin_memory=True)
            eval_loaders.append((eval_vloader, True))

    if args.eval_ilists is not None:
        for eval_ilist in args.eval_ilists:
            eval_idata = IDataset(eval_transform, args.sigma,
                                  model_config.downsample, args.heatmap_type,
                                  args.data_indicator)
            eval_idata.load_list(eval_ilist, args.num_pts, True)
            eval_iloader = torch.utils.data.DataLoader(
                eval_idata,
                batch_size=args.batch_size,
                shuffle=False,
                num_workers=args.workers,
                pin_memory=True)
            eval_loaders.append((eval_iloader, False))

    # Define network
    lk_config = load_configure(args.lk_config, logger)
    logger.log('model configure : {:}'.format(model_config))
    logger.log('LK configure : {:}'.format(lk_config))
    net = obtain_model(model_config, lk_config, args.num_pts + 1)
    assert model_config.downsample == net.downsample, 'downsample is not correct : {} vs {}'.format(
        model_config.downsample, net.downsample)
    logger.log("=> network :\n {}".format(net))

    logger.log('Training-data : {:}'.format(train_data))
    for i, eval_loader in enumerate(eval_loaders):
        eval_loader, is_video = eval_loader
        logger.log('The [{:2d}/{:2d}]-th testing-data [{:}] = {:}'.format(
            i, len(eval_loaders), 'video' if is_video else 'image',
            eval_loader.dataset))

    logger.log('arguments : {:}'.format(args))

    opt_config = load_configure(args.opt_config, logger)

    if hasattr(net, 'specify_parameter'):
        net_param_dict = net.specify_parameter(opt_config.LR, opt_config.Decay)
    else:
        net_param_dict = net.parameters()

    optimizer, scheduler, criterion = obtain_optimizer(net_param_dict,
                                                       opt_config, logger)
    logger.log('criterion : {:}'.format(criterion))
    net, criterion = net.cuda(), criterion.cuda()
    net = torch.nn.DataParallel(net)

    last_info = logger.last_info()
    if last_info.exists():
        logger.log("=> loading checkpoint of the last-info '{:}' start".format(
            last_info))
        last_info = torch.load(last_info)
        start_epoch = last_info['epoch'] + 1
        checkpoint = torch.load(last_info['last_checkpoint'])
        assert last_info['epoch'] == checkpoint[
            'epoch'], 'Last-Info is not right {:} vs {:}'.format(
                last_info, checkpoint['epoch'])
        net.load_state_dict(checkpoint['state_dict'])
        optimizer.load_state_dict(checkpoint['optimizer'])
        scheduler.load_state_dict(checkpoint['scheduler'])
        logger.log("=> load-ok checkpoint '{:}' (epoch {:}) done".format(
            logger.last_info(), checkpoint['epoch']))
    elif args.init_model is not None:
        init_model = Path(args.init_model)
        assert init_model.exists(), 'init-model {:} does not exist'.format(
            init_model)
        checkpoint = torch.load(init_model)
        checkpoint = remove_module_dict(checkpoint['state_dict'], True)
        net.module.detector.load_state_dict(checkpoint)
        logger.log("=> initialize the detector : {:}".format(init_model))
        start_epoch = 0
    else:
        logger.log("=> do not find the last-info file : {:}".format(last_info))
        start_epoch = 0

    detector = torch.nn.DataParallel(net.module.detector)

    eval_results = eval_all(args, eval_loaders, detector, criterion,
                            'start-eval', logger, opt_config)
    if args.eval_once:
        logger.log("=> only evaluate the model once")
        logger.close()
        return

    # Main Training and Evaluation Loop
    start_time = time.time()
    epoch_time = AverageMeter()
    for epoch in range(start_epoch, opt_config.epochs):

        scheduler.step()
        need_time = convert_secs2time(
            epoch_time.avg * (opt_config.epochs - epoch), True)
        epoch_str = 'epoch-{:03d}-{:03d}'.format(epoch, opt_config.epochs)
        LRs = scheduler.get_lr()
        logger.log(
            '\n==>>{:s} [{:s}], [{:s}], LR : [{:.5f} ~ {:.5f}], Config : {:}'.
            format(time_string(), epoch_str, need_time, min(LRs), max(LRs),
                   opt_config))

        # train for one epoch
        train_loss = train(args, train_loader, net, criterion, optimizer,
                           epoch_str, logger, opt_config, lk_config,
                           epoch >= lk_config.start)
        # log the results
        logger.log('==>>{:s} Train [{:}] Average Loss = {:.6f}'.format(
            time_string(), epoch_str, train_loss))

        # remember best prec@1 and save checkpoint
        save_path = save_checkpoint(
            {
                'epoch': epoch,
                'args': deepcopy(args),
                'arch': model_config.arch,
                'state_dict': net.state_dict(),
                'detector': detector.state_dict(),
                'scheduler': scheduler.state_dict(),
                'optimizer': optimizer.state_dict(),
            },
            logger.path('model') /
            '{:}-{:}.pth'.format(model_config.arch, epoch_str), logger)

        last_info = save_checkpoint(
            {
                'epoch': epoch,
                'last_checkpoint': save_path,
            }, logger.last_info(), logger)

        eval_results = eval_all(args, eval_loaders, detector, criterion,
                                epoch_str, logger, opt_config)

        # measure elapsed time
        epoch_time.update(time.time() - start_time)
        start_time = time.time()

    logger.close()
예제 #3
0
def main(args):
    assert torch.cuda.is_available(), 'CUDA is not available.'
    torch.backends.cudnn.enabled = True
    torch.backends.cudnn.benchmark = True
    torch.set_num_threads(args.workers)
    print('Evaluate the Robustness of a Detector : prepare_seed : {:}'.format(
        args.rand_seed))
    prepare_seed(args.rand_seed)

    assert args.init_model is not None and Path(
        args.init_model).exists(), 'invalid initial model path : {:}'.format(
            args.init_model)

    checkpoint = load_checkpoint(args.init_model)
    xargs = checkpoint['args']
    eval_func = procedures[xargs.procedure]

    logger = prepare_logger(args)

    if xargs.use_gray == False:
        mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
        normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                         std=[0.229, 0.224, 0.225])
    else:
        mean_fill = (0.5, )
        normalize = transforms.Normalize(mean=[mean_fill[0]], std=[0.5])

    robust_component = [
        transforms.ToTensor(), normalize,
        transforms.PreCrop(xargs.pre_crop_expand)
    ]
    robust_component += [
        transforms.RandomTrans(args.robust_scale, args.robust_offset,
                               args.robust_rotate, args.robust_iters,
                               args.robust_cache_dir, True)
    ]
    robust_transform = transforms.Compose3V(robust_component)
    logger.log('--- arguments --- : {:}'.format(args))
    logger.log('robust_transform  : {:}'.format(robust_transform))

    recover = xvision.transforms2v.ToPILImage(normalize)
    model_config = load_configure(xargs.model_config, logger)
    shape = (xargs.height, xargs.width)
    logger.log('Model : {:} $$$$ Shape : {:}'.format(model_config, shape))

    # Evaluation Dataloader
    assert args.eval_lists is not None and len(
        args.eval_lists) > 0, 'invalid args.eval_lists : {:}'.format(
            args.eval_lists)
    eval_loaders = []
    for eval_list in args.eval_lists:
        eval_data = RobustDataset(robust_transform, xargs.sigma,
                                  model_config.downsample, xargs.heatmap_type,
                                  shape, xargs.use_gray, xargs.data_indicator)
        if xargs.x68to49:
            eval_data.load_list(eval_list, 68, xargs.boxindicator, True)
            convert68to49(eval_data)
        else:
            eval_data.load_list(eval_list, xargs.num_pts, xargs.boxindicator,
                                True)
        eval_data.get_normalization_distance(None, True)
        if hasattr(xargs, 'batch_size'):
            batch_size = xargs.batch_size
        elif hasattr(xargs, 'i_batch_size') and xargs.i_batch_size > 0:
            batch_size = xargs.i_batch_size
        elif hasattr(xargs, 'v_batch_size') and xargs.v_batch_size > 0:
            batch_size = xargs.v_batch_size
        else:
            raise ValueError(
                'can not find batch size information in xargs : {:}'.format(
                    xargs))
        eval_loader = torch.utils.data.DataLoader(eval_data,
                                                  batch_size=batch_size,
                                                  shuffle=False,
                                                  num_workers=args.workers,
                                                  pin_memory=True)
        eval_loaders.append(eval_loader)

    # define the detection network
    detector = obtain_pro_model(model_config, xargs.num_pts, xargs.sigma,
                                xargs.use_gray)
    assert model_config.downsample == detector.downsample, 'downsample is not correct : {:} vs {:}'.format(
        model_config.downsample, detector.downsample)
    logger.log("=> detector :\n {:}".format(detector))
    logger.log("=> Net-Parameters : {:} MB".format(
        count_parameters_in_MB(detector)))

    for i, eval_loader in enumerate(eval_loaders):
        logger.log('The [{:2d}/{:2d}]-th testing-data = {:}'.format(
            i, len(eval_loaders), eval_loader.dataset))

    logger.log('basic-arguments : {:}\n'.format(xargs))
    logger.log('xoxox-arguments : {:}\n'.format(args))

    detector.load_state_dict(remove_module_dict(checkpoint['detector']))
    detector = detector.cuda()

    for ieval, loader in enumerate(eval_loaders):
        errors, valids, meta = eval_func(detector, loader, args.print_freq,
                                         logger)
        logger.log(
            '[{:2d}/{:02d}] eval-data : error : mean={:.3f}, std={:.3f}'.
            format(ieval, len(eval_loaders), np.mean(errors), np.std(errors)))
        logger.log(
            '[{:2d}/{:02d}] eval-data : valid : mean={:.3f}, std={:.3f}'.
            format(ieval, len(eval_loaders), np.mean(valids), np.std(valids)))
        nme, auc, pck_curves = meta.compute_mse(loader.dataset.dataset_name,
                                                logger)
    logger.close()
예제 #4
0
def main(args):
  assert torch.cuda.is_available(), 'CUDA is not available.'
  torch.backends.cudnn.enabled   = True
  torch.backends.cudnn.benchmark = True
  torch.set_num_threads( args.workers )
  print ('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed))
  prepare_seed(args.rand_seed)

  temporal_main, eval_all = procedures['{:}-train'.format(args.procedure)], procedures['{:}-test'.format(args.procedure)]

  logger = prepare_logger(args)

  # General Data Argumentation
  normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation(transforms, args)
  recover = transforms.ToPILImage(normalize)
  args.tensor2imageF = recover
  assert (args.scale_min+args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format(args.scale_min, args.scale_max)
  
  # Model Configure Load
  model_config = load_configure(args.model_config, logger)
  sbr_config   = load_configure(args.sbr_config, logger)
  shape = (args.height, args.width)
  logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format(model_config, args.sigma, shape))
  logger.log('--> SBR Configuration : {:}\n'.format(sbr_config))

  # Training Dataset
  train_data   = VDataset(train_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, \
                            args.data_indicator, sbr_config, transforms.ToPILImage(normalize, 'cv2gray'))
  train_data.load_list(args.train_lists, args.num_pts, args.boxindicator, args.normalizeL, True)
  batch_sampler = SbrBatchSampler(train_data, args.i_batch_size, args.v_batch_size, args.sbr_sampler_use_vid)
  train_loader  = torch.utils.data.DataLoader(train_data, batch_sampler=batch_sampler, num_workers=args.workers, pin_memory=True)

  # Evaluation Dataloader
  eval_loaders = []
  if args.eval_ilists is not None:
    for eval_ilist in args.eval_ilists:
      eval_idata = IDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator)
      eval_idata.load_list(eval_ilist, args.num_pts, args.boxindicator, args.normalizeL, True)
      eval_iloader = torch.utils.data.DataLoader(eval_idata, batch_size=args.i_batch_size+args.v_batch_size, shuffle=False, num_workers=args.workers, pin_memory=True)
      eval_loaders.append((eval_iloader, False))
  if args.eval_vlists is not None:
    for eval_vlist in args.eval_vlists:
      eval_vdata = IDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, args.data_indicator)
      eval_vdata.load_list(eval_vlist, args.num_pts, args.boxindicator, args.normalizeL, True)
      eval_vloader = torch.utils.data.DataLoader(eval_vdata, batch_size=args.i_batch_size+args.v_batch_size, shuffle=False, num_workers=args.workers, pin_memory=True)
      eval_loaders.append((eval_vloader, True))
  # from 68 points to 49 points, removing the face contour
  if args.x68to49:
    assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format(args.num_pts)
    if train_data is not None: train_data = convert68to49( train_data )
    for eval_loader, is_video in eval_loaders:
      convert68to49( eval_loader.dataset )
    args.num_pts = 49

  # define the temporal model (accelerated SBR)
  net = obtain_pro_temporal(model_config, sbr_config, args.num_pts, args.sigma, args.use_gray)
  assert model_config.downsample == net.downsample, 'downsample is not correct : {:} vs {:}'.format(model_config.downsample, net.downsample)
  logger.log("=> network :\n {}".format(net))

  logger.log('Training-data : {:}'.format(train_data))
  for i, eval_loader in enumerate(eval_loaders):
    eval_loader, is_video = eval_loader
    logger.log('The [{:2d}/{:2d}]-th testing-data [{:}] = {:}'.format(i, len(eval_loaders), 'video' if is_video else 'image', eval_loader.dataset))

  logger.log('arguments : {:}'.format(args))
  opt_config = load_configure(args.opt_config, logger)

  if hasattr(net, 'specify_parameter'): net_param_dict = net.specify_parameter(opt_config.LR, opt_config.weight_decay)
  else                                : net_param_dict = net.parameters()

  optimizer, scheduler, criterion = obtain_optimizer(net_param_dict, opt_config, logger)
  logger.log('criterion : {:}'.format(criterion))
  net, criterion = net.cuda(), criterion.cuda()
  net = torch.nn.DataParallel(net)

  last_info = logger.last_info()
  if last_info.exists():
    logger.log("=> loading checkpoint of the last-info '{:}' start".format(last_info))
    last_info = torch.load(last_info)
    start_epoch = last_info['epoch'] + 1
    checkpoint  = torch.load(last_info['last_checkpoint'])
    test_accuracies = checkpoint['test_accuracies']
    assert last_info['epoch'] == checkpoint['epoch'], 'Last-Info is not right {:} vs {:}'.format(last_info, checkpoint['epoch'])
    net.load_state_dict(checkpoint['state_dict'])
    optimizer.load_state_dict(checkpoint['optimizer'])
    scheduler.load_state_dict(checkpoint['scheduler'])
    logger.log("=> load-ok checkpoint '{:}' (epoch {:}) done" .format(logger.last_info(), checkpoint['epoch']))
  elif args.init_model is not None:
    last_checkpoint = load_checkpoint(args.init_model)
    checkpoint = remove_module_dict(last_checkpoint['state_dict'], False)
    net.module.detector.load_state_dict( checkpoint )
    logger.log("=> initialize the detector : {:}".format(args.init_model))
    start_epoch, test_accuracies = 0, {'best': 10000}
  else:
    logger.log("=> do not find the last-info file : {:}".format(last_info))
    start_epoch, test_accuracies = 0, {'best': 10000}

  detector = torch.nn.DataParallel(net.module.detector)

  if args.skip_first_eval == False:
    logger.log('===>>> First Time Evaluation')
    eval_results, eval_metas = eval_all(args, eval_loaders, detector, criterion, 'Before-Training', logger, opt_config, None)
    save_path = save_checkpoint(eval_metas, logger.path('meta') / '{:}-first.pth'.format(model_config.arch), logger)
    logger.log('===>>> Before Training : {:}'.format(eval_results))

  # Main Training and Evaluation Loop
  start_time = time.time()
  epoch_time = AverageMeter()
  for epoch in range(start_epoch, opt_config.epochs):

    need_time = convert_secs2time(epoch_time.avg * (opt_config.epochs-epoch), True)
    epoch_str = 'epoch-{:03d}-{:03d}'.format(epoch, opt_config.epochs)
    LRs       = scheduler.get_lr()
    logger.log('\n==>>{:s} [{:s}], [{:s}], LR : [{:.5f} ~ {:.5f}], Config : {:}'.format(time_string(), epoch_str, need_time, min(LRs), max(LRs), opt_config))

    # train for one epoch
    train_loss, train_nme = temporal_main(args, train_loader, net, criterion, optimizer, epoch_str, logger, opt_config, sbr_config, epoch>=sbr_config.start, 'train')
    scheduler.step()
    # log the results    
    logger.log('==>>{:s} Train [{:}] Average Loss = {:.6f}, NME = {:.2f}'.format(time_string(), epoch_str, train_loss, train_nme*100))

    save_path = save_checkpoint({
          'epoch': epoch,
          'args' : deepcopy(args),
          'arch' : model_config.arch,
          'detector'  : detector.state_dict(),
          'test_accuracies': test_accuracies,
          'state_dict': net.state_dict(),
          'scheduler' : scheduler.state_dict(),
          'optimizer' : optimizer.state_dict(),
          }, logger.path('model') / 'ckp-seed-{:}-last-{:}.pth'.format(args.rand_seed, model_config.arch), logger)

    last_info = save_checkpoint({
          'epoch': epoch,
          'last_checkpoint': save_path,
          }, logger.last_info(), logger)
    if (args.eval_freq is None) or (epoch+1 == opt_config.epochs) or (epoch%args.eval_freq == 0):

      if epoch+1 == opt_config.epochs: _robust_transform = robust_transform
      else                           : _robust_transform = None
      logger.log('')
      eval_results, eval_metas = eval_all(args, eval_loaders, detector, criterion, epoch_str, logger, opt_config, _robust_transform)
      # check whether it is the best and save with copyfile(src, dst)
      try:
        cur_eval_nme = float( eval_results.split('NME =  ')[1].split(' ')[0] )
      except:
        cur_eval_nme = 1e9
      test_accuracies[epoch] = cur_eval_nme
      if test_accuracies['best'] > cur_eval_nme: # find the lowest error
        dest_path = logger.path('model') / 'ckp-seed-{:}-best-{:}.pth'.format(args.rand_seed, model_config.arch)
        copyfile(save_path, dest_path)
        logger.log('==>> find lowest error = {:}, save into {:}'.format(cur_eval_nme, dest_path))
      meta_save_path = save_checkpoint(eval_metas, logger.path('meta') / '{:}-{:}.pth'.format(model_config.arch, epoch_str), logger)
      logger.log('==>> evaluation results : {:}'.format(eval_results))
    
    # measure elapsed time
    epoch_time.update(time.time() - start_time)
    start_time = time.time()

  logger.log('Final checkpoint into {:}'.format(logger.last_info()))

  logger.close()
def main(args):
    assert torch.cuda.is_available(), 'CUDA is not available.'
    torch.backends.cudnn.enabled = True
    torch.backends.cudnn.benchmark = True
    torch.set_num_threads(args.workers)
    print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed))
    prepare_seed(args.rand_seed)

    basic_main, eval_all = procedures['{:}-train'.format(
        args.procedure)], procedures['{:}-test'.format(args.procedure)]

    logger = prepare_logger(args)

    # General Data Augmentation
    normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation(
        transforms, args)
    #data_cache = get_path2image( args.shared_img_cache )
    data_cache = None

    recover = transforms.ToPILImage(normalize)
    args.tensor2imageF = recover
    assert (args.scale_min +
            args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format(
                args.scale_min, args.scale_max)
    logger.log('robust_transform : {:}'.format(robust_transform))

    # Model Configure Load
    model_config = load_configure(args.model_config, logger)
    shape = (args.height, args.width)
    logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format(
        model_config, args.sigma, shape))

    # Training Dataset
    if args.train_lists:
        train_data = Dataset(train_transform, args.sigma,
                             model_config.downsample, args.heatmap_type, shape,
                             args.use_gray, args.mean_point,
                             args.data_indicator, data_cache)
        safex_data = Dataset(eval_transform, args.sigma,
                             model_config.downsample, args.heatmap_type, shape,
                             args.use_gray, args.mean_point,
                             args.data_indicator, data_cache)
        train_data.set_cutout(args.cutout_length)
        safex_data.set_cutout(args.cutout_length)
        train_data.load_list(args.train_lists, args.num_pts, args.boxindicator,
                             args.normalizeL, True)
        safex_data.load_list(args.train_lists, args.num_pts, args.boxindicator,
                             args.normalizeL, True)
        if args.sampler is None:
            train_loader = torch.utils.data.DataLoader(
                train_data,
                batch_size=args.batch_size,
                shuffle=True,
                num_workers=args.workers,
                drop_last=True,
                pin_memory=True)
            safex_loader = torch.utils.data.DataLoader(
                safex_data,
                batch_size=args.batch_size,
                shuffle=True,
                num_workers=args.workers,
                drop_last=True,
                pin_memory=True)
        else:
            train_sampler = SpecialBatchSampler(train_data, args.batch_size,
                                                args.sampler)
            safex_sampler = SpecialBatchSampler(safex_data, args.batch_size,
                                                args.sampler)
            logger.log('Training-sampler : {:}'.format(train_sampler))
            train_loader = torch.utils.data.DataLoader(
                train_data,
                batch_sampler=train_sampler,
                num_workers=args.workers,
                pin_memory=True)
            safex_loader = torch.utils.data.DataLoader(
                safex_data,
                batch_sampler=safex_sampler,
                num_workers=args.workers,
                pin_memory=True)
        logger.log('Training-data : {:}'.format(train_data))
    else:
        train_data, safex_loader = None, None

    #train_data[0]
    # Evaluation Dataloader
    eval_loaders = []
    if args.eval_ilists is not None:
        for eval_ilist in args.eval_ilists:
            eval_idata = Dataset(eval_transform, args.sigma,
                                 model_config.downsample, args.heatmap_type,
                                 shape, args.use_gray, args.mean_point,
                                 args.data_indicator, data_cache)
            eval_idata.load_list(eval_ilist, args.num_pts, args.boxindicator,
                                 args.normalizeL, True)
            eval_iloader = torch.utils.data.DataLoader(
                eval_idata,
                batch_size=args.batch_size,
                shuffle=False,
                num_workers=args.workers,
                pin_memory=True)
            eval_loaders.append((eval_iloader, False))
    if args.eval_vlists is not None:
        for eval_vlist in args.eval_vlists:
            eval_vdata = Dataset(eval_transform, args.sigma,
                                 model_config.downsample, args.heatmap_type,
                                 shape, args.use_gray, args.mean_point,
                                 args.data_indicator, data_cache)
            eval_vdata.load_list(eval_vlist, args.num_pts, args.boxindicator,
                                 args.normalizeL, True)
            eval_vloader = torch.utils.data.DataLoader(
                eval_vdata,
                batch_size=args.batch_size,
                shuffle=False,
                num_workers=args.workers,
                pin_memory=True)
            eval_loaders.append((eval_vloader, True))
    # from 68 points to 49 points, removing the face contour
    if args.x68to49:
        assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format(
            args.num_pts)
        if train_data is not None: train_data = convert68to49(train_data)
        for eval_loader, is_video in eval_loaders:
            convert68to49(eval_loader.dataset)
        args.num_pts = 49

    # define the detector
    detector = obtain_pro_model(model_config, args.num_pts, args.sigma,
                                args.use_gray)
    assert model_config.downsample == detector.downsample, 'downsample is not correct : {:} vs {:}'.format(
        model_config.downsample, detector.downsample)
    logger.log("=> detector :\n {:}".format(detector))
    logger.log("=> Net-Parameters : {:} MB".format(
        count_parameters_in_MB(detector)))

    for i, eval_loader in enumerate(eval_loaders):
        eval_loader, is_video = eval_loader
        logger.log('The [{:2d}/{:2d}]-th testing-data [{:}] = {:}'.format(
            i, len(eval_loaders), 'video' if is_video else 'image',
            eval_loader.dataset))

    logger.log('arguments : {:}\n'.format(args))
    logger.log('train_transform : {:}'.format(train_transform))
    logger.log('eval_transform  : {:}'.format(eval_transform))
    opt_config = load_configure(args.opt_config, logger)

    if hasattr(detector, 'specify_parameter'):
        net_param_dict = detector.specify_parameter(opt_config.LR,
                                                    opt_config.weight_decay)
    else:
        net_param_dict = detector.parameters()

    optimizer, scheduler, criterion = obtain_optimizer(net_param_dict,
                                                       opt_config, logger)
    logger.log('criterion : {:}'.format(criterion))
    detector, criterion = detector.cuda(), criterion.cuda()
    net = torch.nn.DataParallel(detector)

    last_info = logger.last_info()
    if last_info.exists():
        logger.log("=> loading checkpoint of the last-info '{:}' start".format(
            last_info))
        last_info = torch.load(last_info)
        start_epoch = last_info['epoch'] + 1
        checkpoint = torch.load(last_info['last_checkpoint'])
        assert last_info['epoch'] == checkpoint[
            'epoch'], 'Last-Info is not right {:} vs {:}'.format(
                last_info, checkpoint['epoch'])
        net.load_state_dict(checkpoint['state_dict'])
        optimizer.load_state_dict(checkpoint['optimizer'])
        scheduler.load_state_dict(checkpoint['scheduler'])
        logger.log("=> load-ok checkpoint '{:}' (epoch {:}) done".format(
            logger.last_info(), checkpoint['epoch']))
    elif args.init_model is not None:
        last_checkpoint = load_checkpoint(args.init_model)
        net.load_state_dict(last_checkpoint['detector'])
        logger.log("=> initialize the detector : {:}".format(args.init_model))
        start_epoch = 0
    else:
        logger.log("=> do not find the last-info file : {:}".format(last_info))
        start_epoch = 0

    if args.eval_once is not None:
        logger.log("=> only evaluate the model once")
        #if safex_loader is not None:
        #  safe_results, safe_metas = eval_all(args, [(safex_loader, False)], net, criterion, 'eval-once-train', logger, opt_config, robust_transform)
        #  logger.log('-'*50 + ' evaluate the training set')
        #import pdb; pdb.set_trace()
        eval_results, eval_metas = eval_all(args, eval_loaders, net, criterion,
                                            'eval-once', logger, opt_config,
                                            robust_transform)
        all_predictions = [eval_meta.predictions for eval_meta in eval_metas]
        torch.save(
            all_predictions,
            osp.join(args.save_path,
                     '{:}-predictions.pth'.format(args.eval_once)))
        logger.log('==>> evaluation results : {:}'.format(eval_results))
        logger.log('==>> configuration : {:}'.format(model_config))
        logger.close()
        return

    # Main Training and Evaluation Loop
    start_time = time.time()
    epoch_time = AverageMeter()
    for epoch in range(start_epoch, opt_config.epochs):

        need_time = convert_secs2time(
            epoch_time.avg * (opt_config.epochs - epoch), True)
        epoch_str = 'epoch-{:03d}-{:03d}'.format(epoch, opt_config.epochs)
        LRs = scheduler.get_lr()
        logger.log(
            '\n==>>{:s} [{:s}], [{:s}], LR : [{:.5f} ~ {:.5f}], Config : {:}'.
            format(time_string(), epoch_str, need_time, min(LRs), max(LRs),
                   opt_config))

        # train for one epoch
        train_loss, train_meta, train_nme = basic_main(args, train_loader, net,
                                                       criterion, optimizer,
                                                       epoch_str, logger,
                                                       opt_config, 'train')
        scheduler.step()
        # log the results
        logger.log(
            '==>>{:s} Train [{:}] Average Loss = {:.6f}, NME = {:.2f}'.format(
                time_string(), epoch_str, train_loss, train_nme * 100))

        save_path = save_checkpoint(
            {
                'epoch': epoch,
                'args': deepcopy(args),
                'arch': model_config.arch,
                'detector': net.state_dict(),
                'state_dict': net.state_dict(),
                'scheduler': scheduler.state_dict(),
                'optimizer': optimizer.state_dict(),
            },
            logger.path('model') /
            'seed-{:}-{:}.pth'.format(args.rand_seed, model_config.arch),
            logger)

        last_info = save_checkpoint(
            {
                'epoch': epoch,
                'args': deepcopy(args),
                'last_checkpoint': save_path,
            }, logger.last_info(), logger)

        if (args.eval_freq is None) or (epoch + 1 == opt_config.epochs) or (
                epoch % args.eval_freq == 0):
            if epoch + 1 == opt_config.epochs:
                _robust_transform = robust_transform
            else:
                _robust_transform = None
            logger.log('')
            eval_results, eval_metas = eval_all(args, eval_loaders, net,
                                                criterion, epoch_str, logger,
                                                opt_config, _robust_transform)
            #save_path = save_checkpoint(eval_metas, logger.path('meta') / '{:}-{:}.pth'.format(model_config.arch, epoch_str), logger)
            save_path = save_checkpoint(
                eval_metas,
                logger.path('meta') /
                'seed-{:}-{:}.pth'.format(args.rand_seed, model_config.arch),
                logger)
            logger.log(
                '==>> evaluation results : {:}\n==>> save evaluation results into {:}.'
                .format(eval_results, save_path))

        # measure elapsed time
        epoch_time.update(time.time() - start_time)
        start_time = time.time()

    logger.log('Final checkpoint into {:}'.format(logger.last_info()))
    logger.close()
def main(args):
    assert torch.cuda.is_available(), 'CUDA is not available.'
    torch.backends.cudnn.enabled = True
    torch.backends.cudnn.benchmark = True
    torch.set_num_threads(args.workers)
    print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed))
    prepare_seed(args.rand_seed)
    temporal_main, eval_all = procedures['{:}-train'.format(
        args.procedure)], procedures['{:}-test'.format(args.procedure)]

    logger = prepare_logger(args)

    # General Data Argumentation
    normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation(
        transforms, args)
    recover = transforms.ToPILImage(normalize)
    args.tensor2imageF = recover
    assert (args.scale_min +
            args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format(
                args.scale_min, args.scale_max)

    # Model Configure Load
    model_config = load_configure(args.model_config, logger)
    sbr_config = load_configure(args.sbr_config, logger)
    shape = (args.height, args.width)
    logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format(
        model_config, args.sigma, shape))
    logger.log('--> SBR Configuration : {:}\n'.format(sbr_config))

    # Training Dataset
    train_data   = VDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, \
                              args.data_indicator, sbr_config, transforms.ToPILImage(normalize, 'cv2gray'))
    train_data.load_list(args.train_lists, args.num_pts, args.boxindicator,
                         args.normalizeL, True)
    if args.x68to49:
        assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format(
            args.num_pts)
        if train_data is not None: train_data = convert68to49(train_data)
        args.num_pts = 49

    # define the temporal model (accelerated SBR)
    net = obtain_pro_temporal(model_config, sbr_config, args.num_pts,
                              args.sigma, args.use_gray)
    assert model_config.downsample == net.downsample, 'downsample is not correct : {:} vs {:}'.format(
        model_config.downsample, net.downsample)
    logger.log("=> network :\n {}".format(net))

    logger.log('Training-data : {:}'.format(train_data))

    logger.log('arguments : {:}'.format(args))
    opt_config = load_configure(args.opt_config, logger)

    optimizer, scheduler, criterion = obtain_optimizer(net.parameters(),
                                                       opt_config, logger)
    logger.log('criterion : {:}'.format(criterion))
    net, criterion = net.cuda(), criterion.cuda()
    net = torch.nn.DataParallel(net)

    last_info = logger.last_info()
    try:
        last_checkpoint = load_checkpoint(args.init_model)
        checkpoint = remove_module_dict(last_checkpoint['state_dict'], False)
        net.module.detector.load_state_dict(checkpoint)
    except:
        last_checkpoint = load_checkpoint(args.init_model)
        net.load_state_dict(last_checkpoint['state_dict'])

    detector = torch.nn.DataParallel(net.module.detector)
    logger.log("=> initialize the detector : {:}".format(args.init_model))

    net.eval()
    detector.eval()

    logger.log('SBR Config : {:}'.format(sbr_config))
    save_xdir = logger.path('meta')
    random.seed(111)
    index_list = list(range(len(train_data)))
    random.shuffle(index_list)
    #selected_list = index_list[: min(200, len(index_list))]
    #selected_list = [7260, 11506, 39952, 75196, 51614, 41061, 37747, 41355]
    #for iidx, i in enumerate(selected_list):
    index_list.remove(47875)
    selected_list = [47875] + index_list
    save_xdir = logger.path('meta')

    type_error_1, type_error_2, type_error, misses = 0, 0, 0, 0
    type_error_pts, total_pts = 0, 0
    for iidx, i in enumerate(selected_list):
        frames, Fflows, Bflows, targets, masks, normpoints, transthetas, meanthetas, image_index, nopoints, shapes, is_images = train_data[
            i]

        frames, Fflows, Bflows, is_images = frames.unsqueeze(
            0), Fflows.unsqueeze(0), Bflows.unsqueeze(0), is_images.unsqueeze(
                0)
        # batch_heatmaps is a list for stage-predictions, each element should be [Batch, Sequence, PTS, H/Down, W/Down]
        with torch.no_grad():
            if args.procedure == 'heatmap':
                batch_heatmaps, batch_locs, batch_scos, batch_past2now, batch_future2now, batch_FBcheck = net(
                    frames, Fflows, Bflows, is_images)
            else:
                batch_locs, batch_past2now, batch_future2now, batch_FBcheck = net(
                    frames, Fflows, Bflows, is_images)

        (batch_size, frame_length, C, H,
         W), num_pts, annotate_index = frames.size(
         ), args.num_pts, train_data.video_L
        batch_locs = batch_locs.cpu()[:, :, :num_pts]
        video_mask = masks.unsqueeze(0)[:, :num_pts]
        batch_past2now = batch_past2now.cpu()[:, :, :num_pts]
        batch_future2now = batch_future2now.cpu()[:, :, :num_pts]
        batch_FBcheck = batch_FBcheck[:, :num_pts].cpu()
        FB_check_oks = FB_communication(criterion, batch_locs, batch_past2now,
                                        batch_future2now, batch_FBcheck,
                                        video_mask, sbr_config)

        # locations
        norm_past_det_locs = torch.cat(
            (batch_locs[0, annotate_index - 1, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_noww_det_locs = torch.cat(
            (batch_locs[0, annotate_index, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_next_det_locs = torch.cat(
            (batch_locs[0, annotate_index + 1, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_next_locs = torch.cat(
            (batch_past2now[0, annotate_index, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_past_locs = torch.cat(
            (batch_future2now[0, annotate_index - 1, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        transtheta = transthetas[:2, :]
        norm_past_det_locs = torch.mm(transtheta, norm_past_det_locs)
        norm_noww_det_locs = torch.mm(transtheta, norm_noww_det_locs)
        norm_next_det_locs = torch.mm(transtheta, norm_next_det_locs)
        norm_next_locs = torch.mm(transtheta, norm_next_locs)
        norm_past_locs = torch.mm(transtheta, norm_past_locs)
        real_past_det_locs = denormalize_points(shapes.tolist(),
                                                norm_past_det_locs)
        real_noww_det_locs = denormalize_points(shapes.tolist(),
                                                norm_noww_det_locs)
        real_next_det_locs = denormalize_points(shapes.tolist(),
                                                norm_next_det_locs)
        real_next_locs = denormalize_points(shapes.tolist(), norm_next_locs)
        real_past_locs = denormalize_points(shapes.tolist(), norm_past_locs)
        gt_noww_points = train_data.labels[image_index.item()].get_points()
        gt_past_points = train_data.find_index(
            train_data.datas[image_index.item()][annotate_index - 1])
        gt_next_points = train_data.find_index(
            train_data.datas[image_index.item()][annotate_index + 1])

        FB_check_oks = FB_check_oks[:num_pts].squeeze()
        #import pdb; pdb.set_trace()
        if FB_check_oks.sum().item() > 2:
            # type 1 error : detection at both (t) and (t-1) is wrong, while pass the check
            is_type_1, (T_wrong, T_total) = check_is_1st_error(
                [real_past_det_locs, real_noww_det_locs, real_next_det_locs],
                [gt_past_points, gt_noww_points, gt_next_points], FB_check_oks,
                shapes)
            # type 2 error : detection at frame t is ok, while tracking are wrong and frame at (t-1) is wrong:
            spec_index, is_type_2 = check_is_2nd_error(
                real_noww_det_locs, gt_noww_points,
                [real_past_locs, real_next_locs],
                [gt_past_points, gt_next_points], FB_check_oks, shapes)
            type_error_1 += is_type_1
            type_error_2 += is_type_2
            type_error += is_type_1 or is_type_2
            type_error_pts, total_pts = type_error_pts + T_wrong, total_pts + T_total
            if is_type_2:
                RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255)
                [image_past, image_noww,
                 image_next] = train_data.datas[image_index.item()]
                crop_box = train_data.labels[
                    image_index.item()].get_box().tolist()
                point_index = FB_check_oks.nonzero().squeeze().tolist()
                colors = [
                    GREEN if _i in point_index else RED
                    for _i in range(num_pts)
                ] + [BLUE for _i in range(num_pts)]

                I_past_det = draw_image_by_points(
                    image_past,
                    torch.cat((real_past_det_locs, gt_past_points[:2]), dim=1),
                    3, colors, crop_box, (400, 500))
                I_noww_det = draw_image_by_points(
                    image_noww,
                    torch.cat((real_noww_det_locs, gt_noww_points[:2]), dim=1),
                    3, colors, crop_box, (400, 500))
                I_next_det = draw_image_by_points(
                    image_next,
                    torch.cat((real_next_det_locs, gt_next_points[:2]), dim=1),
                    3, colors, crop_box, (400, 500))
                I_past = draw_image_by_points(
                    image_past,
                    torch.cat((real_past_locs, gt_past_points[:2]), dim=1), 3,
                    colors, crop_box, (400, 500))
                I_next = draw_image_by_points(
                    image_next,
                    torch.cat((real_next_locs, gt_next_points[:2]), dim=1), 3,
                    colors, crop_box, (400, 500))
                ###
                I_past.save(str(save_xdir / '{:05d}-v1-a-pastt.png'.format(i)))
                I_noww_det.save(
                    str(save_xdir / '{:05d}-v1-b-curre.png'.format(i)))
                I_next.save(str(save_xdir / '{:05d}-v1-c-nextt.png'.format(i)))

                I_past_det.save(
                    str(save_xdir / '{:05d}-v1-det-a-past.png'.format(i)))
                I_noww_det.save(
                    str(save_xdir / '{:05d}-v1-det-b-curr.png'.format(i)))
                I_next_det.save(
                    str(save_xdir / '{:05d}-v1-det-c-next.png'.format(i)))

                logger.log('TYPE-ERROR : {:}, landmark-index : {:}'.format(
                    i, spec_index))
        else:
            misses += 1
        string = 'Handle {:05d}/{:05d} :: {:05d}'.format(
            iidx, len(selected_list), i)
        string += ', error-1 : {:} ({:.2f}%), error-2 : {:} ({:.2f}%)'.format(
            type_error_1, type_error_1 * 100.0 / (iidx + 1), type_error_2,
            type_error_2 * 100.0 / (iidx + 1))
        string += ', error : {:} ({:.2f}%), miss : {:}'.format(
            type_error, type_error * 100.0 / (iidx + 1), misses)
        string += ', final-error : {:05d} / {:05d} = {:.2f}%'.format(
            type_error_pts, total_pts, type_error_pts * 100.0 / total_pts)
        logger.log(string)
예제 #7
0
def main(args):
    assert torch.cuda.is_available(), 'CUDA is not available.'
    torch.backends.cudnn.enabled = True
    torch.backends.cudnn.benchmark = True
    torch.set_num_threads(args.workers)
    print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed))
    prepare_seed(args.rand_seed)
    temporal_main, eval_all = procedures['{:}-train'.format(
        args.procedure)], procedures['{:}-test'.format(args.procedure)]

    logger = prepare_logger(args)

    # General Data Argumentation
    normalize, train_transform, eval_transform, robust_transform = prepare_data_augmentation(
        transforms, args)
    recover = transforms.ToPILImage(normalize)
    args.tensor2imageF = recover
    assert (args.scale_min +
            args.scale_max) / 2 == 1, 'The scale is not ok : {:} ~ {:}'.format(
                args.scale_min, args.scale_max)

    # Model Configure Load
    model_config = load_configure(args.model_config, logger)
    sbr_config = load_configure(args.sbr_config, logger)
    shape = (args.height, args.width)
    logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format(
        model_config, args.sigma, shape))
    logger.log('--> SBR Configuration : {:}\n'.format(sbr_config))

    # Training Dataset
    train_data   = VDataset(eval_transform, args.sigma, model_config.downsample, args.heatmap_type, shape, args.use_gray, args.mean_point, \
                              args.data_indicator, sbr_config, transforms.ToPILImage(normalize, 'cv2gray'))
    train_data.load_list(args.train_lists, args.num_pts, args.boxindicator,
                         args.normalizeL, True)

    # Evaluation Dataloader
    assert len(
        args.eval_ilists) == 1, 'invalid length of eval_ilists : {:}'.format(
            len(eval_ilists))
    eval_data = IDataset(eval_transform, args.sigma, model_config.downsample,
                         args.heatmap_type, shape, args.use_gray,
                         args.mean_point, args.data_indicator)
    eval_data.load_list(args.eval_ilists[0], args.num_pts, args.boxindicator,
                        args.normalizeL, True)
    if args.x68to49:
        assert args.num_pts == 68, 'args.num_pts is not 68 vs. {:}'.format(
            args.num_pts)
        if train_data is not None: train_data = convert68to49(train_data)
        eval_data = convert68to49(eval_data)
        args.num_pts = 49

    # define the temporal model (accelerated SBR)
    net = obtain_pro_temporal(model_config, sbr_config, args.num_pts,
                              args.sigma, args.use_gray)
    assert model_config.downsample == net.downsample, 'downsample is not correct : {:} vs {:}'.format(
        model_config.downsample, net.downsample)
    logger.log("=> network :\n {}".format(net))

    logger.log('Training-data : {:}'.format(train_data))
    logger.log('Evaluate-data : {:}'.format(eval_data))

    logger.log('arguments : {:}'.format(args))
    opt_config = load_configure(args.opt_config, logger)

    optimizer, scheduler, criterion = obtain_optimizer(net.parameters(),
                                                       opt_config, logger)
    logger.log('criterion : {:}'.format(criterion))
    net, criterion = net.cuda(), criterion.cuda()
    net = torch.nn.DataParallel(net)

    last_info = logger.last_info()
    try:
        last_checkpoint = load_checkpoint(args.init_model)
        checkpoint = remove_module_dict(last_checkpoint['state_dict'], False)
        net.module.detector.load_state_dict(checkpoint)
    except:
        last_checkpoint = load_checkpoint(args.init_model)
        net.load_state_dict(last_checkpoint['state_dict'])

    detector = torch.nn.DataParallel(net.module.detector)
    logger.log("=> initialize the detector : {:}".format(args.init_model))

    net.eval()
    detector.eval()

    logger.log('SBR Config : {:}'.format(sbr_config))
    save_xdir = logger.path('meta')
    type_error = 0
    random.seed(111)
    index_list = list(range(len(train_data)))
    random.shuffle(index_list)
    #selected_list = index_list[: min(200, len(index_list))]

    selected_list = [
        7260, 11506, 39952, 75196, 51614, 41061, 37747, 41355, 47875
    ]
    for iidx, i in enumerate(selected_list):
        frames, Fflows, Bflows, targets, masks, normpoints, transthetas, meanthetas, image_index, nopoints, shapes, is_images = train_data[
            i]

        frames, Fflows, Bflows, is_images = frames.unsqueeze(
            0), Fflows.unsqueeze(0), Bflows.unsqueeze(0), is_images.unsqueeze(
                0)
        # batch_heatmaps is a list for stage-predictions, each element should be [Batch, Sequence, PTS, H/Down, W/Down]
        if args.procedure == 'heatmap':
            batch_heatmaps, batch_locs, batch_scos, batch_past2now, batch_future2now, batch_FBcheck = net(
                frames, Fflows, Bflows, is_images)
        else:
            batch_locs, batch_past2now, batch_future2now, batch_FBcheck = net(
                frames, Fflows, Bflows, is_images)

        (batch_size, frame_length, C, H,
         W), num_pts, annotate_index = frames.size(
         ), args.num_pts, train_data.video_L
        batch_locs = batch_locs.cpu()[:, :, :num_pts]
        video_mask = masks.unsqueeze(0)[:, :num_pts]
        batch_past2now = batch_past2now.cpu()[:, :, :num_pts]
        batch_future2now = batch_future2now.cpu()[:, :, :num_pts]
        batch_FBcheck = batch_FBcheck[:, :num_pts].cpu()
        FB_check_oks = FB_communication(criterion, batch_locs, batch_past2now,
                                        batch_future2now, batch_FBcheck,
                                        video_mask, sbr_config)

        # locations
        norm_past_det_locs = torch.cat(
            (batch_locs[0, annotate_index - 1, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_noww_det_locs = torch.cat(
            (batch_locs[0, annotate_index, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_next_det_locs = torch.cat(
            (batch_locs[0, annotate_index + 1, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_next_locs = torch.cat(
            (batch_past2now[0, annotate_index, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        norm_past_locs = torch.cat(
            (batch_future2now[0, annotate_index - 1, :num_pts].permute(
                1, 0), torch.ones(1, num_pts)),
            dim=0)
        transtheta = transthetas[:2, :]
        norm_past_det_locs = torch.mm(transtheta, norm_past_det_locs)
        norm_noww_det_locs = torch.mm(transtheta, norm_noww_det_locs)
        norm_next_det_locs = torch.mm(transtheta, norm_next_det_locs)
        norm_next_locs = torch.mm(transtheta, norm_next_locs)
        norm_past_locs = torch.mm(transtheta, norm_past_locs)
        real_past_det_locs = denormalize_points(shapes.tolist(),
                                                norm_past_det_locs)
        real_noww_det_locs = denormalize_points(shapes.tolist(),
                                                norm_noww_det_locs)
        real_next_det_locs = denormalize_points(shapes.tolist(),
                                                norm_next_det_locs)
        real_next_locs = denormalize_points(shapes.tolist(), norm_next_locs)
        real_past_locs = denormalize_points(shapes.tolist(), norm_past_locs)
        gt_noww_points = train_data.labels[image_index.item()].get_points()

        FB_check_oks = FB_check_oks[:num_pts].squeeze()
        #import pdb; pdb.set_trace()
        if FB_check_oks.sum().item() > 2:
            point_index = FB_check_oks.nonzero().squeeze().tolist()
            something_wrong = False
            for pidx in point_index:
                real_now_det_loc = real_noww_det_locs[:, pidx]
                real_pst_det_loc = real_past_det_locs[:, pidx]
                real_net_det_loc = real_next_det_locs[:, pidx]
                real_nex_loc = real_next_locs[:, pidx]
                real_pst_loc = real_next_locs[:, pidx]
                grdt_now_loc = gt_noww_points[:2, pidx]
                #if torch.abs(real_now_loc - grdt_now_loc).max() > 5:
                #  something_wrong = True
                #if torch.abs(real_nex_loc - grdt_nex_loc).max() > 5:
                #  something_wrong = True
            #if something_wrong == True:
            if True:
                [image_past, image_noww,
                 image_next] = train_data.datas[image_index.item()]
                try:
                    crop_box = train_data.labels[
                        image_index.item()].get_box().tolist()
                    #crop_box = [crop_box[0]-20, crop_box[1]-20, crop_box[2]+20, crop_box[3]+20]
                except:
                    crop_box = False

                RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255)
                colors = [
                    GREEN if _i in point_index else RED
                    for _i in range(num_pts)
                ]
                if crop_box != False or True:
                    I_past_det = draw_image_by_points(image_past,
                                                      real_past_det_locs[:], 3,
                                                      colors, crop_box,
                                                      (400, 500))
                    I_noww_det = draw_image_by_points(image_noww,
                                                      real_noww_det_locs[:], 3,
                                                      colors, crop_box,
                                                      (400, 500))
                    I_next_det = draw_image_by_points(image_next,
                                                      real_next_det_locs[:], 3,
                                                      colors, crop_box,
                                                      (400, 500))
                    I_next = draw_image_by_points(image_next,
                                                  real_next_locs[:], 3, colors,
                                                  crop_box, (400, 500))
                    I_past = draw_image_by_points(image_past,
                                                  real_past_locs[:], 3, colors,
                                                  crop_box, (400, 500))

                    I_past.save(
                        str(save_xdir / '{:05d}-v1-a-pastt.png'.format(i)))
                    I_noww_det.save(
                        str(save_xdir / '{:05d}-v1-b-curre.png'.format(i)))
                    I_next.save(
                        str(save_xdir / '{:05d}-v1-c-nextt.png'.format(i)))

                    I_past_det.save(
                        str(save_xdir / '{:05d}-v1-det-a-past.png'.format(i)))
                    I_noww_det.save(
                        str(save_xdir / '{:05d}-v1-det-b-curr.png'.format(i)))
                    I_next_det.save(
                        str(save_xdir / '{:05d}-v1-det-c-next.png'.format(i)))

                #[image_past, image_noww, image_next] = train_data.datas[image_index.item()]
                #image_noww = draw_image_by_points(image_noww, real_noww_locs[:], 2, colors, False, False)
                #image_next = draw_image_by_points(image_next, real_next_locs[:], 2, colors, False, False)
                #image_past = draw_image_by_points(image_past, real_past_locs[:], 2, colors, False, False)
                #image_noww.save( str(save_xdir / '{:05d}-v2-b-curre.png'.format(i)) )
                #image_next.save( str(save_xdir / '{:05d}-v2-c-nextt.png'.format(i)) )
                #image_past.save( str(save_xdir / '{:05d}-v2-a-pastt.png'.format(i)) )
                #type_error += 1
        logger.log(
            'Handle {:05d}/{:05d} :: {:05d}, ok-points={:.3f}, wrong data={:}'.
            format(iidx, len(selected_list), i,
                   FB_check_oks.float().mean().item(), type_error))

    save_xx_dir = save_xdir.parent / 'image-data'
    save_xx_dir.mkdir(parents=True, exist_ok=True)
    selected_list = [100, 115, 200, 300, 400] + list(range(200, 220))
    for iidx, i in enumerate(selected_list):
        inputs, targets, masks, normpoints, transthetas, meanthetas, image_index, nopoints, shapes = eval_data[
            i]
        inputs = inputs.unsqueeze(0)
        (batch_size, C, H, W), num_pts = inputs.size(), args.num_pts
        _, _, batch_locs, batch_scos = detector(inputs)  # inputs

        batch_locs, batch_scos = batch_locs.cpu(), batch_scos.cpu()
        norm_locs = normalize_points((H, W),
                                     batch_locs[0, :num_pts].transpose(1, 0))
        norm_det_locs = torch.cat((norm_locs, torch.ones(1, num_pts)), dim=0)
        norm_det_locs = torch.mm(transthetas[:2, :], norm_det_locs)
        real_det_locs = denormalize_points(shapes.tolist(), norm_det_locs)
        gt_now_points = eval_data.labels[image_index.item()].get_points()
        image_now = eval_data.datas[image_index.item()]
        crop_box = eval_data.labels[image_index.item()].get_box().tolist()

        RED, GREEN, BLUE = (255, 0, 0), (0, 255, 0), (0, 0, 255)
        Gcolors = [GREEN for _ in range(num_pts)]
        points = torch.cat((real_det_locs, gt_now_points[:2]), dim=1)
        colors = [GREEN
                  for _ in range(num_pts)] + [BLUE for _ in range(num_pts)]
        image = draw_image_by_points(image_now, real_det_locs, 3, Gcolors,
                                     crop_box, (400, 500))
        image.save(str(save_xx_dir / '{:05d}-crop.png'.format(i)))
        image = draw_image_by_points(image_now, points, 3, colors, False,
                                     False)
        #image  = draw_image_by_points(image_now, real_det_locs, 3, colors , False, False)
        image.save(str(save_xx_dir / '{:05d}-orig.png'.format(i)))
    logger.log('Finish drawing : {:}'.format(save_xdir))
    logger.log('Finish drawing : {:}'.format(save_xx_dir))
    logger.close()
예제 #8
0
def main(args):
    assert torch.cuda.is_available(), 'CUDA is not available.'
    torch.backends.cudnn.enabled = True
    torch.backends.cudnn.benchmark = True
    torch.set_num_threads(args.workers)
    print('Training Base Detector : prepare_seed : {:}'.format(args.rand_seed))
    prepare_seed(args.rand_seed)

    logger = prepare_logger(args)

    checkpoint = load_checkpoint(args.init_model)
    xargs = checkpoint['args']
    logger.log('Previous args : {:}'.format(xargs))

    # General Data Augmentation
    if xargs.use_gray == False:
        mean_fill = tuple([int(x * 255) for x in [0.485, 0.456, 0.406]])
        normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
                                         std=[0.229, 0.224, 0.225])
    else:
        mean_fill = (0.5, )
        normalize = transforms.Normalize(mean=[mean_fill[0]], std=[0.5])
    eval_transform  = transforms.Compose2V([transforms.ToTensor(), normalize, \
                                                transforms.PreCrop(xargs.pre_crop_expand), \
                                                transforms.CenterCrop(xargs.crop_max)])

    # Model Configure Load
    model_config = load_configure(xargs.model_config, logger)
    shape = (xargs.height, xargs.width)
    logger.log('--> {:}\n--> Sigma : {:}, Shape : {:}'.format(
        model_config, xargs.sigma, shape))

    # Evaluation Dataloader
    eval_loaders = []
    if args.eval_ilists is not None:
        for eval_ilist in args.eval_ilists:
            eval_idata = EvalDataset(eval_transform, xargs.sigma,
                                     model_config.downsample,
                                     xargs.heatmap_type, shape, xargs.use_gray,
                                     xargs.data_indicator)
            eval_idata.load_list(eval_ilist, args.num_pts, xargs.boxindicator,
                                 xargs.normalizeL, True)
            eval_iloader = torch.utils.data.DataLoader(
                eval_idata,
                batch_size=args.batch_size,
                shuffle=False,
                num_workers=args.workers,
                pin_memory=True)
            eval_loaders.append((eval_iloader, False))
    if args.eval_vlists is not None:
        for eval_vlist in args.eval_vlists:
            eval_vdata = EvalDataset(eval_transform, xargs.sigma,
                                     model_config.downsample,
                                     xargs.heatmap_type, shape, xargs.use_gray,
                                     xargs.data_indicator)
            eval_vdata.load_list(eval_vlist, args.num_pts, xargs.boxindicator,
                                 xargs.normalizeL, True)
            eval_vloader = torch.utils.data.DataLoader(
                eval_vdata,
                batch_size=args.batch_size,
                shuffle=False,
                num_workers=args.workers,
                pin_memory=True)
            eval_loaders.append((eval_vloader, True))

    # define the detector
    detector = obtain_pro_model(model_config, xargs.num_pts, xargs.sigma,
                                xargs.use_gray)
    assert model_config.downsample == detector.downsample, 'downsample is not correct : {:} vs {:}'.format(
        model_config.downsample, detector.downsample)
    logger.log("=> detector :\n {:}".format(detector))
    logger.log("=> Net-Parameters : {:} MB".format(
        count_parameters_in_MB(detector)))
    logger.log('=> Eval-Transform : {:}'.format(eval_transform))

    detector = detector.cuda()
    net = torch.nn.DataParallel(detector)
    net.eval()
    net.load_state_dict(checkpoint['detector'])
    cpu = torch.device('cpu')

    assert len(args.use_stable) == 2

    for iLOADER, (loader, is_video) in enumerate(eval_loaders):
        logger.log(
            '{:} The [{:2d}/{:2d}]-th test set [{:}] = {:} with {:} batches.'.
            format(time_string(), iLOADER, len(eval_loaders),
                   'video' if is_video else 'image', loader.dataset,
                   len(loader)))
        with torch.no_grad():
            all_points, all_results, all_image_ps = [], [], []
            for i, (inputs, targets, masks, normpoints, transthetas,
                    image_index, nopoints, shapes) in enumerate(loader):
                image_index = image_index.squeeze(1).tolist()
                (batch_size, C, H, W), num_pts = inputs.size(), xargs.num_pts
                # batch_heatmaps is a list for stage-predictions, each element should be [Batch, C, H, W]
                if xargs.procedure == 'heatmap':
                    batch_features, batch_heatmaps, batch_locs, batch_scos = net(
                        inputs)
                    batch_locs = batch_locs[:, :-1, :]
                else:
                    batch_locs = net(inputs)
                batch_locs = batch_locs.detach().to(cpu)
                # evaluate the training data
                for ibatch, (imgidx,
                             nopoint) in enumerate(zip(image_index, nopoints)):
                    if xargs.procedure == 'heatmap':
                        norm_locs = normalize_points(
                            (H, W), batch_locs[ibatch].transpose(1, 0))
                        norm_locs = torch.cat(
                            (norm_locs, torch.ones(1, num_pts)), dim=0)
                    else:
                        norm_locs = torch.cat((batch_locs[ibatch].permute(
                            1, 0), torch.ones(1, num_pts)),
                                              dim=0)
                    transtheta = transthetas[ibatch][:2, :]
                    norm_locs = torch.mm(transtheta, norm_locs)
                    real_locs = denormalize_points(shapes[ibatch].tolist(),
                                                   norm_locs)
                    #real_locs  = torch.cat((real_locs, batch_scos[ibatch].permute(1,0)), dim=0)
                    real_locs = torch.cat((real_locs, torch.ones(1, num_pts)),
                                          dim=0)
                    xpoints = loader.dataset.labels[imgidx].get_points().numpy(
                    )
                    image_path = loader.dataset.datas[imgidx]
                    # put into the list
                    all_points.append(torch.from_numpy(xpoints))
                    all_results.append(real_locs)
                    all_image_ps.append(image_path)
            total = len(all_points)
            logger.log(
                '{:} The [{:2d}/{:2d}]-th test set finishes evaluation : {:} frames/images'
                .format(time_string(), iLOADER, len(eval_loaders), total))
        """
    if args.use_stable[0] > 0:
      save_dir = Path( osp.join(args.save_path, '{:}-X-{:03d}'.format(args.model_name, iLOADER)) )
      save_dir.mkdir(parents=True, exist_ok=True)
      wrap_parallel = WrapParallel(save_dir, all_image_ps, all_results, all_points, 180, (255, 0, 0))
      wrap_loader   = torch.utils.data.DataLoader(wrap_parallel, batch_size=args.workers, shuffle=False, num_workers=args.workers, pin_memory=True)
      for iL, INDEXES in enumerate(wrap_loader): _ = INDEXES
      cmd = 'ffmpeg -y -i {:}/%06d.png -framerate 30 {:}.avi'.format(save_dir, save_dir)
      logger.log('{:} possible >>>>> : {:}'.format(time_string(), cmd))
      os.system( cmd )

    if args.use_stable[1] > 0:
      save_dir = Path( osp.join(args.save_path, '{:}-Y-{:03d}'.format(args.model_name, iLOADER)) )
      save_dir.mkdir(parents=True, exist_ok=True)
      Xpredictions, Xgts = torch.stack(all_results), torch.stack(all_points)
      new_preds = fc_solve(Xgts, Xpredictions, is_cuda=True)
      wrap_parallel = WrapParallel(save_dir, all_image_ps, new_preds, all_points, 180, (0, 0, 255))
      wrap_loader   = torch.utils.data.DataLoader(wrap_parallel, batch_size=args.workers, shuffle=False, num_workers=args.workers, pin_memory=True)
      for iL, INDEXES in enumerate(wrap_loader): _ = INDEXES
      cmd = 'ffmpeg -y -i {:}/%06d.png -framerate 30 {:}.avi'.format(save_dir, save_dir)
      logger.log('{:} possible >>>>> : {:}'.format(time_string(), cmd))
      os.system( cmd )
    """
        Xpredictions, Xgts = torch.stack(all_results), torch.stack(all_points)
        save_path = Path(
            osp.join(args.save_path,
                     '{:}-result-{:03d}.pth'.format(args.model_name, iLOADER)))
        torch.save(
            {
                'paths': all_image_ps,
                'ground-truths': Xgts,
                'predictions': all_results
            }, save_path)
        logger.log('{:} save into {:}'.format(time_string(), save_path))
        if False:
            new_preds = fc_solve_v2(Xgts, Xpredictions, is_cuda=True)
            # create the dir
            save_dir = Path(
                osp.join(args.save_path,
                         '{:}-T-{:03d}'.format(args.model_name, iLOADER)))
            save_dir.mkdir(parents=True, exist_ok=True)
            wrap_parallel = WrapParallelV2(save_dir, all_image_ps, Xgts,
                                           all_results, new_preds, all_points,
                                           180, [args.model_name, 'SRT'])
            wrap_parallel[0]
            wrap_loader = torch.utils.data.DataLoader(wrap_parallel,
                                                      batch_size=args.workers,
                                                      shuffle=False,
                                                      num_workers=args.workers,
                                                      pin_memory=True)
            for iL, INDEXES in enumerate(wrap_loader):
                _ = INDEXES
            cmd = 'ffmpeg -y -i {:}/%06d.png -vb 5000k {:}.avi'.format(
                save_dir, save_dir)
            logger.log('{:} possible >>>>> : {:}'.format(time_string(), cmd))
            os.system(cmd)

    logger.close()
    return