【论文阅读】Similarity Reasoning and Filtration for Image-Text Matching

发表时间：2021
引用：Diao, Haiwen, et al. “Similarity reasoning and filtration for image-text matching.” arXiv preprint arXiv:2101.01368 (2021).
论文地址：https://openaccess.thecvf.com
代码地址：https://github.com/Paranioar/SGRAF

介绍

作者还是为了实现更为细粒度的对齐。虽然此前使用全局对齐或者局部对齐的方式已经取得了一些成效，但是作者认为，当下的模型方法还是存在三点问题：

1. 大多方法使用标量的方法计算局部特征之间的相似性，也就是说会直接转换成一个数值，而数值是很难描述区域和单词之间的关联的
2. 在计算完区域和单词之间的潜在对齐后，部分模型就直接用最大池化或者平均池化的方法计算出全局相似。无论是哪种方法，都会阻碍全局对齐和局部对齐之间的信息交流。（比如SCAN最后用的就是一个平均池化的方法：$S_{AVG}(I,T)=\frac{{\sum }_{i=1}^{k}R(v_i,a_i^t)}{k}$）
3. 很少去考虑一些没有太大意义的对齐的干扰，比如下图中"a"和"in"和其他实例之间的关系
   

那么，为了解决上述三点问题，作者提出了一种相似图推理和注意过滤网络。具体来说：

1. 首先捕捉整个图像和句子之间的全局对齐，以及图像区域和句子单词之间的局部对齐。在这里，使用基于向量的相似性表示来更有效地表示这种跨模态关联；
2. 使用SGR相似图推理模块来捕捉局部对齐和全局对齐之间的关系，从而推理更为准确的图像文本相似性，在这里，SGR模块基于GCNN图卷积神经网络构成；
3. 使用SAF相似性注意过滤模块来聚合所有具有不同显著性分数的对齐，从而减少无意义的干扰。

注意的是，这里不是说先用SGR再用SAF，也就是这两个模块没有先后顺序，作者进行实验的时候也是分模块进行的实验

方法

整体的模型结构如上所示，可以看到，经过特征提取后，就进行全局对齐和局部对齐，然后将对齐的结果分别进入SGR和SAF模块进行相似度的计算，这两个模块是独立的。那么下面也将分成四个部分进行说明重点说明。

特征提取

图特征提取

使用Faster RCNN提取图特征，添加一个全连接层转成d维向量，得到每个区域的表示$V=\{v_1,...,v_k\}$，这里和SCAN是一致的。

然后，在每个区域上执行自注意力机制，该机制采用平均特征$\overline{q_v}=\frac{1}{K}{\sum }_{i=1}^K{v}_i$作为查询并汇总所有区域以获得全局表示$\bar{v}$。代码对应部分如下：

class VisualSA(nn.Module):
    def __init__(self, embed_dim, dropout_rate, num_region):
        super(VisualSA, self).__init__()

        self.embedding_local = nn.Sequential(nn.Linear(embed_dim, embed_dim),
                                             nn.BatchNorm1d(num_region),
                                             nn.Tanh(), nn.Dropout(dropout_rate))
        self.embedding_global = nn.Sequential(nn.Linear(embed_dim, embed_dim),
                                              nn.BatchNorm1d(embed_dim),
                                              nn.Tanh(), nn.Dropout(dropout_rate))
        self.embedding_common = nn.Sequential(nn.Linear(embed_dim, 1))

        self.init_weights()
        self.softmax = nn.Softmax(dim=1)

    # local (batch, 36, d=1024)
    # global (batch, d=1024)
    def forward(self, local, raw_global):
        # compute embedding of local regions and raw global image
        l_emb = self.embedding_local(local)
        g_emb = self.embedding_global(raw_global)

        # compute the normalized weights, shape: (batch_size, 36)
        g_emb = g_emb.unsqueeze(1).repeat(1, l_emb.size(1), 1)
        common = l_emb.mul(g_emb)
        weights = self.embedding_common(common).squeeze(2)
        weights = self.softmax(weights)

        # compute final image, shape: (batch_size, 1024)
        new_global = (weights.unsqueeze(2) * local).sum(dim=1)
        new_global = l2norm(new_global, dim=-1)

        # new_global (shape, d=1024)
        return new_global

文本特征提取

使用GRU提取文本特征，得到表示$T=\{t_1,...,t_L\}$，按照同样的方式，得到文本的全局表示。这一部分在代码中体现在class TextSA(nn.Module)中

相似性表示学习

向量相似函数

