【YOLOv8改进 - 注意力机制】Gather-Excite : 提高网络捕获长距离特征交互的能力

YOLOv8目标检测创新改进与实战案例专栏

专栏目录： YOLOv8有效改进系列及项目实战目录 包含卷积，主干 注意力，检测头等创新机制 以及 各种目标检测分割项目实战案例

专栏链接: YOLOv8基础解析+创新改进+实战案例

介绍

摘要

虽然卷积神经网络（CNNs）中使用自下而上的局部操作符与自然图像的一些统计特性很好地匹配，但这也可能阻止这些模型捕捉上下文的长程特征交互。在这项工作中，我们提出了一种简单且轻量的方法，以更好地在CNNs中利用上下文信息。我们通过引入一对操作符来实现这一目标：聚集（gather），该操作符高效地聚合来自大空间范围的特征响应；激发（excite），将汇集的信息重新分配给局部特征。这些操作符在添加参数数量和计算复杂度方面都很便宜，并且可以直接集成到现有架构中以提高其性能。多个数据集上的实验表明，聚集-激发（gather-excite）操作符可以带来类似于增加CNN深度的好处，但成本仅为其一小部分。例如，我们发现带有聚集-激发操作符的ResNet-50在ImageNet上能够超越其101层的对应模型，而无需额外的可学习参数。我们还提出了一对参数化的聚集-激发操作符，这对进一步提高性能有帮助，并将其与最近引入的挤压-激励网络（Squeeze-and-Excitation Networks）联系起来，并分析这些变化对CNN特征激活统计的影响。

文章链接

论文地址：论文地址

代码地址：代码地址

基本原理

Gather-Excite（简称GE）框架旨在增强卷积神经网络（CNNs）中对上下文的利用能力。它引入了两个主要操作符：gather和excite，这两个操作符协同工作，提高了网络捕获长距离特征交互的能力。

技术原理

1. 动机

传统的卷积神经网络主要使用局部操作符，这些操作符虽然高效，但在捕捉长距离依赖关系方面存在局限性。这是因为它们的感受野是局部的。尽管更深的层理论上具有更大的感受野，但实际上有效感受野要小得多。这一限制妨碍了CNN利用整个图像中分布的上下文信息。

2. Gather操作符 (ξG)

Gather操作符用于从较大的空间范围内聚合特征响应。它通过汇集广泛区域的信息，使网络能够收集上下文信息。这个操作符可以通过不同的池化方法实现，如平均池化，它对指定范围内的特征值进行平均。

3. Excite操作符 (ξE)

Excite操作符将聚合的信息重新分配给局部特征。这种重新分配通过根据聚合的上下文信息重新缩放原始输入特征来实现。Excite操作符使用门控机制（通常是sigmoid函数）来调整输入特征，使其受到聚合上下文的调节。

4. 在CNN中的整合

GE操作符轻量且易于整合到现有的CNN架构中。它们被插入到ResNet等网络的残差块中，就在与恒等分支求和之前。这样的整合提高了网络的表示能力，而不会显著增加计算负担。

实现细节

1. 无参数配对

在基础实现（GE-θ−）中，gather操作符使用平均池化来聚合特征，excite操作符使用sigmoid函数来调整这些聚合。这种方法不引入额外的可学习参数，并且显著提高了性能。

2. 参数化配对

为了进一步增强框架，参数化的gather操作符被引入，通过深度卷积来应用空间滤波到独立通道上。这种方法被称为GE-θ，为gather操作符添加了可学习参数，进一步提高了性能。

性能和优势

1. ImageNet分类：实验表明，将GE操作符集成到ResNet-50中，其性能优于更深的ResNet-101，展示了上下文利用的效率。

2. 泛化能力：GE框架在其他架构和任务中也表现出良好的泛化能力，如在MS COCO上的Faster R-CNN目标检测和CIFAR-10/100上的分类任务。

3. 计算效率：这些操作符计算成本低，不会显著增加网络的参数数量或计算复杂度，适合资源受限的环境。

核心代码

无

下载YoloV8代码

直接下载

GitHub地址

Git Clone

git clone https://github.com/ultralytics/ultralytics

安装环境

进入代码根目录并安装依赖。

pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple

在最新版本中，官方已经废弃了requirements.txt文件，转而将所有必要的代码和依赖整合进了ultralytics包中。因此，用户只需安装这个单一的ultralytics库，就能获得所需的全部功能和环境依赖。

pip install ultralytics

引入代码

在根目录下的ultralytics/nn/目录，新建一个 attention目录，然后新建一个以 GatherExcite为文件名的py文件， 把代码拷贝进去。

import math, torch
from torch import nn as nn
import torch.nn.functional as F

