vismatch 1.1.1__py3-none-any.whl

vismatch/third_party/Se2_LoFTR/src/utils/misc.py

@@ -0,0 +1,104 @@
+import os
+import contextlib
+import joblib
+from typing import Union
+from loguru import _Logger, logger
+from itertools import chain
+
+import torch
+from yacs.config import CfgNode as CN
+try:
+    from pytorch_lightning.utilities import rank_zero_only
+except ModuleNotFoundError:
+    print('WARNING: No pytorch lightning installed. This is ok for interence. Please install pytorch lightning if you want to train.')
+
+
+def lower_config(yacs_cfg):
+    if not isinstance(yacs_cfg, CN):
+        return yacs_cfg
+    return {k.lower(): lower_config(v) for k, v in yacs_cfg.items()}
+
+
+def upper_config(dict_cfg):
+    if not isinstance(dict_cfg, dict):
+        return dict_cfg
+    return {k.upper(): upper_config(v) for k, v in dict_cfg.items()}
+
+
+def log_on(condition, message, level):
+    if condition:
+        assert level in ['INFO', 'DEBUG', 'WARNING', 'ERROR', 'CRITICAL']
+        logger.log(level, message)
+
+
+def get_rank_zero_only_logger(logger: _Logger):
+    if rank_zero_only.rank == 0:
+        return logger
+    else:
+        for _level in logger._core.levels.keys():
+            level = _level.lower()
+            setattr(logger, level,
+                    lambda x: None)
+        logger._log = lambda x: None
+    return logger
+
+
+def setup_gpus(gpus: Union[str, int]) -> int:
+    """ A temporary fix for pytorch-lighting 1.3.x """
+    gpus = str(gpus)
+    gpu_ids = []
+    
+    if ',' not in gpus:
+        n_gpus = int(gpus)
+        return n_gpus if n_gpus != -1 else torch.cuda.device_count()
+    else:
+        gpu_ids = [i.strip() for i in gpus.split(',') if i != '']
+    
+    # setup environment variables
+    visible_devices = os.getenv('CUDA_VISIBLE_DEVICES')
+    if visible_devices is None:
+        os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+        os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(str(i) for i in gpu_ids)
+        visible_devices = os.getenv('CUDA_VISIBLE_DEVICES')
+        logger.warning(f'[Temporary Fix] manually set CUDA_VISIBLE_DEVICES when specifying gpus to use: {visible_devices}')
+    else:
+        logger.warning('[Temporary Fix] CUDA_VISIBLE_DEVICES already set by user or the main process.')
+    return len(gpu_ids)
+
+
+def flattenList(x):
+    return list(chain(*x))
+
+
+@contextlib.contextmanager
+def tqdm_joblib(tqdm_object):
+    """Context manager to patch joblib to report into tqdm progress bar given as argument
+    
+    Usage:
+        with tqdm_joblib(tqdm(desc="My calculation", total=10)) as progress_bar:
+            Parallel(n_jobs=16)(delayed(sqrt)(i**2) for i in range(10))
+            
+    When iterating over a generator, directly use of tqdm is also a solutin (but monitor the task queuing, instead of finishing)
+        ret_vals = Parallel(n_jobs=args.world_size)(
+                    delayed(lambda x: _compute_cov_score(pid, *x))(param)
+                        for param in tqdm(combinations(image_ids, 2),
+                                          desc=f'Computing cov_score of [{pid}]',
+                                          total=len(image_ids)*(len(image_ids)-1)/2))
+    Src: https://stackoverflow.com/a/58936697
+    """
+    class TqdmBatchCompletionCallback(joblib.parallel.BatchCompletionCallBack):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+
+        def __call__(self, *args, **kwargs):
+            tqdm_object.update(n=self.batch_size)
+            return super().__call__(*args, **kwargs)
+
+    old_batch_callback = joblib.parallel.BatchCompletionCallBack
+    joblib.parallel.BatchCompletionCallBack = TqdmBatchCompletionCallback
+    try:
+        yield tqdm_object
+    finally:
+        joblib.parallel.BatchCompletionCallBack = old_batch_callback
+        tqdm_object.close()
+

