源自Deformable Convolutional Networks的一种可变形卷积实现解析

衍生记录：深度学习pytorch之简单方法自定义9类卷积即插即用

文章目录

- 概述
- 1. 可变形卷积的背景
- 2. DeformConv2D概述
- - 2.1 构造函数分析
  - 2.2 前向传播函数解析
  - - 2.2.1 偏移量的计算与应用
    - 2.2.2 目标位置的计算
    - 2.2.3 四个角的插值
    - 2.2.4 双线性插值的权重
    - 2.2.5 特征图的采样与卷积操作
- 3. 可变形卷积的优势
- 4. 完整代码
- 5. 总结

概述

在深度学习中的计算机视觉任务中，卷积神经网络（CNN）是最常见且强大的模型之一。然而，传统的卷积操作在处理具有几何变换（如旋转、平移、缩放等）或变形的图像时，通常表现得不够灵活。为了解决这一问题，可变形卷积（Deformable Convolution）应运而生。可变形卷积（Deformable Convolution），来源于微软亚洲研究院（MSRA）在 ICCV 2017 发表的论文：《Deformable Convolutional Networks》（作者：Jifeng Dai 等，论文地址：arXiv:1703.06211）。

本文将详细解析 DeformConv2D 类，它是可变形卷积的一种实现，帮助我们更好地理解可变形卷积的工作原理。
提示：DeformConv2D完整代码见4.完整代码

1. 可变形卷积的背景

传统卷积神经网络（CNN）中的卷积操作通过在图像上滑动固定大小的卷积核来提取局部特征。每个卷积核的权重是固定的，这使得卷积操作对输入图像的空间位置不够敏感。因此，在面对具有复杂空间变换（如变形物体、物体位移等）的图像时，传统的卷积核可能无法有效地捕捉到这些变化。

可变形卷积通过引入动态调整卷积核位置的机制，解决了这一问题。它能够根据输入图像的特征自适应地调整卷积核的采样位置，从而更好地适应输入的几何变换。

2. DeformConv2D概述

DeformConv2D 类是实现可变形卷积操作的核心组件。它的主要功能是允许卷积核在图像中根据学习到的偏移量进行自适应调整。通过这种方式，卷积操作能够更加灵活地适应图像中的空间变形，提高了网络在处理复杂图像时的表现。
在这里插入图片描述

3×3标准卷积和可变形卷积的采样位置示意图。（a）标准卷积的规则采样网格（绿色点）。（b）可变形卷积中变形的采样位置（深蓝色点）和增强的偏移量（浅蓝色箭头）。（c）（d）是（b）的特殊情况，显示可变形卷积如何对尺度、（各向异性）纵横比和旋转进行广义化。

2.1 构造函数分析

DeformConv2D 的构造函数如下：

def __init__(self, inc=3, outc=16, kernel_size=3, padding=1, bias=None):
    super(DeformConv2D, self).__init__()
    self.offset = nn.Conv2d(inc, 18, kernel_size=kernel_size, padding=padding)
    self.kernel_size = kernel_size
    self.padding = padding
    self.zero_padding = nn.ZeroPad2d(padding)
    self.conv_kernel = nn.Conv2d(inc, outc, kernel_size=kernel_size, stride=kernel_size, bias=bias)

inc 和 outc：输入和输出通道数。
kernel_size 和 padding：卷积核的大小和填充方式。
self.offset：用于计算偏移量的卷积层，它输出每个像素的偏移量。输出通道数为18，表示每个像素有9个x方向和9个y方向的偏移量。
self.conv_kernel：最终执行标准卷积操作的卷积层。

2.2 前向传播函数解析

DeformConv2D 的前向传播函数实现了变形卷积的主要步骤，下面我们一一解析：

def forward(self, x):
    offset = self.offset(x)  # 计算偏移量
    offset = offset.permute(0, 2, 3, 1)  # 调整偏移量的形状

    if self.padding > 0:
        x = self.zero_padding(x)  # 如果有填充，执行填充操作

    # 计算目标位置 p
    p_0 = self._get_p_0(x)  # 输入图像每个像素的位置
    p_n = self._get_p_n()  # 卷积核的相对位置网格
    p = self._get_p(p_0, offset, p_n)  # 每个像素的目标位置

    # 计算四个角的插值位置
    q_lt, q_rb, q_lb, q_rt = self._get_q(p)
    mask = self._get_mask(p)  # 掩码，标记哪些区域无效
    g_lt, g_rb, g_lb, g_rt = self._get_g(p, q_lt, q_rb, q_lb, q_rt)  # 双线性插值的权重

    # 从输入图像中采样数据
    x_q = self._get_x_q(x, q_lt, q_rb, q_lb, q_rt)

    # 重塑采样后的数据并执行卷积操作
    x_offset = self._reshape_x_offset(x_q, g_lt, g_rb, g_lb, g_rt)
    out = self.conv_kernel(x_offset)
    return out

