SuperGlue:Learning Feature Matching with Graph Neural Networks 解读与实验

最新推荐文章于 2024-06-09 16:03:39 发布

Pxmzhao

最新推荐文章于 2024-06-09 16:03:39 发布

阅读量1w

点赞数 43

分类专栏： Deep Learning Computer Vision python 文章标签：深度学习 pytorch 神经网络 python 人工智能

本文链接：https://blog.csdn.net/shizhuoduao/article/details/107120805

版权

Deep Learning 同时被 3 个专栏收录

5 篇文章 2 订阅

订阅专栏

python

4 篇文章 0 订阅

订阅专栏

Computer Vision

3 篇文章 0 订阅

订阅专栏

说明

本文基于vincentqin对SuperGlue的翻译博客，做了一些补充整理，并在相应章节贴了对应的代码。
由于SuperGlue是做特征匹配的，所以可以用来做一个简单的frame-by-frame的VO，我基于SuperGlue实现了一个简单的VO，对比了传统的ORB，SIFT特征，以及暴力匹配和FLANN匹配方法，请参考https://github.com/Shiaoming/Python-VO。

CVPR 2020 Oral，效果太好了👏

摘要

提出了一种能够同时进行特征匹配以及滤除外点的网络；
特征匹配是通过求解最优传输问题（ optimal transport problem）来解决，最优传输问题的代价由GNN来估计；
基于注意力机制提出了一种灵活的内容聚合机制，这使得SuperGlue能够同时感知潜在的3D场景以及进行特征匹配。

框架（The SuperGlue Architecture)

Motivation

特征匹配必须满足的硬性要求是：

至多有1个匹配点；(约束1)
有些点由于遮挡等原因并没有匹配点。（约束2）

一个成熟的特征匹配模型应该做到：

既能够找到特征之间的正确匹配，又可以鉴别错误匹配。

在这里插入图片描述

整个框架由两个主要模块组成：注意力GNN以及最优匹配层。

注意力GNN，将特征点以及描述子编码成为一个向量（该向量可以理解为特征匹配向量），随后利用自我注意力以及交叉注意力来回增强（重复 $L$ 次）这个向量 $f$ 的特征匹配性能；
最优匹配层，通过计算特征匹配向量的内积得到匹配度得分矩阵，然后通过Sinkhorn算法（迭代 $T$ 次）解算出最优特征分配矩阵。

Formulation

两张图片 $A$ , $B$ ；
每张图片上都有特征点位置 $p$ 以及对应的描述子 $d$ ，用 $(p, d)$ 来表示图像特征；
第 $i$ 个特征可以表示为 $p_i:=(x,y,c)$ ，

其中: $c$ 表示特征点提取置信度; $(x, y)$ 表示特征坐标；描述子可以表示为 $d_i \in R^D$ ，其中 $D$ 表示特征维度，这里的特征可以是CNN特征，如SuperPoint，或者是传统特征SIFT。假设图像 $A$ , $B$ 分别有 $M$ , $N$ 个特征，可以表示为 $A:={1,…,M}$ 以及 $B:={1,…,N}$ 。

Partial Assignment

约束1和2 意味着对应关系来自两组关键点之间的部分分配（partial assignment，即只有一部分关键点匹做了匹配，其余的没有匹配）。我们给出一个软分配矩阵（soft assignment matrix） $\bold P\in[0,1]^{M\times N}$ ，根据上述约束，有如下关系：

设计网络的目标就是从两个局部特征集合预测这个矩阵 $\bold P$ 。

上面的公式表示矩阵 $\bold P$ 每行和每列至多只有一个1，即每行和每列最多只有一个匹配。

Attentional Graph Neural Network

除了 keypoints 的位置 $p$ 和其visual appearance $d$ 之外，融合其他 contextual 线索在直觉上可以增加 keypoints 的 distinctiveness。