vismatch/third_party/Se2_LoFTR/src/utils/plotting.py

@@ -0,0 +1,154 @@
+import bisect
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib
+
+
+def _compute_conf_thresh(data):
+    dataset_name = data['dataset_name'][0].lower()
+    if dataset_name == 'scannet':
+        thr = 5e-4
+    elif dataset_name == 'megadepth':
+        thr = 1e-4
+    else:
+        raise ValueError(f'Unknown dataset: {dataset_name}')
+    return thr
+
+
+# --- VISUALIZATION --- #
+
+def make_matching_figure(
+        img0, img1, mkpts0, mkpts1, color,
+        kpts0=None, kpts1=None, text=[], dpi=75, path=None):
+    # draw image pair
+    assert mkpts0.shape[0] == mkpts1.shape[0], f'mkpts0: {mkpts0.shape[0]} v.s. mkpts1: {mkpts1.shape[0]}'
+    fig, axes = plt.subplots(1, 2, figsize=(10, 6), dpi=dpi)
+    axes[0].imshow(img0, cmap='gray')
+    axes[1].imshow(img1, cmap='gray')
+    for i in range(2):   # clear all frames
+        axes[i].get_yaxis().set_ticks([])
+        axes[i].get_xaxis().set_ticks([])
+        for spine in axes[i].spines.values():
+            spine.set_visible(False)
+    plt.tight_layout(pad=1)
+    
+    if kpts0 is not None:
+        assert kpts1 is not None
+        axes[0].scatter(kpts0[:, 0], kpts0[:, 1], c='w', s=2)
+        axes[1].scatter(kpts1[:, 0], kpts1[:, 1], c='w', s=2)
+
+    # draw matches
+    if mkpts0.shape[0] != 0 and mkpts1.shape[0] != 0:
+        fig.canvas.draw()
+        transFigure = fig.transFigure.inverted()
+        fkpts0 = transFigure.transform(axes[0].transData.transform(mkpts0))
+        fkpts1 = transFigure.transform(axes[1].transData.transform(mkpts1))
+        fig.lines = [matplotlib.lines.Line2D((fkpts0[i, 0], fkpts1[i, 0]),
+                                            (fkpts0[i, 1], fkpts1[i, 1]),
+                                            transform=fig.transFigure, c=color[i], linewidth=1)
+                                        for i in range(len(mkpts0))]
+        
+        axes[0].scatter(mkpts0[:, 0], mkpts0[:, 1], c=color, s=4)
+        axes[1].scatter(mkpts1[:, 0], mkpts1[:, 1], c=color, s=4)
+
+    # put txts
+    txt_color = 'k' if img0[:100, :200].mean() > 200 else 'w'
+    fig.text(
+        0.01, 0.99, '\n'.join(text), transform=fig.axes[0].transAxes,
+        fontsize=15, va='top', ha='left', color=txt_color)
+
+    # save or return figure
+    if path:
+        plt.savefig(str(path), bbox_inches='tight', pad_inches=0)
+        plt.close()
+    else:
+        return fig
+
+
+def _make_evaluation_figure(data, b_id, alpha='dynamic'):
+    b_mask = data['m_bids'] == b_id
+    conf_thr = _compute_conf_thresh(data)
+    
+    img0 = (data['image0'][b_id][0].cpu().numpy() * 255).round().astype(np.int32)
+    img1 = (data['image1'][b_id][0].cpu().numpy() * 255).round().astype(np.int32)
+    kpts0 = data['mkpts0_f'][b_mask].cpu().numpy()
+    kpts1 = data['mkpts1_f'][b_mask].cpu().numpy()
+    
+    # for megadepth, we visualize matches on the resized image
+    if 'scale0' in data:
+        kpts0 = kpts0 / data['scale0'][b_id].cpu().numpy()[[1, 0]]
+        kpts1 = kpts1 / data['scale1'][b_id].cpu().numpy()[[1, 0]]
+
+    epi_errs = data['epi_errs'][b_mask].cpu().numpy()
+    correct_mask = epi_errs < conf_thr
+    precision = np.mean(correct_mask) if len(correct_mask) > 0 else 0
+    n_correct = np.sum(correct_mask)
+    n_gt_matches = int(data['conf_matrix_gt'][b_id].sum().cpu())
+    recall = 0 if n_gt_matches == 0 else n_correct / (n_gt_matches)
+    # recall might be larger than 1, since the calculation of conf_matrix_gt
+    # uses groundtruth depths and camera poses, but epipolar distance is used here.
+
+    # matching info
+    if alpha == 'dynamic':
+        alpha = dynamic_alpha(len(correct_mask))
+    color = error_colormap(epi_errs, conf_thr, alpha=alpha)
+    
+    text = [
+        f'#Matches {len(kpts0)}',
+        f'Precision({conf_thr:.2e}) ({100 * precision:.1f}%): {n_correct}/{len(kpts0)}',
+        f'Recall({conf_thr:.2e}) ({100 * recall:.1f}%): {n_correct}/{n_gt_matches}'
+    ]
+    
+    # make the figure
+    figure = make_matching_figure(img0, img1, kpts0, kpts1,
+                                  color, text=text)
+    return figure
+
+def _make_confidence_figure(data, b_id):
+    # TODO: Implement confidence figure
+    raise NotImplementedError()
+
+
+def make_matching_figures(data, config, mode='evaluation'):
+    """ Make matching figures for a batch.
+    
+    Args:
+        data (Dict): a batch updated by PL_LoFTR.
+        config (Dict): matcher config
+    Returns:
+        figures (Dict[str, List[plt.figure]]
+    """
+    assert mode in ['evaluation', 'confidence']  # 'confidence'
+    figures = {mode: []}
+    for b_id in range(data['image0'].size(0)):
+        if mode == 'evaluation':
+            fig = _make_evaluation_figure(
+                data, b_id,
+                alpha=config.TRAINER.PLOT_MATCHES_ALPHA)
+        elif mode == 'confidence':
+            fig = _make_confidence_figure(data, b_id)
+        else:
+            raise ValueError(f'Unknown plot mode: {mode}')
+        figures[mode].append(fig)
+    return figures
+
+
+def dynamic_alpha(n_matches,
+                  milestones=[0, 300, 1000, 2000],
+                  alphas=[1.0, 0.8, 0.4, 0.2]):
+    if n_matches == 0:
+        return 1.0
+    ranges = list(zip(alphas, alphas[1:] + [None]))
+    loc = bisect.bisect_right(milestones, n_matches) - 1
+    _range = ranges[loc]
+    if _range[1] is None:
+        return _range[0]
+    return _range[1] + (milestones[loc + 1] - n_matches) / (
+        milestones[loc + 1] - milestones[loc]) * (_range[0] - _range[1])
+
+
+def error_colormap(err, thr, alpha=1.0):
+    assert alpha <= 1.0 and alpha > 0, f"Invaid alpha value: {alpha}"
+    x = 1 - np.clip(err / (thr * 2), 0, 1)
+    return np.clip(
+        np.stack([2-x*2, x*2, np.zeros_like(x), np.ones_like(x)*alpha], -1), 0, 1)

