图像匹配sparse-ncnet复现

一、资源下载

在进行环境配置之前需要准备以下资源：
1、sparse-ncnet源代码下载
sparse-ncnet
2、MinkowskiEngine源代码下载，由于MinkowskiEngine更新比较快，但是sparse-ncnet 没有进行更新，所以需要在连接中找到0.4.3版本的.zip文件进行下载
MinkowskiEngine0.4.3
3、训练数据集下载（如果只想跑demo可不需要进行下载），按照官方提示进行数据集下载，此过程需要访问外网
ivd数据集下载

二、环境搭建

1、我这里使用的是网上租用的服务器，由于这个复现可能对显存有要求，所以采用租用服务器的方法进行实现，而且不可以租用30系列显卡，我这里使用的是Tesla P40，因为编译MinkowskiEngine需要cuda-10.1，租用的时候选择镜像选择pytorch1.6.0。如果大家的显存是12G可能会报错，还是选择显存大一点的显卡。这个服务器新人有10元代金券，大家可以免费体验。
服务器租用网址

2、搭建好环境后，需要将之前下载好的sparse-ncnet源代码与MinkowskiEngine源代码上传到服务器，并进行解压。

3、首次使用这个服务器打开终端后需要执行source activate命令配置一下anaconda（如果是自己的服务器可以忽略，直接进行第4步）

4、配置好终端后，打开命令行终端依次执行以下指令,有些双等号后面有空格，大家可以自行删除。
a) conda create -n sparsencnet python=3.6.9=h265db76_0（这里一定要安装3.6，其他版本有些库会安装失败）
b) conda activate sparsencnet
c) conda install numpy== 1.15.1 openblas
c) conda install openblas-devel -c anaconda
d) pip install torch== 1.6.0+cu101 torchvision== 0.7.0+cu101 -f https://download.pytorch.org/whl/torch_stable.html或者conda install pytorch== 1.6.0 torchvision== 0.7.0 cudatoolkit=10.1 -c pytorch（大家可以到pytorch官网进行安装pytorch1.6.0，千万不要安错，一定要选择cuda10.1版本，我使用的是前者，因为网速快）
e) cd MinkowskiEngine-0.4.3（进入到自己之前解压好的MinkowskiEngine路径）
f) export CXX=g+±7
g) python setup.py install（如果采用我推荐服务器安装，大家一定要有卡安装，否则编译出错）
h) conda install https://repo.anaconda.com/pkgs/free/linux-64/cudatoolkit-8.0-3.tar.bz2（这个安装下载可能有点慢，如果用上面服务器，大家可以采用无卡模式进行安装）
i) conda install --force --no-deps faiss-gpu=1.4.0=py36_cuda8.0.61_1 -c pytorch
j) conda install matplotlib scikit-image pandas
k) pip uninstall pillow
l) CC=“cc -mavx2” pip install -U --force-reinstall pillow-simd

三、demo测试

搭建好环境后，可以利用官方提供的demo进行测试，需要先通过/sparse-ncnet-master/trained_models/路径下的download.sh文件下载与训练模型。

我将demo.ipynb文件内的内容拷贝了出来，做成可.py文件，一定要和源文件放在同一个地方，然后进入次目录，并进入刚刚搭建好的虚拟环境进行测试。（和我用一样服务器一定要在有卡模式下）

demo.py的代码如下

import faiss
import torch

import os

import sys
sys.path.append('..')

import matplotlib.pyplot as plt
import numpy as np

from lib.model import ImMatchNet, MutualMatching
from lib.normalization import imreadth, resize, normalize, normalize_image
from lib.relocalize import relocalize, relocalize_soft, eval_model_reloc
from lib.sparse import get_matches_both_dirs

checkpoint = '../trained_models/sparsencnet_k10.pth.tar'
chp_args = torch.load(checkpoint)['args']
model = ImMatchNet(use_cuda=True,
                   checkpoint=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,
                   change_stride=1
                  )
                  
image_size = 1600
scale_factor = 0.0625

src=imreadth('aachen_query.jpg')
hA,wA=src.shape[-2:]
src=resize(normalize(src), image_size, scale_factor)
hA_,wA_=src.shape[-2:]

tgt=imreadth('aachen_db.jpg')
hB,wB=tgt.shape[-2:]
tgt=resize(normalize(tgt), image_size, scale_factor)
hB_,wB_=tgt.shape[-2:]   
                  
with torch.no_grad():
    corr4d, feature_A_2x, feature_B_2x, fs1, fs2, fs3, fs4 = eval_model_reloc(
        model,
        {'source_image':src,
         'target_image':tgt}
    )      


Npts = 500

# extract matches
xA_, yA_, xB_, yB_, score_ = get_matches_both_dirs(corr4d, fs1, fs2, fs3, fs4)

# get top Npts
matches_idx_sorted = torch.argsort(-score_.view(-1))
N_matches = min(Npts, matches_idx_sorted.shape[0])
matches_idx_sorted = matches_idx_sorted[:N_matches]
score_ = score_[:,matches_idx_sorted]
xA_ = xA_[:,matches_idx_sorted]
yA_ = yA_[:,matches_idx_sorted]
xB_ = xB_[:,matches_idx_sorted]
yB_ = yB_[:,matches_idx_sorted]

# upscale feature sizes by 2x
fs1_,fs2_,fs3_,fs4_=2*fs1,2*fs2,2*fs3,2*fs4

# relocalization stage 1:
xA_, yA_, xB_, yB_, score_ = relocalize(xA_,
                                        yA_,
                                        xB_,
                                        yB_,
                                        score_,
                                        feature_A_2x,
                                        feature_B_2x,
                                        crop_size=2)

# relocalization stage 2:
xA_, yA_, xB_, yB_, score_ = relocalize_soft(xA_,yA_,xB_,yB_,score_,feature_A_2x, feature_B_2x, upsample_positions=False)

# normalize coords in [0,1] range
yA=((yA_+0.5)/(fs1_)).squeeze().cpu().numpy()
xA=((xA_+0.5)/(fs2_)).squeeze().cpu().numpy()
yB=((yB_+0.5)/(fs3_)).squeeze().cpu().numpy()
xB=((xB_+0.5)/(fs4_)).squeeze().cpu().numpy()




mean = torch.tensor([0.485, 0.456, 0.406]).view(1,3,1,1).cuda()
std = torch.tensor([0.229, 0.224, 0.225]).view(1,3,1,1).cuda()

src_tgt = (torch.cat((src,tgt),dim=2)*std)+mean
src_tgt = src_tgt.squeeze().permute(1,2,0).mul(255).cpu().numpy().astype(np.uint8)


plt.imshow(src_tgt)
plt.axis('off')
plt.scatter(xA*wA_,yA*hA_,0.5,c='limegreen',alpha=0.5)
plt.scatter(xB*wB_,yB*hB_+hA_,0.5,c='limegreen',alpha=0.5)
plt.plot(np.stack((xA*wA_,xB*wB_)),
         np.stack((yA*hA_,yB*hB_+hA_)),
         c='limegreen',
         linewidth=0.1)
plt.gcf().set_dpi(400)
                 

四、训练数据

在进行训练数据之前，要将下载好的数据集导入所存储位置，然后运行train.py进行训练。

下载好的ivd数据集所存储的内容。

运行train.py。

训练之后的权值文件，会存储在预训练模型文件夹下。