比如可以使用一个 keypoint 和与其共视 keypoints 之间的 spatial 和 visual 的关系（比如：引用一堆文献）。
在第二幅图像里的 keypoints 可以帮助解决 ambiguities （通过比较候选匹配，估计相对光度或全局的几何信息等）

这里有个有意思的说法：另外一个具有启发性的观点是人类在寻找匹配点过程是具有参考价值的。想一下人类是怎样进行特征匹配的，人类通过来回浏览两个图像试探性筛选匹配关键点，并进行来回检查（如果不是匹配的特征，观察一下周围有没有匹配的更好的点，直到找到匹配点/或没有匹配）。上述过程人们通过主动寻找上下文来增加特征点特异性，这样可以排除一些具有奇异性的匹配。

本文的核心就是利用基于注意力机制的GNN实现上述过程，即模拟了人类进行特征匹配。

Keypoint Encoder

每个 keypoint $i$ 的 intial representation $^{(0)}\bold x_i$ 结合了 visual appearance （即特征描述子 $d$ ）和 location（即位置 $p$ ）。使用MLP将位置 $p$ 嵌入到高维空间：

上式实际上是将视觉外观以及特征点位置进行了耦合，这使后续的注意力机制能够充分考虑到特征的外观以及位置相似度。

class KeypointEncoder(nn.Module):
    """ Joint encoding of visual appearance and location using MLPs"""
    """ feature_dim: 256, layers: [32, 64, 128, 256]"""
    def __init__(self, feature_dim, layers):
        super().__init__()
        self.encoder = MLP([3] + layers + [feature_dim]) # MLP([3, 32, 64, 128, 256, 256])
        nn.init.constant_(self.encoder[-1].bias, 0.0)

    def forward(self, kpts, scores):
        inputs = [kpts.transpose(1, 2), scores.unsqueeze(1)]
        return self.encoder(torch.cat(inputs, dim=1))
    
def MLP(channels: list, do_bn=True):
    """ Multi-layer perceptron """
    n = len(channels)
    layers = []
    for i in range(1, n):
        layers.append(
            nn.Conv1d(channels[i - 1], channels[i], kernel_size=1, bias=True))
        if i < (n-1):
            if do_bn:
                layers.append(nn.BatchNorm1d(channels[i]))
            layers.append(nn.ReLU())
    return nn.Sequential(*layers)

Multiplex Graph Neural Network

想象有这么一个 graph，它的 nodes 是两幅图像的 keypoints。假设它有两种类型的 undirected edges（multiplex graph）：

Intra-image edges（self edges)： $\varepsilon_{self}$ ，它连接了来自图像内部 keypoint
Inter-image edges（cross edges)： $\varepsilon_{cross}$ ，它连接本图 keypoint $i$ 与另外一张图所有 keypoints

使用 message passing fomulation [23,4] 来沿着两种 edges 传递信息。最后，这个 multiplex GNN 从每个节点的高维度状态开始，通过同时合并所有节点所有边的的信息在每层上面计算一个更新的 representation。

设 $^{(l)}\bold x_i^A$ 为图像 $A$ 上第 $i$ 个元素在第 $l$ 层的 intermediate representation。message $\bold m_{\varepsilon \rightarrow i}$ 是所有 keypoints ${j:(i,j)\in E}$ 联合后的结果，其中 $\varepsilon \in \{\varepsilon_{self},\varepsilon_{cross}\}$ 。则，对 $A$ 中所有 keypoints $i$ 传递更新的残差信息（residual message passing update）为：

其中 $[\cdot ∣ ∣ \cdot]$ 表示串联操作。同样的，图像 $B$ 上所有 keypoints 也按类似的形式更新。

网络层数是固定的 $L$ 层，每层有不同的参数，串联起来交替合并 self 和 cross 的 edges。即从 $l = 1$ 开始：

$l$ 为奇数： $\varepsilon = \varepsilon_{self}$
$l$ 为偶数： $\varepsilon = \varepsilon_{cross}$