2.2.1 偏移量的计算与应用

通过 self.offset(x) 计算每个像素的偏移量，偏移量表示了卷积核应该滑动到哪里。然后，偏移量的维度调整为 (batch_size, height, width, 18)，其中18是每个像素在x方向和y方向的偏移量。

2.2.2 目标位置的计算

输入图像的每个像素都有一个对应的目标位置 p，它由原始位置 p_0 和通过偏移量计算的变化量构成。公式如下：

$p_0 + \Delta p$

其中，p_0 是像素的原始位置，Δp 是偏移量。

2.2.3 四个角的插值

在目标位置 p 处，可能不落在整数位置。因此，需要通过四个邻近整数位置（左上 q_lt，右下 q_rb，左下 q_lb 和右上 q_rt）进行双线性插值。

2.2.4 双线性插值的权重

双线性插值的权重 g_lt、g_rb、g_lb 和 g_rt 通过目标位置与邻近整数位置的距离计算得出。通过这些权重，可以计算目标位置的值。

2.2.5 特征图的采样与卷积操作

在计算出权重后，我们可以从输入图像中根据目标位置 p 进行采样。然后，通过 _reshape_x_offset 函数将采样结果整理成适合卷积操作的格式，最后用 self.conv_kernel 执行标准的卷积操作。

3. 可变形卷积的优势

传统卷积核对图像的每个位置进行固定的采样，而可变形卷积通过学习得到的偏移量使得卷积核可以根据图像的内容动态地调整其采样位置。这带来了以下几个优势：

更好的空间适应性：对于具有旋转、平移等空间变换的图像，可变形卷积能够自适应调整卷积核位置，从而提高模型的表现。
提高了图像变形的容忍度：在处理复杂的图像变形时（如物体的非刚性变形），传统卷积可能难以有效捕捉这些变化，而可变形卷积通过自适应调整，能够更好地应对这些挑战。
提升了模型的灵活性和表达能力：可变形卷积使得网络可以更好地捕捉图像中的复杂变化模式，尤其是在目标检测、图像分割等任务中表现尤为出色。

4. 完整代码

使用代码，其中inc为输入通道，outc为输出通道：

    model = DeformConv2D(inc=3, outc=32, kernel_size=3, padding=1, bias=None)
    x = torch.zeros(16, 3, 224, 224)
    outs = model(x)

定义代码：

from torch.autograd import Variable, Function
import torch
from torch import nn
import numpy as np