from timm.models.layers.create_act import create_act_layer, get_act_layer
from timm.models.layers.create_conv2d import create_conv2d
from timm.models.layers import make_divisible
from timm.models.layers.mlp import ConvMlp


class GatherExcite(nn.Module):
    def __init__(
            self, channels, feat_size=None, extra_params=False, extent=0, use_mlp=True,
            rd_ratio=1./16, rd_channels=None,  rd_divisor=1, add_maxpool=False,
            act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, gate_layer='sigmoid'):
        super(GatherExcite, self).__init__()
        self.add_maxpool = add_maxpool
        act_layer = get_act_layer(act_layer)
        self.extent = extent
        if extra_params:
            self.gather = nn.Sequential()
            if extent == 0:
                assert feat_size is not None, 'spatial feature size must be specified for global extent w/ params'
                self.gather.add_module(
                    'conv1', create_conv2d(channels, channels, kernel_size=feat_size, stride=1, depthwise=True))
                if norm_layer:
                    self.gather.add_module(f'norm1', nn.BatchNorm2d(channels))
            else:
                assert extent % 2 == 0
                num_conv = int(math.log2(extent))
                for i in range(num_conv):
                    self.gather.add_module(
                        f'conv{i + 1}',
                        create_conv2d(channels, channels, kernel_size=3, stride=2, depthwise=True))
                    if norm_layer:
                        self.gather.add_module(f'norm{i + 1}', nn.BatchNorm2d(channels))
                    if i != num_conv - 1:
                        self.gather.add_module(f'act{i + 1}', act_layer(inplace=True))
        else:
            self.gather = None
            if self.extent == 0:
                self.gk = 0
                self.gs = 0
            else:
                assert extent % 2 == 0
                self.gk = self.extent * 2 - 1
                self.gs = self.extent

        if not rd_channels:
            rd_channels = make_divisible(channels * rd_ratio, rd_divisor, round_limit=0.)
        self.mlp = ConvMlp(channels, rd_channels, act_layer=act_layer) if use_mlp else nn.Identity()
        self.gate = create_act_layer(gate_layer)

    def forward(self, x):
        size = x.shape[-2:]
        if self.gather is not None:
            x_ge = self.gather(x)
        else:
            if self.extent == 0:
                # global extent
                x_ge = x.mean(dim=(2, 3), keepdims=True)
                if self.add_maxpool:
                    # experimental codepath, may remove or change
                    x_ge = 0.5 * x_ge + 0.5 * x.amax((2, 3), keepdim=True)
            else:
                x_ge = F.avg_pool2d(
                    x, kernel_size=self.gk, stride=self.gs, padding=self.gk // 2, count_include_pad=False)
                if self.add_maxpool:
                    # experimental codepath, may remove or change
                    x_ge = 0.5 * x_ge + 0.5 * F.max_pool2d(x, kernel_size=self.gk, stride=self.gs, padding=self.gk // 2)
        x_ge = self.mlp(x_ge)
        if x_ge.shape[-1] != 1 or x_ge.shape[-2] != 1:
            x_ge = F.interpolate(x_ge, size=size)
        return x * self.gate(x_ge)

if __name__ == '__main__':
    input=torch.randn(50,512,7,7)
    GE = GatherExcite(512)
    output=GE(input)
    print(output.shape)

注册

在ultralytics/nn/tasks.py中进行如下操作：

步骤1:

from ultralytics.nn.attention.GatherExcite import GatherExcite

步骤2

修改def parse_model(d, ch, verbose=True):

        elif m is GatherExcite:
            c1 = ch[f]
            args = [c1, *args[0:]]
            

配置yolov8_GatherExcite.yaml

ultralytics/cfg/models/v8/yolov8_GatherExcite.yaml

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLOv8 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect

# Parameters
nc: 80 # number of classes
scales: # model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.33, 0.25, 1024]
  s: [0.33, 0.50, 1024]
  m: [0.67, 0.75, 768]
  l: [1.00, 1.00, 512]
  x: [1.00, 1.25, 512]

# YOLOv8.0n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9

# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2f, [512]] # 12

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 15 (P3/8-small)
  - [-1, 1, GatherExcite, []] #16

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2f, [512]] # 19 (P4/16-medium)
  - [-1, 1, GatherExcite, []] #20

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2f, [1024]] # 23 (P5/32-large)
  - [-1, 1, GatherExcite, []] #24

  - [[16, 20, 24], 1, Detect, [nc]] # Detect(P3, P4, P5)

实验

脚本

import os
from ultralytics import YOLO
 
yaml = 'ultralytics/cfg/models/v8/yolov8_GatherExcite.yaml'

 
model = YOLO(yaml) 
 
model.info()
if __name__ == "__main__":
   
    results = model.train(data='coco128.yaml',
                          name='yolov8_GatherExcite',
                          epochs=10, 
                          workers=8, 
                          batch=1)

结果