这里的self-/cross-attention实际上就是模拟了人类来回浏览匹配的过程，其中self-attention是为了使得特征更加具有匹配特异性，而cross-attention是为了用这些具有特异性的点做图像间特征的相似度比较。

Attentional Aggregation

文章的亮点之一就是将注意力机制用于特征匹配，这到底是如何实现的呢？

注意力机制将 self 以及 cross 信息聚合得到 $\bold m_{\varepsilon \rightarrow i}$ ，其中：

self edge 利用了 self-attention [61]
cross edge 利用了 cross-attention

类似于数据库检索，想要查询（query) $\bold q_i$ ，基于元素的属性即键（key) $\bold k_i$ ，检索到了某些元素的值（value) $\bold v_ j$ 。message 可以按照加权平均的方式来计算：

其中注意力权重 $\alpha_{ij}$ 是 key-query 的 softmax 相似度， $\alpha_{ij}=\text{Softmax}_j(\bold q_i^T \bold k_j)$ 。

这里的 key，query以及 value 是通过GNN 的features 线性映射得到的。令待查询点特征点 $i$ 位于查询图像Q上，所有的源特征点位于图像S上，其中 $(Q,S)\in\{A,B\}^2$ ，则：

每一层 $ℓ$ 都有其对应的一套投影参数，这些参数被所有的keypoints 共享。

最后B 图上 $i$ 匹配的特征描述子为：

下图展示了每层self-attention以及across-attention中权重αijαij的结果。按照匹配从难到易，文中画出了3个不同的特征点作为演示，绿色特征点（容易），蓝色特征点（中等）以及红色特征点（困难）。对于self-attention，初始时它（某个特征）关联了图像上所有的点（首行），然后逐渐地关注在与该特征相邻近的特征点（尾行）。同样地，cross-attention主要关注去匹配可能的特征点，随着层的增加，它逐渐减少匹配点集直到收敛。绿色特征点在第9层就已经趋近收敛，而红色特征直到最后才能趋紧收敛（匹配）。可以看到无论是self还是cross，它们关注的区域都会随着网络层深度的增加而逐渐缩小。

einsum参考

################# 此 attention 为全文最重要的创新点
# query: [Batch_size, 64, 4, N0]
# key: [Batch_size, 64, 4, N1]
# value: [Batch_size, 64, 4, N1]
def attention(query, key, value):
    dim = query.shape[1]
    # q^T * k: [Batch_size, 4, N0, N1]
    scores = torch.einsum('bdhn,bdhm->bhnm', query, key) / dim**.5
    # softmax(q^T * k): [Batch_size, 4, N0, N1]
    prob = torch.nn.functional.softmax(scores, dim=-1)
    # 公式（4）: return [Batch_size, 64, 4, N0], [Batch_size, 4, N0, N1]
    return torch.einsum('bhnm,bdhm->bdhn', prob, value), prob

class MultiHeadedAttention(nn.Module):
    """ Multi-head attention to increase model expressivitiy """
    # num_heads=4, d_model=256
    def __init__(self, num_heads: int, d_model: int):
        super().__init__()
        assert d_model % num_heads == 0
        self.dim = d_model // num_heads #64
        self.num_heads = num_heads #4
        self.merge = nn.Conv1d(d_model, d_model, kernel_size=1)
        # proj: [conv1d, conv1d, conv1d]
        self.proj = nn.ModuleList([deepcopy(self.merge) for _ in range(3)])

    # query: [Batch_size, 256, N0]
    # key: [Batch_size, 256, N1]
    # value: [Batch_size, 256, N1]
    def forward(self, query, key, value):
        batch_dim = query.size(0)
        # 公式（5）
        # 对query,key,value各自做一个conv1d,然后resize
        # query,key,value:[Batch_size, 64, 4, N0/N1]
        query, key, value = [l(x).view(batch_dim, self.dim, self.num_heads, -1)
                             for l, x in zip(self.proj, (query, key, value))]
        # softmax及公式（4）
        # x: [Batch_size, 64, 4, N0]
        # prob: [Batch_size, 4, N0, N1]
        x, prob = attention(query, key, value)
        self.prob.append(prob)
        # return: [Batch_size, 256, N0]
        return self.merge(x.contiguous().view(batch_dim, self.dim*self.num_heads, -1))