class DeformConv2D(nn.Module):
    def __init__(self, inc=3, outc=16, kernel_size=3, padding=1, bias=None):
        super(DeformConv2D, self).__init__()
        self.offset = nn.Conv2d(inc, 18, kernel_size=kernel_size, padding=padding)
        self.kernel_size = kernel_size
        self.padding = padding
        self.zero_padding = nn.ZeroPad2d(padding)
        self.conv_kernel = nn.Conv2d(inc, outc, kernel_size=kernel_size, stride=kernel_size, bias=bias)

    def forward(self, x):

        offset = self.offset(x)

        dtype = offset.data.type()
        ks = self.kernel_size
        N = offset.size(1) // 2

        # Change offset's order from [x1, x2, ..., y1, y2, ...] to [x1, y1, x2, y2, ...]
        # Codes below are written to make sure same results of MXNet implementation.
        # You can remove them, and it won't influence the module's performance.
        offsets_index = Variable(torch.cat([torch.arange(0, 2*N, 2), torch.arange(1, 2*N+1, 2)]), requires_grad=False).type_as(x).long()
        offsets_index = offsets_index.unsqueeze(dim=0).unsqueeze(dim=-1).unsqueeze(dim=-1).expand(*offset.size())
        offset = torch.gather(offset, dim=1, index=offsets_index)
        # ------------------------------------------------------------------------

        if self.padding:
            x = self.zero_padding(x)

        # (b, 2N, h, w)
        p = self._get_p(offset, dtype)

        # (b, h, w, 2N)
        p = p.contiguous().permute(0, 2, 3, 1)
        q_lt = Variable(p.data, requires_grad=False).floor()
        q_rb = q_lt + 1

        q_lt = torch.cat([torch.clamp(q_lt[..., :N], 0, x.size(2)-1), torch.clamp(q_lt[..., N:], 0, x.size(3)-1)], dim=-1).long()
        q_rb = torch.cat([torch.clamp(q_rb[..., :N], 0, x.size(2)-1), torch.clamp(q_rb[..., N:], 0, x.size(3)-1)], dim=-1).long()
        q_lb = torch.cat([q_lt[..., :N], q_rb[..., N:]], -1)
        q_rt = torch.cat([q_rb[..., :N], q_lt[..., N:]], -1)

        # (b, h, w, N)
        mask = torch.cat([p[..., :N].lt(self.padding)+p[..., :N].gt(x.size(2)-1-self.padding),
                          p[..., N:].lt(self.padding)+p[..., N:].gt(x.size(3)-1-self.padding)], dim=-1).type_as(p)
        mask = mask.detach()
        floor_p = p - (p - torch.floor(p))
        p = p*(1-mask) + floor_p*mask
        p = torch.cat([torch.clamp(p[..., :N], 0, x.size(2)-1), torch.clamp(p[..., N:], 0, x.size(3)-1)], dim=-1)

        # bilinear kernel (b, h, w, N)
        g_lt = (1 + (q_lt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_lt[..., N:].type_as(p) - p[..., N:]))
        g_rb = (1 - (q_rb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_rb[..., N:].type_as(p) - p[..., N:]))
        g_lb = (1 + (q_lb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_lb[..., N:].type_as(p) - p[..., N:]))
        g_rt = (1 - (q_rt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_rt[..., N:].type_as(p) - p[..., N:]))

        # (b, c, h, w, N)
        x_q_lt = self._get_x_q(x, q_lt, N)
        x_q_rb = self._get_x_q(x, q_rb, N)
        x_q_lb = self._get_x_q(x, q_lb, N)
        x_q_rt = self._get_x_q(x, q_rt, N)

        # (b, c, h, w, N)
        x_offset = g_lt.unsqueeze(dim=1) * x_q_lt + \
                   g_rb.unsqueeze(dim=1) * x_q_rb + \
                   g_lb.unsqueeze(dim=1) * x_q_lb + \
                   g_rt.unsqueeze(dim=1) * x_q_rt

        x_offset = self._reshape_x_offset(x_offset, ks)
        out = self.conv_kernel(x_offset)

        return out

    def _get_p_n(self, N, dtype):
        p_n_x, p_n_y = np.meshgrid(range(-(self.kernel_size-1)//2, (self.kernel_size-1)//2+1),
                          range(-(self.kernel_size-1)//2, (self.kernel_size-1)//2+1), indexing='ij')
        # (2N, 1)
        p_n = np.concatenate((p_n_x.flatten(), p_n_y.flatten()))
        p_n = np.reshape(p_n, (1, 2*N, 1, 1))
        p_n = Variable(torch.from_numpy(p_n).type(dtype), requires_grad=False)

        return p_n

    @staticmethod
    def _get_p_0(h, w, N, dtype):
        p_0_x, p_0_y = np.meshgrid(range(1, h+1), range(1, w+1), indexing='ij')
        p_0_x = p_0_x.flatten().reshape(1, 1, h, w).repeat(N, axis=1)
        p_0_y = p_0_y.flatten().reshape(1, 1, h, w).repeat(N, axis=1)
        p_0 = np.concatenate((p_0_x, p_0_y), axis=1)
        p_0 = Variable(torch.from_numpy(p_0).type(dtype), requires_grad=False)

        return p_0

    def _get_p(self, offset, dtype):
        N, h, w = offset.size(1)//2, offset.size(2), offset.size(3)

        # (1, 2N, 1, 1)
        p_n = self._get_p_n(N, dtype)
        # (1, 2N, h, w)
        p_0 = self._get_p_0(h, w, N, dtype)
        p = p_0 + p_n + offset
        return p

    def _get_x_q(self, x, q, N):
        b, h, w, _ = q.size()
        padded_w = x.size(3)
        c = x.size(1)
        # (b, c, h*w)
        x = x.contiguous().view(b, c, -1)

        # (b, h, w, N)
        index = q[..., :N]*padded_w + q[..., N:]  # offset_x*w + offset_y
        # (b, c, h*w*N)
        index = index.contiguous().unsqueeze(dim=1).expand(-1, c, -1, -1, -1).contiguous().view(b, c, -1)

        x_offset = x.gather(dim=-1, index=index).contiguous().view(b, c, h, w, N)

        return x_offset

    @staticmethod
    def _reshape_x_offset(x_offset, ks):
        b, c, h, w, N = x_offset.size()
        x_offset = torch.cat([x_offset[..., s:s+ks].contiguous().view(b, c, h, w*ks) for s in range(0, N, ks)], dim=-1)
        x_offset = x_offset.contiguous().view(b, c, h*ks, w*ks)

        return x_offset


if __name__ == '__main__':
    model = DeformConv2D(inc=3, outc=32, kernel_size=3, padding=1, bias=None)

    x = torch.zeros(16, 3, 224, 224)
    outs = model(x)
    print(outs.shape)