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']
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'
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,
)
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]
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")