class AttentionalPropagation(nn.Module):
    # feature_dim: 256, num_heads:  4
    def __init__(self, feature_dim: int, num_heads: int):
        super().__init__()
        self.attn = MultiHeadedAttention(num_heads, feature_dim)
        # mlp : [512, 512, 256]
        self.mlp = MLP([feature_dim*2, feature_dim*2, feature_dim])
        nn.init.constant_(self.mlp[-1].bias, 0.0)

    # x: [Batch_size, 256, N0]
    # source: [Batch_size, 256, N1]
    def forward(self, x, source): 
        # 公式（4）：message
        message = self.attn(x, source, source) # [Batch_size, 256, N0]
        # 公式（3）后半部分：MLP（x||m)      
        return self.mlp(torch.cat([x, message], dim=1)) # [Batch_size, 256, N0]
    
class AttentionalGNN(nn.Module):
    # feature_dim: 256, layer_names:  ['self', 'cross'] * 9
    def __init__(self, feature_dim: int, layer_names: list):
        super().__init__()
        self.layers = nn.ModuleList([
            AttentionalPropagation(feature_dim, 4)
            for _ in range(len(layer_names))])
        self.names = layer_names

    # desc0: [Batch_size, 256, N0]
    # desc1: [Batch_size, 256, N1]
    def forward(self, desc0, desc1):
        for layer, name in zip(self.layers, self.names):
            layer.attn.prob = []
            if name == 'cross':
                src0, src1 = desc1, desc0
            else:  # if name == 'self':
                src0, src1 = desc0, desc1
            # 公式（3）
            # delta0: [Batch_size, 256, N0]
    		# delta1: [Batch_size, 256, N1]
            delta0, delta1 = layer(desc0, src0), layer(desc1, src1)
            desc0, desc1 = (desc0 + delta0), (desc1 + delta1) 
        return desc0, desc1

Optimal matching layer

接下来的任务就是去构建partial assignment matrix $\bold P$ 。对于一般的graph matching 流程，assignment matrix $\bold P$ 可以通过计算一个 score matrix $\bold S \in R ^{M \times N}$ 来实现。具体而言，可以在公式（1）的约束下，通过最大化总体得分即 $\sum_{i,j}\bold S_{i,j} \bold P_{i,j}$ 可得到 $\bold P$ 。上述过程和求解一个linear assignment problem是等价的。

assignment problem：分配问题

假设有4个工人（workers）a,b,c,d，有4项任务（job）p,q,r,s，每个工人干每一项活的成本都不同（可以理解为不同工人的技术能力不同，薪资待遇也不同），那么便可构造一个代价矩阵（cost matrix） $C$ ：

……

Score Prediction

去计算 $M\times N$ 个潜在匹配得分是不可取的，于是作者就用GNN得到的 $f_i^A$ 以及 $f_i^B$ 计算相似度（此处使用内积）得到pairwise score：

与 learned 的 visual descriptors 不同的是，这里的 $f_i^A$ 和 $f_i^B$ 没有经过normalize，因为不同的feature 幅度不同，可以反映预测的confidence。

Occlusion and Visibility

将 $S$ 扩充一个dustbin 通道，直接把没有匹配的赋值给该通道即可（这样做的作用在于可以滤出错误的匹配点）：