之前说过，作者没有使用余弦距离或欧几里得距离来计算相似性标量，而是用的一个相似向量来表示不同模态之间的相似关联程度。那么在这里，作者就是用的如下函数：
$$s(x,y;W)=\frac{W|x-y{|}^2}{||W|x-y{|}^2|{|}_2}\text{\hspace{1em}(1)}$$
其中$W\in {\mathbb{R}}^{m\times d}$为一个可学习的参数矩阵，从而可以获取一个m维度的相似向量。$|\cdot {|}^2$和$||\cdot |{|}_2$分别表示逐元素平方和l2标准化。

这一部分在代码的class EncoderSimilarity(nn.Module)中：

def l2norm(X, dim=-1, eps=1e-8):
    """L2-normalize columns of X"""
    norm = torch.pow(X, 2).sum(dim=dim, keepdim=True).sqrt() + eps
    X = torch.div(X, norm)
    return X

self.sim_tranloc_w = nn.Linear(embed_size, sim_dim)
self.sim_tranglo_w = nn.Linear(embed_size, sim_dim)

sim_loc = torch.pow(torch.sub(Context_img, cap_i_expand), 2)
sim_loc = l2norm(self.sim_tranloc_w(sim_loc), dim=-1)

sim_glo = torch.pow(torch.sub(img_glo, cap_glo_i), 2)
sim_glo = l2norm(self.sim_tranglo_w(sim_glo), dim=-1)

全局相似表示

利用上面的公式得到$s^g=s(\bar{v},\bar{t};W_g)$，那么这里的$W_g$就用于学习全局相似表示

局部相似表示

和SCAN一致，注意力权重计算为：${\alpha }_{ij}=\frac{exp(\lambda {\hat{c}}_{ij})}{{\sum }_{i=1}^{K}exp(\lambda {\hat{c}}_{ij})}$，$c_{ij}$表示区域特征$v_i$和词特征$t_j$之间的余弦距离，也就是相似程度，这里用的是标量，${\hat{c}}_{ij}$为标准化后的结果。由此得到生成的视觉特征（第j个单词对整幅图像的贡献程度）$a_j^v={\sum }_{i=1}^K{\alpha }_{ij}{v}_i$

这样，得到$a_j^v$和$t_j$之间（即第j个单词和整个图像之间的相关性）的局部相似表示为：$s_j^l=s(a_j^v,t_j;W_t)$

这一部分在代码中，直接用了SCAN的代码部分：

def SCAN_attention(query, context, smooth, eps=1e-8):
    """
    query: (n_context, queryL, d)
    context: (n_context, sourceL, d)
    """
    # --> (batch, d, queryL)
    queryT = torch.transpose(query, 1, 2)

    # (batch, sourceL, d)(batch, d, queryL)
    # --> (batch, sourceL, queryL)
    attn = torch.bmm(context, queryT)

    attn = nn.LeakyReLU(0.1)(attn)
    attn = l2norm(attn, 2)

    # --> (batch, queryL, sourceL)
    attn = torch.transpose(attn, 1, 2).contiguous()
    # --> (batch, queryL, sourceL
    attn = F.softmax(attn*smooth, dim=2)

    # --> (batch, sourceL, queryL)
    attnT = torch.transpose(attn, 1, 2).contiguous()

    # --> (batch, d, sourceL)
    contextT = torch.transpose(context, 1, 2)
    # (batch x d x sourceL)(batch x sourceL x queryL)
    # --> (batch, d, queryL)
    weightedContext = torch.bmm(contextT, attnT)
    # --> (batch, queryL, d)
    weightedContext = torch.transpose(weightedContext, 1, 2)
    weightedContext = l2norm(weightedContext, dim=-1)

    return weightedContext

需要注意的是，这里只有特定单词和对应图像区域之间的关联，并不像SCAN一样还存在特定区域和单词之间的关联

SGR(相似图推理)

将所有单词的局部相似度表示和文本的全局相似度表示作为图节点$N=\{s_1^l,..,s_L^l,s^g\}$，这里的节点都是m维向量（代码中m取256），代码中如下：

# concat the global and local alignments
sim_emb = torch.cat([sim_glo.unsqueeze(1), sim_loc], 1)             # batch, n_word+1, sim_d

使用以下公式计算节点$s_q$和$s_p$之间的边：
$$e(s_p,s_q;W_{in},W_{out})=\frac{exp((W_{in}{s}_p)(W_{out}{s}_q))}{{\sum }_{q}exp((W_{in}{s}_p)(W_{out}{s}_q))}\text{\hspace{1em}(2)}$$
两个$W$分别为输入节点和输出节点的线性变化。从这里也能看出，节点之间的边是存在方向的。

