name = 1 modelPath = 'ourModel/best_checkpoint_adam.pth.tar' if name == 1 else 'trained_models/ncnet_pfpascal.pth.tar' parser.add_argument( '--checkpoint', type=str, default=modelPath) # 'ourModel/250205LOSSbest_checkpoint_adam.pth.tar') # parser.add_argument('--image_size', type=int, default=250) # 400s parser.add_argument('--eval_dataset_path', type=str, default='datasets/pf-pascal/', help='path to PF Pascal dataset') args = parser.parse_args() # Create model print('Creating CNN model...') model = ImMatchNet(use_cuda=use_cuda, checkpoint=args.checkpoint) # Dataset and dataloader Dataset = PFPascalDataset collate_fn = default_collate csv_file = 'image_pairs/test_pairs.csv' if pfPascal else 'image_pairs/pw_test.csv' # csv_file = 'image_pairs/pw_test.csv' cnn_image_size = (args.image_size, args.image_size) dataset = Dataset(csv_file=os.path.join(args.eval_dataset_path, csv_file), dataset_path=args.eval_dataset_path, transform=NormalizeImageDict( ['source_image', 'target_image']), output_size=cnn_image_size) dataset.pck_procedure = 'scnet'
args = parser.parse_args() image_size = args.image_size k_size = args.k_size matching_both_directions = args.matching_both_directions flip_matching_direction = args.flip_matching_direction # Load pretrained model half_precision = True # use for memory saving print(args) model = ImMatchNet(use_cuda=use_cuda, checkpoint=args.checkpoint, half_precision=half_precision, feature_extraction_cnn=args.feature_extraction_cnn, relocalization_k_size=args.k_size, symmetric_mode=args.symmetric_mode) if args.change_stride: scale_factor = 0.0625 # import pdb;pdb.set_trace() model.FeatureExtraction.model[-1][0].conv1.stride = (1, 1) model.FeatureExtraction.model[-1][0].conv2.stride = (1, 1) model.FeatureExtraction.model[-1][0].downsample[0].stride = (1, 1) else: scale_factor = 0.0625 / 2 imreadth = lambda x: torch.Tensor(imread(x).astype(np.float32)).transpose( 1, 2).transpose(0, 1) normalize = lambda x: NormalizeImageDict(['im'])({'im': x})['im']
help='path to InLoc queries') args = parser.parse_args() image_size = args.image_size k_size = args.k_size matching_both_directions = args.matching_both_directions flip_matching_direction = args.flip_matching_direction # Load pretrained model half_precision = True # use for memory saving print(args) model = ImMatchNet(use_cuda=use_cuda, checkpoint=args.checkpoint, half_precision=half_precision, relocalization_k_size=args.k_size) # Generate output folder path output_folder = args.inloc_shortlist.split('/')[-1].split( '.')[0] + '_SZ_NEW_' + str(image_size) + '_K_' + str(k_size) if matching_both_directions: output_folder += '_BOTHDIRS' elif flip_matching_direction: output_folder += '_AtoB' else: output_folder += '_BtoA' if args.softmax == True: output_folder += '_SOFTMAX' if args.checkpoint != '': checkpoint_name = args.checkpoint.split('/')[-1].split('.')[0]
def main(): print("NCNet evaluation script - PF Pascal dataset") use_cuda = torch.cuda.is_available() # Argument parsing parser = argparse.ArgumentParser(description="Compute PF Pascal matches") parser.add_argument("--checkpoint", type=str, default="models/ancnet_86_11.pth.tar") parser.add_argument( "--vis", type=int, default=0, help= "visilisation options: 0 calculate pck; 1 visualise keypoint matches and heat maps; 2 display matched key points", ) parser.add_argument("--a", type=float, default=0.1, help="a is the pck@alpha value") parser.add_argument("--num_examples", type=int, default=5, help="the number of matching examples") args = parser.parse_args() vis = args.vis alpha = args.a num_examples = args.num_examples if args.checkpoint is not None and args.checkpoint is not "": print("Loading checkpoint...") checkpoint = torch.load(args.checkpoint, map_location=lambda storage, loc: storage) checkpoint["state_dict"] = OrderedDict([ (k.replace("vgg", "model"), v) for k, v in checkpoint["state_dict"].items() ]) args = checkpoint["args"] else: print("checkpoint needed.") exit() cnn_image_size = (args.image_size, args.image_size) # Create model print("Creating CNN model...") model = ImMatchNet( use_cuda=use_cuda, feature_extraction_cnn=args.backbone, checkpoint=checkpoint, ncons_kernel_sizes=args.ncons_kernel_sizes, ncons_channels=args.ncons_channels, pss=args.pss, noniso=args.noniso, ) model.eval() print("args.dataset_image_path", args.dataset_image_path) # Dataset and dataloader collate_fn = default_collate csv_file = "image_pairs/test_pairs.csv" dataset = PFPascalDataset( csv_file=os.path.join(args.dataset_image_path, csv_file), dataset_path=args.dataset_image_path, transform=NormalizeImageDict(["source_image", "target_image"]), output_size=cnn_image_size, ) dataset.pck_procedure = "scnet" # Only batch_size=1 is supported for evaluation batch_size = 1 dataloader = DataLoader( dataset, batch_size=batch_size, shuffle=False, num_workers=0, collate_fn=collate_fn, ) batch_tnf = BatchTensorToVars(use_cuda=use_cuda) # initialize vector for storing results stats = {} stats["point_tnf"] = {} stats["point_tnf"]["pck"] = np.zeros((len(dataset), 1)) # Compute pck accuracy total = len(dataloader) progress = tqdm(dataloader, total=total) for i, batch in enumerate(progress): batch = batch_tnf(batch) batch_start_idx = batch_size * i corr4d = model(batch) # get matches # note invert_matching_direction doesnt work at all xA, yA, xB, yB, sB = corr_to_matches(corr4d, do_softmax=True, invert_matching_direction=False) matches = (xA, yA, xB, yB) stats = pck_metric(batch, batch_start_idx, matches, stats, alpha=alpha, use_cuda=use_cuda) # Print results results = stats["point_tnf"]["pck"] good_idx = np.flatnonzero((results != -1) * ~np.isnan(results)) print("Total: " + str(results.size)) print("Valid: " + str(good_idx.size)) filtered_results = results[good_idx] print("PCK:", "{:.2%}".format(np.mean(filtered_results))) test_csv = "test_pairs.csv" dataset_val = pf.ImagePairDataset( transform=NormalizeImageDict(["source_image", "target_image"]), dataset_image_path=args.dataset_image_path, dataset_csv_path=os.path.join(args.dataset_image_path, "image_pairs"), dataset_csv_file=test_csv, output_size=cnn_image_size, keypoints_on=True, original=True, test=True, ) loader_test = DataLoader(dataset_val, batch_size=1, shuffle=True, num_workers=4) batch_tnf = BatchTensorToVars(use_cuda=use_cuda) print("visualise correlation") tools.visualise_feature(model, loader_test, batch_tnf, image_size=cnn_image_size, MAX=num_examples) print("visualise pair") tools.validate( model, loader_test, batch_tnf, None, image_scale=args.image_size, im_fe_ratio=16, image_size=cnn_image_size, MAX=num_examples, display=True, )
type=str, default='resnet101', help='type of feature extractor') parser.add_argument('--relocalize', type=int, default=0) parser.add_argument('--change_stride', type=int, default=0) args = parser.parse_args() print(args) # Create model print('Creating CNN model...') model = ImMatchNet(use_cuda=use_cuda, checkpoint=args.checkpoint, ncons_kernel_sizes=args.ncons_kernel_sizes, ncons_channels=args.ncons_channels, sparse=True, symmetric_mode=bool(args.symmetric_mode), feature_extraction_cnn=args.feature_extraction_cnn, bn=bool(args.bn), k=args.k) if args.change_stride: model.FeatureExtraction.model[-1][0].conv1.stride = (1, 1) model.FeatureExtraction.model[-1][0].conv2.stride = (1, 1) model.FeatureExtraction.model[-1][0].downsample[0].stride = (1, 1) def eval_model_fn(batch): # feature extraction if args.relocalize: feature_A_2x = model.FeatureExtraction(batch['source_image'])
default="trained_models", help="path to trained models folder", ) parser.add_argument("--fe_finetune_params", type=int, default=0, help="number of layers to finetune") args = parser.parse_args() print(args) # Create model print("Creating CNN model...") model = ImMatchNet( use_cuda=use_cuda, checkpoint=args.checkpoint, ncons_kernel_sizes=args.ncons_kernel_sizes, ncons_channels=args.ncons_channels, ) # Set which parts of the model to train if args.fe_finetune_params > 0: for i in range(args.fe_finetune_params): for p in model.FeatureExtraction.model[-1][-(i + 1)].parameters(): p.requires_grad = True print("Trainable parameters:") for i, p in enumerate(filter(lambda p: p.requires_grad, model.parameters())): print(str(i + 1) + ": " + str(p.shape)) # Optimizer print("using Adam optimizer")
from lib.model import ImMatchNet, MutualMatching from lib.normalization import NormalizeImageDict from lib.torch_util import save_checkpoint, str_to_bool import xlrd, xlwt from lib.point_tnf import corr_to_matches from lib.eval_util import * from lib.point_tnf import normalize_axis, unnormalize_axis, bilinearInterpPointTnf from lib.plot import plot_image from warp import * # CUDA use_cuda = torch.cuda.is_available() ###################################Load pretrained model################################### name = 1 checkpoint = 'ourModel/250205LOSSbest_checkpoint_adam.pth.tar' if name == 1 else 'trained_models/ncnet_pfpascal.pth.tar' model = ImMatchNet(use_cuda=use_cuda, checkpoint=checkpoint) # print(model) # show the net structure model.FeatureExtraction.eval() for param in model.NeighConsensus.parameters(): param.requires_grad = False print('Done') ##############################################Dataset######################################### from lib.pf_dataset import PFPascalDataset Dataset = PFPascalDataset eval_dataset_path = 'datasets/pf-pascal/' csv_file = 'image_pairs/test_pairs.csv' xlsx_file = eval_dataset_path + 'image_pairs/test_pairs.xlsx' image_size = 250 # 400 feature_size = int(image_size * 0.0625)
parser.add_argument('--change_stride', type=int, default=1) parser.add_argument('--benchmark', type=int, default=0) parser.add_argument('--no_ncnet', type=int, default=0) parser.add_argument('--Npts', type=int, default=8000) parser.add_argument('--image_pairs', type=str, default='all') args = parser.parse_args() print(args) chp_args = torch.load(args.checkpoint)['args'] model = ImMatchNet(use_cuda=use_cuda, checkpoint=args.checkpoint, ncons_kernel_sizes=chp_args.ncons_kernel_sizes, ncons_channels=chp_args.ncons_channels, sparse=True, symmetric_mode=bool(chp_args.symmetric_mode), feature_extraction_cnn=chp_args.feature_extraction_cnn, bn=bool(chp_args.bn), k=chp_args.k, return_fs=True) scale_factor = 0.0625 if args.relocalize == 1: scale_factor = scale_factor / 2 if args.change_stride == 1: scale_factor = scale_factor * 2 elif args.change_stride == 2: scale_factor = scale_factor * 4 if args.change_stride >= 1: model.FeatureExtraction.model[-1][0].conv1.stride = (1, 1)
parser.add_argument('--result-model-dir', type=str, default='ourModel', help='path to trained models folder') parser.add_argument('--fe_finetune_params', type=int, default=0, help='number of layers to finetune') args = parser.parse_args() print(args) # Create model print('Creating CNN model...') model = ImMatchNet(use_cuda=use_cuda, checkpoint=args.checkpoint, ncons_kernel_sizes=args.ncons_kernel_sizes, ncons_channels=args.ncons_channels) # Set which parts of the model to train if args.fe_finetune_params > 0: for i in range(args.fe_finetune_params): for p in model.FeatureExtraction.model[-1][-(i + 1)].parameters(): p.requires_grad = True print('Trainable parameters:') for i, p in enumerate(filter(lambda p: p.requires_grad, model.parameters())): print(str(i + 1) + ": " + str(p.shape)) # Optimizer print('using Adam optimizer')