vismatch/third_party/Se2_LoFTR/src/utils/profiler.py

@@ -0,0 +1,39 @@
+import torch
+from pytorch_lightning.profiler import SimpleProfiler, PassThroughProfiler
+from contextlib import contextmanager
+from pytorch_lightning.utilities import rank_zero_only
+
+
+class InferenceProfiler(SimpleProfiler):
+    """
+    This profiler records duration of actions with cuda.synchronize()
+    Use this in test time. 
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.start = rank_zero_only(self.start)
+        self.stop = rank_zero_only(self.stop)
+        self.summary = rank_zero_only(self.summary)
+
+    @contextmanager
+    def profile(self, action_name: str) -> None:
+        try:
+            torch.cuda.synchronize()
+            self.start(action_name)
+            yield action_name
+        finally:
+            torch.cuda.synchronize()
+            self.stop(action_name)
+
+
+def build_profiler(name):
+    if name == 'inference':
+        return InferenceProfiler()
+    elif name == 'pytorch':
+        from pytorch_lightning.profiler import PyTorchProfiler
+        return PyTorchProfiler(use_cuda=True, profile_memory=True, row_limit=100)
+    elif name is None:
+        return PassThroughProfiler()
+    else:
+        raise ValueError(f'Invalid profiler: {name}')

vismatch/third_party/Se2_LoFTR/test.py

@@ -0,0 +1,68 @@
+import pytorch_lightning as pl
+import argparse
+import pprint
+from loguru import logger as loguru_logger
+
+from src.config.default import get_cfg_defaults
+from src.utils.profiler import build_profiler
+
+from src.lightning.data import MultiSceneDataModule
+from src.lightning.lightning_loftr import PL_LoFTR
+
+
+def parse_args():
+    # init a costum parser which will be added into pl.Trainer parser
+    # check documentation: https://pytorch-lightning.readthedocs.io/en/latest/common/trainer.html#trainer-flags
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument(
+        'data_cfg_path', type=str, help='data config path')
+    parser.add_argument(
+        'main_cfg_path', type=str, help='main config path')
+    parser.add_argument(
+        '--ckpt_path', type=str, default="weights/indoor_ds.ckpt", help='path to the checkpoint')
+    parser.add_argument(
+        '--dump_dir', type=str, default=None, help="if set, the matching results will be dump to dump_dir")
+    parser.add_argument(
+        '--profiler_name', type=str, default=None, help='options: [inference, pytorch], or leave it unset')
+    parser.add_argument(
+        '--batch_size', type=int, default=1, help='batch_size per gpu')
+    parser.add_argument(
+        '--num_workers', type=int, default=2)
+    parser.add_argument(
+        '--thr', type=float, default=None, help='modify the coarse-level matching threshold.')
+
+    parser = pl.Trainer.add_argparse_args(parser)
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    # parse arguments
+    args = parse_args()
+    pprint.pprint(vars(args))
+
+    # init default-cfg and merge it with the main- and data-cfg
+    config = get_cfg_defaults()
+    config.merge_from_file(args.main_cfg_path)
+    config.merge_from_file(args.data_cfg_path)
+    pl.seed_everything(config.TRAINER.SEED)  # reproducibility
+
+    # tune when testing
+    if args.thr is not None:
+        config.LOFTR.MATCH_COARSE.THR = args.thr
+
+    loguru_logger.info(f"Args and config initialized!")
+
+    # lightning module
+    profiler = build_profiler(args.profiler_name)
+    model = PL_LoFTR(config, pretrained_ckpt=args.ckpt_path, profiler=profiler, dump_dir=args.dump_dir)
+    loguru_logger.info(f"LoFTR-lightning initialized!")
+
+    # lightning data
+    data_module = MultiSceneDataModule(args, config)
+    loguru_logger.info(f"DataModule initialized!")
+
+    # lightning trainer
+    trainer = pl.Trainer.from_argparse_args(args, replace_sampler_ddp=False, logger=False)
+
+    loguru_logger.info(f"Start testing!")
+    trainer.test(model, datamodule=data_module, verbose=False)

vismatch/third_party/Se2_LoFTR/train.py

@@ -0,0 +1,123 @@
+import math
+import argparse
+import pprint
+from distutils.util import strtobool
+from pathlib import Path
+from loguru import logger as loguru_logger
+
+import pytorch_lightning as pl
+from pytorch_lightning.utilities import rank_zero_only
+from pytorch_lightning.loggers import TensorBoardLogger
+from pytorch_lightning.callbacks import ModelCheckpoint, LearningRateMonitor
+from pytorch_lightning.plugins import DDPPlugin
+
+from src.config.default import get_cfg_defaults
+from src.utils.misc import get_rank_zero_only_logger, setup_gpus
+from src.utils.profiler import build_profiler
+from src.lightning.data import MultiSceneDataModule
+from src.lightning.lightning_loftr import PL_LoFTR
+
+loguru_logger = get_rank_zero_only_logger(loguru_logger)
+
+
+def parse_args():
+    # init a costum parser which will be added into pl.Trainer parser
+    # check documentation: https://pytorch-lightning.readthedocs.io/en/latest/common/trainer.html#trainer-flags
+    parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument(
+        'data_cfg_path', type=str, help='data config path')
+    parser.add_argument(
+        'main_cfg_path', type=str, help='main config path')
+    parser.add_argument(
+        '--exp_name', type=str, default='default_exp_name')
+    parser.add_argument(
+        '--batch_size', type=int, default=4, help='batch_size per gpu')
+    parser.add_argument(
+        '--num_workers', type=int, default=4)
+    parser.add_argument(
+        '--pin_memory', type=lambda x: bool(strtobool(x)),
+        nargs='?', default=True, help='whether loading data to pinned memory or not')
+    parser.add_argument(
+        '--ckpt_path', type=str, default=None,
+        help='pretrained checkpoint path, helpful for using a pre-trained coarse-only LoFTR')
+    parser.add_argument(
+        '--disable_ckpt', action='store_true',
+        help='disable checkpoint saving (useful for debugging).')
+    parser.add_argument(
+        '--profiler_name', type=str, default=None,
+        help='options: [inference, pytorch], or leave it unset')
+    parser.add_argument(
+        '--parallel_load_data', action='store_true',
+        help='load datasets in with multiple processes.')
+
+    parser = pl.Trainer.add_argparse_args(parser)
+    return parser.parse_args()
+
+
+def main():
+    # parse arguments
+    args = parse_args()
+    rank_zero_only(pprint.pprint)(vars(args))
+
+    # init default-cfg and merge it with the main- and data-cfg
+    config = get_cfg_defaults()
+    config.merge_from_file(args.main_cfg_path)
+    config.merge_from_file(args.data_cfg_path)
+    pl.seed_everything(config.TRAINER.SEED)  # reproducibility
+    # TODO: Use different seeds for each dataloader workers
+    # This is needed for data augmentation
+    
+    # scale lr and warmup-step automatically
+    args.gpus = _n_gpus = setup_gpus(args.gpus)
+    config.TRAINER.WORLD_SIZE = _n_gpus * args.num_nodes
+    config.TRAINER.TRUE_BATCH_SIZE = config.TRAINER.WORLD_SIZE * args.batch_size
+    _scaling = config.TRAINER.TRUE_BATCH_SIZE / config.TRAINER.CANONICAL_BS
+    config.TRAINER.SCALING = _scaling
+    config.TRAINER.TRUE_LR = config.TRAINER.CANONICAL_LR * _scaling
+    config.TRAINER.WARMUP_STEP = math.floor(config.TRAINER.WARMUP_STEP / _scaling)
+    
+    # lightning module
+    profiler = build_profiler(args.profiler_name)
+    model = PL_LoFTR(config, pretrained_ckpt=args.ckpt_path, profiler=profiler)
+    loguru_logger.info(f"LoFTR LightningModule initialized!")
+    
+    # lightning data
+    data_module = MultiSceneDataModule(args, config)
+    loguru_logger.info(f"LoFTR DataModule initialized!")
+    
+    # TensorBoard Logger
+    logger = TensorBoardLogger(save_dir='logs/tb_logs', name=args.exp_name, default_hp_metric=False)
+    ckpt_dir = Path(logger.log_dir) / 'checkpoints'
+    
+    # Callbacks
+    # TODO: update ModelCheckpoint to monitor multiple metrics
+    ckpt_callback = ModelCheckpoint(monitor='auc@10', verbose=True, save_top_k=5, mode='max',
+                                    save_last=True,
+                                    dirpath=str(ckpt_dir),
+                                    filename='{epoch}-{auc@5:.3f}-{auc@10:.3f}-{auc@20:.3f}')
+    lr_monitor = LearningRateMonitor(logging_interval='step')
+    callbacks = [lr_monitor]
+    if not args.disable_ckpt:
+        callbacks.append(ckpt_callback)
+    
+    # Lightning Trainer
+    trainer = pl.Trainer.from_argparse_args(
+        args,
+        plugins=DDPPlugin(find_unused_parameters=False,
+                          num_nodes=args.num_nodes,
+                          sync_batchnorm=config.TRAINER.WORLD_SIZE > 0),
+        gradient_clip_val=config.TRAINER.GRADIENT_CLIPPING,
+        callbacks=callbacks,
+        logger=logger,
+        sync_batchnorm=config.TRAINER.WORLD_SIZE > 0,
+        replace_sampler_ddp=False,  # use custom sampler
+        reload_dataloaders_every_epoch=False,  # avoid repeated samples!
+        weights_summary='full',
+        profiler=profiler)
+    loguru_logger.info(f"Trainer initialized!")
+    loguru_logger.info(f"Start training!")
+    trainer.fit(model, datamodule=data_module)
+
+
+if __name__ == '__main__':
+    main()

vismatch/third_party/SphereGlue/demo_SphereGlue.py

@@ -0,0 +1,141 @@
+import os
+import time
+import torch
+import argparse
+from torch.utils.data import DataLoader
+from model.sphereglue import SphereGlue
+from utils.demo_mydataset import MyDataset 
+import numpy
+from utils.Utils import draw_match, split_name
+
+torch.cuda.empty_cache()
+torch.manual_seed(1)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(description='SuperGlue',
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter)
+    parser.add_argument('--input', type=str, default='data/', 
+        help=' Input path', metavar='')   
+    parser.add_argument('--output', type=str, default='output', 
+        help=' Output path', metavar='')
+    parser.add_argument('--matches', type=str, default='matches/', 
+        help=' Matches path', metavar='') 
+    parser.add_argument('--images', type=str, default='images/', 
+        help=' Image path', metavar='')                                                                         
+    parser.add_argument('--match_threshold', type=float, default=0.2,
+        help=' Match threshold ', metavar='')
+    parser.add_argument('--batch_size', type=int, default=1,
+        help=' Batch size of training images', metavar='')
+    parser.add_argument('--max_kpts', type=int, default=20000,
+        help=' Maximum number of keypoints', metavar='')
+    parser.add_argument('--knn', type=int, default=20,
+        help=' K nearest neighbour for creating edges', metavar='')
+    parser.add_argument('--sinkhorn_iterations', type=int, default=20,
+        help=' Sinkhorn iterations', metavar='')
+    parser.add_argument('--aggregation', type=str, nargs='+', default='add',
+        help=' Aggregation', metavar='') 
+    parser.add_argument('--force_cpu', action='store_true',
+        help='Force pytorch to run in CPU mode.')
+
+    parser.add_argument('--detector', type=str, default= 'superpoint',  # 'superpoint', 'akaze', 'superpoint_tf', 'kp2d', 'sift'
+        help=' Detector', metavar='') 
+    parser.add_argument('--save_npz', type=bool,
+        help=' Saving npz', metavar='') 
+    parser.add_argument('--draw_matches', type=bool, 
+        help=' Draws matches', metavar='') 
+    parser.add_argument('--display_matches', type=bool, 
+        help=' Display matches', metavar='') 
+
+
+    args = parser.parse_args()
+    print('\nargs',args)
+
+    # Connecting device to cuda or cpu
+    device = 'cuda' if torch.cuda.is_available() and not args.force_cpu else 'cpu'
+    print('\nRunning inference on device \"{}\"'.format(device))
+
+    # Config file
+    default_config = {'K': 2, #Chebyshev filter size
+                    'GNN_layers': ['cross'], 
+                    'match_threshold': args.match_threshold,
+                    'sinkhorn_iterations':args.sinkhorn_iterations,
+                    'aggr': args.aggregation,
+                    'knn': args.knn,
+                    'max_kpts': args.max_kpts
+                }
+
+
+    if args.detector in ['kp2d', 'superpoint', 'superpoint_tf']:
+        default_config['descriptor_dim'] = 256
+        default_config['output_dim'] = 256*2
+    if args.detector  == 'sift':
+        default_config['descriptor_dim'] = 128
+        default_config['output_dim'] = 128*2
+    if args.detector  == 'akaze':
+        default_config['descriptor_dim'] = 64
+        default_config['output_dim'] = 64*2
+
+    # Data processing and Data loader    
+    dataset = MyDataset(args.knn, args.input, args.detector , device)
+    print(f'Size of Dataset {len(dataset)}')
+    
+    data_loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=False)
+
+    # Loading the model
+    matching_test = SphereGlue(default_config).to(device)              
+
+    model_path = 'model_weights/' + args.detector + '/autosaved.pt'
+    ckpt_data = torch.load(model_path)
+    matching_test.load_state_dict(ckpt_data["MODEL_STATE_DICT"])
+    matching_test.eval()
+    print('Loading the model weights for detector ' + str(args.detector ) +  ' from->', model_path)
+    
+
+    with torch.no_grad():
+        for data, y_true in data_loader:
+            # run the model on the given dataset
+            y_pred = matching_test(data)
+            
+            output_data = { 'keypointCoords0': data['keypointCoords0'][0],
+                                'keypointCoords1': data['keypointCoords1'][0],
+                                'keypointScores0': data['scores1'][0].detach().cpu().numpy(),
+                                'keypointScores1': data['scores2'][0].detach().cpu().numpy(),
+                                'correspondences': y_pred['matches0'][0].to(torch.float32).detach().cpu().numpy(),
+                                'scores': y_pred['matching_scores0'][0].to(torch.float32).detach().cpu().numpy()
+                            }
+
+            # Saves npz files with keypoints information and predictions 
+            if args.save_npz is True:
+                # Output path
+                output_path = os.path.join(args.output, args.detector)
+
+                if not os.path.exists(args.output):
+                    os.mkdir(args.output)
+                if not os.path.exists(output_path):
+                    os.mkdir(output_path)
+
+                numpy.savez(os.path.join(output_path,str(data['name'][0])), **output_data)
+
+
+            if args.draw_matches is True:
+                matches_path = os.path.join(args.matches, args.detector)
+
+                if not os.path.exists(args.matches):
+                    os.mkdir(args.matches)
+                if not os.path.exists(matches_path):
+                    os.mkdir(matches_path)
+
+                i1, i2, i1_i2 = split_name(data['name'][0])
+                draw_match(os.path.join(args.images, i1 + '.jpg'), os.path.join(args.images, i1 +'.jpg'), output_data, os.path.join(matches_path, i1_i2), args)
+
+
+    if args.save_npz is True:
+         print('Predictions are saved in -> ', output_path)
+    if args.draw_matches is True:
+         print('Matches are saved in -> ', matches_path)
+
+
+#-------------------------------------------- End --------------------------------------------#
+
+