这样，就可以利用构造好的节点和边，通过不断更新来进行相似图推理：
$$\begin{gathered} {\hat{s}}_p^n=\sum _{q}e(s_p^n,s_q^n;W_{in}^n,W_{out}^n)\cdot s_q^n \\ {s}_p^{n+1}=ReLU(W_r^n{\hat{s}}_p^n)\text{\hspace{1em}(3)} \end{gathered}$$

其中$s_p^0$和$s_q^0$为步骤n=0时候的从$N$中提取出来的节点（即初始节点），$W_r^n,W_{in}^n,W_{out}^n$为每一步中的学习出来的参数，每一步结束后，$s_p^n$都会被$s_p^{n+1}$取代

对相似度进行N步迭代推理，并以最后一步全局节点的输出作为推理的相似度表示，然后将其送入一个全连接层来推断最终的相似度分数

在代码中，N取3，具体如下：

class GraphReasoning(nn.Module):
    """
    Perform the similarity graph reasoning with a full-connected graph
    Args: - sim_emb: global and local alignments, shape: (batch_size, L+1, 256)
    Returns; - sim_sgr: reasoned graph nodes after several steps, shape: (batch_size, L+1, 256)
    """
    def __init__(self, sim_dim):
        super(GraphReasoning, self).__init__()

        self.graph_query_w = nn.Linear(sim_dim, sim_dim)
        self.graph_key_w = nn.Linear(sim_dim, sim_dim)
        self.sim_graph_w = nn.Linear(sim_dim, sim_dim)
        self.relu = nn.ReLU()

        self.init_weights()

    # sim_emb (batch, n_word+1, sim_d)
    def forward(self, sim_emb):
        sim_query = self.graph_query_w(sim_emb)
        sim_key = self.graph_key_w(sim_emb)
        # batch, n_word+1, n_word+1
        sim_edge = torch.softmax(torch.bmm(sim_query, sim_key.permute(0, 2, 1)), dim=-1)
        # batch, n_word+1, sim_d
        sim_sgr = torch.bmm(sim_edge, sim_emb)
        # batch, n_word+1, sim_d
        sim_sgr = self.relu(self.sim_graph_w(sim_sgr))
        return sim_sgr

SAF(相似注意过滤)

对每一个节点$s_p$计算一个聚合权重
$${\beta }_p=\frac{\delta (BN(W_f{s}_p))}{{\sum }_{s_q\in N}\delta (BN(W_f{s}_p))}\text{\hspace{1em}(4)}$$
其中$\delta$ 为Sigmoid函数，$BN$表示batch normalization，$W_f\in {\mathbb{R}}^{m\times 1}$为一个线性变换

然后，使用公式$s_f={\sum }_{s_p\in N}{\beta }_p{s}_p$将所有的相似性特征聚合起来，可以看到，通过这样的方式，使得诸如"the"，"be"等无意义的对齐的系数会变得很小，最终等同于被过滤掉。

最终使用一个完全连接层来预测输入图像和句子之间的最终相似度，这里就是一个标量了。

相关代码如下：

class AttentionFiltration(nn.Module):
    """
    Perform the similarity Attention Filtration with a gate-based attention
    Args: - sim_emb: global and local alignments, shape: (batch_size, L+1, 256)
    Returns; - sim_saf: aggregated alignment after attention filtration, shape: (batch_size, 256)
    """
    def __init__(self, sim_dim):
        super(AttentionFiltration, self).__init__()

        self.attn_sim_w = nn.Linear(sim_dim, 1)
        self.bn = nn.BatchNorm1d(1)

        self.init_weights()

    # input (batch, n_word+1, sim_d)
    def forward(self, sim_emb):
        sim_attn = l1norm(torch.sigmoid(self.bn(self.attn_sim_w(sim_emb).permute(0, 2, 1))), dim=-1)
        sim_saf = torch.matmul(sim_attn, sim_emb)
        sim_saf = l2norm(sim_saf.squeeze(1), dim=-1)
        return sim_saf

损失函数

$L_r(v,t)=[\gamma -S_r(v,t)+S_r(v,t^{-}){]}_{+}[\gamma -S_r(v,t)+S_r(v^{-},t){]}_{+}$

其中$(v,t)$为一个（图像，文本）对，$t^{-}$和$v^{-}$为最大负样本，$\gamma$为边缘参数，$S_r$为SGR或者SAF预测的相似函数。这一部分和SCAN基本一致

实验结果

单独看两个模块的相似结果：

在这里面，可以看到，对于SAF来说，诸如on、the、a之类的冠词等的权重非常低，这一类词就被过滤掉了