RT-DETR优化改进：轻量级上采样CARAFE算子 | 注意力机制大作战

原创

AI小怪兽

修改于 2023-11-20 01:41:16

1.2K00

代码可运行

文章被收录于专栏：YOLO大作战YOLO大作战

运行总次数：0

代码可运行

本文独家改进: 上采样操作CARAFE，具有感受野大、内容感知、轻量级、计算速度快等优点，引入RT-DETR二次创新；

1）代替Upsample进行使用；

1.CARAFE介绍

论文：https://arxiv.org/abs/1905.02188

代码：GitHub - open-mmlab/mmdetection: OpenMMLab Detection Toolbox and Benchmark

本文尝试提出一个新的上采样操作CARAFE，它应该具有以下特点：

感受野大。不同于以往只利用亚像素邻域的工作(如双线性插值)，CARAFE可以在一个大的接收域中聚合上下文信息。
内容感知。CARAFE不是为所有的样本使用一个固定的内核(例如反卷积)，而是支持特定于实例的内容感知处理，它可以动态地生成自适应的内核。
轻量级、计算速度快。CARAFE引入了很少的计算开销，可以很容易地集成到现有的网络架构中

在这项工作中，我们提出了内容感知特征重组(CARAFE)来上采样一个特征地图。在每个位置上，CARAFE可以利用底层的内容信息来预测重组内核，并在预定义的附近区域内重组特征。由于内容信息，CARAFE可以在不同的位置使用自适应和优化的重组核，实现比主流的上采样操作(如插值或反褶积)更好的性能。

为了验证CARAFE的有效性，包括目标检测、实例分割、语义分割、图像修复等，在MS COCO test-dev 2018上，CARAFE可以将Faster RCNN的检测性能提高1.2%，将Mask RCNN的实例分割性能提高1.3%。当对256通道的H × W特征图进行2倍的上采样时，CARAFE引入的计算开销只有H * W * 199k FLOPs，而反卷积的计算开销为H * W * 1180k FLOPs。因此，CARAFE是一个有效和高效的特征上采样算子。

2.CARAFE加入RT-DETR

2.1加入ultralytics/nn/attention/attention.py

核心代码：

class CARAFE(nn.Module):
    # CARAFE: Content-Aware ReAssembly of FEatures       https://arxiv.org/pdf/1905.02188.pdf
    def __init__(self, c1, c2, kernel_size=3, up_factor=2):
        super(CARAFE, self).__init__()
        self.kernel_size = kernel_size
        self.up_factor = up_factor
        self.down = nn.Conv2d(c1, c1 // 4, 1)
        self.encoder = nn.Conv2d(c1 // 4, self.up_factor ** 2 * self.kernel_size ** 2,
                                 self.kernel_size, 1, self.kernel_size // 2)
        self.out = nn.Conv2d(c1, c2, 1)

    def forward(self, x):
        N, C, H, W = x.size()
        # N,C,H,W -> N,C,delta*H,delta*W
        # kernel prediction module
        kernel_tensor = self.down(x)  # (N, Cm, H, W)
        kernel_tensor = self.encoder(kernel_tensor)  # (N, S^2 * Kup^2, H, W)
        kernel_tensor = F.pixel_shuffle(kernel_tensor, self.up_factor)  # (N, S^2 * Kup^2, H, W)->(N, Kup^2, S*H, S*W)
        kernel_tensor = F.softmax(kernel_tensor, dim=1)  # (N, Kup^2, S*H, S*W)
        kernel_tensor = kernel_tensor.unfold(2, self.up_factor, step=self.up_factor)  # (N, Kup^2, H, W*S, S)
        kernel_tensor = kernel_tensor.unfold(3, self.up_factor, step=self.up_factor)  # (N, Kup^2, H, W, S, S)
        kernel_tensor = kernel_tensor.reshape(N, self.kernel_size ** 2, H, W,
                                              self.up_factor ** 2)  # (N, Kup^2, H, W, S^2)
        kernel_tensor = kernel_tensor.permute(0, 2, 3, 1, 4)  # (N, H, W, Kup^2, S^2)

        # content-aware reassembly module
        # tensor.unfold: dim, size, step
        x = F.pad(x, pad=(self.kernel_size // 2, self.kernel_size // 2,
                          self.kernel_size // 2, self.kernel_size // 2),
                  mode='constant', value=0)  # (N, C, H+Kup//2+Kup//2, W+Kup//2+Kup//2)
        x = x.unfold(2, self.kernel_size, step=1)  # (N, C, H, W+Kup//2+Kup//2, Kup)
        x = x.unfold(3, self.kernel_size, step=1)  # (N, C, H, W, Kup, Kup)
        x = x.reshape(N, C, H, W, -1)  # (N, C, H, W, Kup^2)
        x = x.permute(0, 2, 3, 1, 4)  # (N, H, W, C, Kup^2)

        out_tensor = torch.matmul(x, kernel_tensor)  # (N, H, W, C, S^2)
        out_tensor = out_tensor.reshape(N, H, W, -1)
        out_tensor = out_tensor.permute(0, 3, 1, 2)
        out_tensor = F.pixel_shuffle(out_tensor, self.up_factor)
        out_tensor = self.out(out_tensor)
        # print("up shape:",out_tensor.shape)
        return out_tensor