图像 $A$ 上的keypoint 可以被分配到图像 $B$ 上某个keypoint 或者dustbin，每个dustbin 最后有 N（A图像）和M（B图像）个匹配。设 $\bold a=[\bold 1_M^T,N]^T$ ， $\bold b=[\bold 1_N^T,M]^T$ ，则公式（1）的约束变为：

具体实现代码里也有

Sinkhorn Algorithm

求解最大化总体得分可由“Sinkhorn Algorithm”[52,12]进行求解（GPU，differentiable）。

Loss

GNN网络以及optimal matching layer都是可微的，这使得反向传播训练成为可能。网络训练使用了一种监督学习的方式，即有了匹配的真值 $M=\{(i,j)\}\subset A×B$ （如，由真值相对位姿变换得到的匹配关系）。当给定真值标签，就可以去最小化assignment $\bar{\bold P}$ 的负对数似然函数：

这个监督学习的目标是同时最大化精度以及匹配的召回率。

Comparisons to related work

略

Implementation details

所有inermediate representation (key, query value, descriptors) 的维度都是 D=256。

层数 L=9。

Sinkhorn 迭代次数 T=100。

Pytorch实现。

12M 参数。

NVIDIA GTX 1080： 69ms (15fps)

其余参考原文 Appendix。

def forward(self, data):
        """Run SuperGlue on a pair of keypoints and descriptors"""
        desc0, desc1 = data['descriptors0'], data['descriptors1']
        kpts0, kpts1 = data['keypoints0'], data['keypoints1']

        if kpts0.shape[1] == 0 or kpts1.shape[1] == 0:  # no keypoints
            shape0, shape1 = kpts0.shape[:-1], kpts1.shape[:-1]
            return {
                'matches0': kpts0.new_full(shape0, -1, dtype=torch.int),
                'matches1': kpts1.new_full(shape1, -1, dtype=torch.int),
                'matching_scores0': kpts0.new_zeros(shape0),
                'matching_scores1': kpts1.new_zeros(shape1),
            }

        # Keypoint normalization based on image size 
        # (let keypoints range be 0~1)
        kpts0 = normalize_keypoints(kpts0, data['image0'].shape)  # [Batch_size, N0, 2]
        kpts1 = normalize_keypoints(kpts1, data['image1'].shape)  # [Batch_size, N1, 2]

        # Keypoint MLP encoder.
        desc0 = desc0 + self.kenc(kpts0, data['scores0']) # [Batch_size, 256, N0]
        desc1 = desc1 + self.kenc(kpts1, data['scores1']) # [Batch_size, 256, N1]

        # Multi-layer Transformer network.
        desc0, desc1 = self.gnn(desc0, desc1)

        # Final MLP projection.
        mdesc0, mdesc1 = self.final_proj(desc0), self.final_proj(desc1)

        # Compute matching descriptor distance.
        scores = torch.einsum('bdn,bdm->bnm', mdesc0, mdesc1)
        scores = scores / self.config['descriptor_dim']**.5

        # Run the optimal transport.
        scores = log_optimal_transport(
            scores, self.bin_score,
            iters=self.config['sinkhorn_iterations'])

        # Get the matches with score above "match_threshold".
        max0, max1 = scores[:, :-1, :-1].max(2), scores[:, :-1, :-1].max(1)
        indices0, indices1 = max0.indices, max1.indices
        mutual0 = arange_like(indices0, 1)[None] == indices1.gather(1, indices0)
        mutual1 = arange_like(indices1, 1)[None] == indices0.gather(1, indices1)
        zero = scores.new_tensor(0)
        mscores0 = torch.where(mutual0, max0.values.exp(), zero)
        mscores1 = torch.where(mutual1, mscores0.gather(1, indices1), zero)
        valid0 = mutual0 & (mscores0 > self.config['match_threshold'])
        valid1 = mutual1 & valid0.gather(1, indices1)
        indices0 = torch.where(valid0, indices0, indices0.new_tensor(-1))
        indices1 = torch.where(valid1, indices1, indices1.new_tensor(-1))

        return {
            'matches0': indices0, # use -1 for invalid match
            'matches1': indices1, # use -1 for invalid match
            'matching_scores0': mscores0,
            'matching_scores1': mscores1,
        }

Experiments

Homography estimation

Dataset：Oxford and Paris dataset

能够获得非常高的匹配召回率（98.3%）同时获得超高的精度，比传统的暴力匹配都好了一大截。

NN： Nearest Neighbor

NN 的变体：

PointCN [33]

OANet：Order-Aware Nerwork [71]

表中前两列参数为图像四个角的重投影误差。

后两列：

P：percision

R：recall

Indoor pose estimation

Dataset

ScanNet，230M for training，1500 test pairs

Metric

与先前工作[33,71,7]一致，统计5°，10°，15°的情况下的 pose error。

pose error是最大的旋转角度和平移的error。

使用RANSAC计算essential matrix，从而估计相对pose。

也统计了match precision 和 matching score（一个match是否正确基于他的epipolar distance判断）。

Baseline

Result

Outdoor pose estimation

Dataset

PhotoTourism：有ground truth pose，sparse 3D models（使用offline的sfm得到的）

MegaDepth：depth（stereo得到），与PhotoTourism重复的被移除了

Results

Understanding SuperGluse

Ablation Study

Visualizing attention

在这里插入图片描述

网络耗时

在NVIDIA GeForce GTX 1080 GPU跑了500次的结果，512个点69ms（14.5fps），1024个点87ms（11.5fps）。

结论

本文展示了基于注意力的图神经网络对局部特征匹配的强大功能。 SuperGlue的框架使用两种注意力：（i）自我注意力，可以增强局部描述符的接受力；以及（ii）交叉注意力，可以实现跨图像交流，并受到人类来回观察方式的启发进行匹配图像。文中方法通过解决最优传输问题，优雅地处理了特征分配问题以及遮挡点。实验表明，SuperGlue与现有方法相比有了显着改进，可以在极宽的基线室内和室外图像对上进行高精度的相对姿势估计。此外，SuperGlue可以实时运行，并且可以同时使用经典和深度学习特征。

总而言之，论文提出的可学习的中后端（middle-end）算法以功能强大的神经网络模型替代了手工启发式技术，该模型同时在单个统一体系结构中执行上下文聚合，匹配和过滤外点。作者最后提到：若与深度学习前端结合使用，SuperGlue是迈向端到端深度学习SLAM的重要里程碑。（when combined with a deep front-end, SuperGlue is a major milestone towards end-to-end deep SLAM）

简单实验

在这里插入图片描述

扩展实验

说明

由于SuperGlue是做特征匹配的，所以可以用来做VO，我做了一个简单的frame-by-frame的VO：https://github.com/Shiaoming/Python-VO，它对比的特征有：

ORB
SIFT
SuperPoint
可以扩展更多特征描述子（欢迎pull request）

对比的匹配方法有：

KNN
FLANN
SuperGlue
可以扩展更多匹配方法（欢迎pull request）

实验的数据集：

KITTI
更多数据集逐渐扩展支持

实验结果

SuperPoint + SuperGlue在KITTI sequence 00上的frame-by-frame VO轨迹：

不同的特征与匹配方式在KITTI sequence 00上结果对比：

Pxmzhao

关注

43
点赞
踩
170

收藏

觉得还不错? 一键收藏
68
评论
SuperGlue:Learning Feature Matching with Graph Neural Networks 解读与实验

SuperGlue:Learning Feature Matching with Graph Neural Networks说明摘要相关工作局部特征匹配图匹配深度点云匹配框架（The SuperGlue Architecture)MotivationFormulationPartial AssignmentAttentional Graph Neural NetworkKeypoint EncoderMultiplex Graph Neural NetworkAttentional AggregationO
复制链接

扫一扫