YOLOv9改进策略【模型轻量化】| GhostNetV2：利用远距离注意力增强廉价操作

一、本文介绍

本文记录的是基于GhostNet V2的YOLOv9目标检测轻量化改进方法研究。在目前的研究中，基于轻量级卷积神经网络在建模长距离依赖方面的不足，引入自注意力机制虽能捕获全局信息，但在实际速度方面存在较大阻碍。GhostNet V2提出了一种硬件友好的注意力机制（DFC attention），并基于此构建GhostNet V2。本文利用其中的模块重新设计YOLOv9的骨干网络，使模型在降低模型大小的同时，赋予模型各阶段更大的感受野，提高模型性能。

---

二、GhostNet V2设计原理

GhostNet V2是为移动应用设计的一种新的轻量级视觉骨干网络，其设计出发点、模型结构及优势如下：

1. 设计出发点：
   • 基于轻量级卷积神经网络在建模长距离依赖方面的不足，引入自注意力机制虽能捕获全局信息，但在实际速度方面存在较大阻碍。
   • 为解决这些问题，提出了一种硬件友好的注意力机制（DFC attention），并基于此构建GhostNet V2。
2. 模型结构：
   • 增强Ghost模块：Ghost模块中只有一半的特征与其他像素交互，损害了其捕获空间信息的能力。因此，使用DFC attention来增强Ghost模块的输出特征Y，以捕获不同空间像素之间的长距离依赖。
     • 输入特征X被送入两个分支，一个是Ghost模块产生输出特征Y，另一个是DFC模块生成注意力图A。
     • 通过1×1卷积将模块的输入X转换为DFC的输入Z。
     • 模块的最终输出O是两个分支输出的乘积，即O = Sigmoid(A) ⊙ V(X)。
   • 特征下采样：直接将DFC attention与Ghost模块并行会引入额外的计算成本，因此通过对特征进行水平和垂直下采样来减小特征的大小，使DFC attention中的所有操作都在较小的特征上进行，然后再将特征图上采样到原始大小以匹配Ghost分支的特征大小。
   • GhostV2 bottleneck：GhostNet采用包含两个Ghost模块的倒置残差瓶颈结构，第一个模块产生具有更多通道的扩展特征，第二个模块减少通道数以获得输出特征。通过研究发现增强“表达能力”更有效，因此只将扩展特征与DFC attention相乘。DFC attention分支与第一个Ghost模块并行以增强扩展特征，然后增强的特征被发送到第二个Ghost模块以产生输出特征。

2. 优势：
   • 性能提升：在ImageNet数据集上，GhostNet V2以更低的计算成本实现了比GhostNet V1更高的性能，例如，GhostNet V2以167M FLOPs实现了75.3%的top - 1准确率，显著优于GhostNet V1的74.5%。
   • 下游任务有效性：在对象检测和语义分割等下游任务中，捕获长距离依赖至关重要，DFC attention可以有效地赋予Ghost模块更大的感受野，从而构建更强大和高效的模块。

论文：https://arxiv.org/abs/2211.12905
源码：https://github.com/huawei-noah/Efficient-AI-Backbones/tree/master/ghostnetv2_pytorch

三、GhostModuleV2模块的实现代码

GhostModuleV2模块的实现代码如下：

class GhostModuleV2(nn.Module):
    def __init__(self, inp, oup, kernel_size=1, ratio=2, dw_size=3, stride=1, relu=True,mode='attn'):
        super(GhostModuleV2, self).__init__()
        self.mode=mode
        self.gate_fn=nn.Sigmoid()

        if self.mode in ['original']:
            self.oup = oup
            init_channels = math.ceil(oup / ratio) 
            new_channels = init_channels*(ratio-1)
            self.primary_conv = nn.Sequential(  
                nn.Conv2d(inp, init_channels, kernel_size, stride, kernel_size//2, bias=False),
                nn.BatchNorm2d(init_channels),
                nn.ReLU(inplace=True) if relu else nn.Sequential(),
            )
            self.cheap_operation = nn.Sequential(
                nn.Conv2d(init_channels, new_channels, dw_size, 1, dw_size//2, groups=init_channels, bias=False),
                nn.BatchNorm2d(new_channels),
                nn.ReLU(inplace=True) if relu else nn.Sequential(),
            )
        elif self.mode in ['attn']: 
            self.oup = oup
            init_channels = math.ceil(oup / ratio) 
            new_channels = init_channels*(ratio-1)
            self.primary_conv = nn.Sequential(  
                nn.Conv2d(inp, init_channels, kernel_size, stride, kernel_size//2, bias=False),
                nn.BatchNorm2d(init_channels),
                nn.ReLU(inplace=True) if relu else nn.Sequential(),
            )
            self.cheap_operation = nn.Sequential(
                nn.Conv2d(init_channels, new_channels, dw_size, 1, dw_size//2, groups=init_channels, bias=False),
                nn.BatchNorm2d(new_channels),
                nn.ReLU(inplace=True) if relu else nn.Sequential(),
            ) 
            self.short_conv = nn.Sequential( 
                nn.Conv2d(inp, oup, kernel_size, stride, kernel_size//2, bias=False),
                nn.BatchNorm2d(oup),
                nn.Conv2d(oup, oup, kernel_size=(1,5), stride=1, padding=(0,2), groups=oup,bias=False),
                nn.BatchNorm2d(oup),
                nn.Conv2d(oup, oup, kernel_size=(5,1), stride=1, padding=(2,0), groups=oup,bias=False),
                nn.BatchNorm2d(oup),
            ) 
      
    def forward(self, x):
        if self.mode in ['original']:
            x1 = self.primary_conv(x)
            x2 = self.cheap_operation(x1)
            out = torch.cat([x1,x2], dim=1)
            return out[:,:self.oup,:,:]         
        elif self.mode in ['attn']:  
            res=self.short_conv(F.avg_pool2d(x,kernel_size=2,stride=2))  
            x1 = self.primary_conv(x)
            x2 = self.cheap_operation(x1)
            out = torch.cat([x1,x2], dim=1)
            return out[:,:self.oup,:,:]*F.interpolate(self.gate_fn(res),size=(out.shape[-2],out.shape[-1]),mode='nearest')

---

四、添加步骤

4.1 修改common.py

此处需要修改的文件是models/common.py

common.py中定义了网络结构的通用模块，我们想要加入新的模块就只需要将模块代码放到这个文件内即可。

此时需要将上方实现的代码添加到common.py中。

注意❗：在4.2小节中的yolo.py文件中需要声明的模块名称为：GhostModuleV2。

4.2 修改yolo.py

此处需要修改的文件是models/yolo.py

yolo.py用于函数调用，我们只需要将common.py中定义的新的模块名添加到parse_model函数下即可。

GhostModuleV2模块添加后如下：

---

五、yaml模型文件

5.1 模型改进⭐

在代码配置完成后，配置模型的YAML文件。

此处以models/detect/yolov9-c.yaml为例，在同目录下创建一个用于自己数据集训练的模型文件yolov9-c-ghostnetv2.yaml。

将yolov9-c.yaml中的内容复制到yolov9-c-ghostnetv2.yaml文件下，修改nc数量等于自己数据中目标的数量。

📌 模型的修改方法是将骨干网络中的所有RepNCSPELAN4模块替换成GhostModuleV2模块，使用DFC attention，并重新设计YOLOv9的骨干网络，使模型在降低模型大小的同时，赋予模型各阶段更大的感受野，提高模型性能。

结构如下：

# YOLOv9

# parameters
nc: 1  # number of classes
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
#activation: nn.LeakyReLU(0.1)
#activation: nn.ReLU()

# anchors
anchors: 3

# YOLOv9 backbone
backbone:
  [
   [-1, 1, Silence, []],  
   
   # conv down
   [-1, 1, GhostModuleV2, [64, 3, 2, 3, 2, 'attn']],  # 1-P1/2

   # conv down
   [-1, 1, GhostModuleV2, [128, 3, 2, 3, 2, 'attn']],  # 2-P2/4

   # elan-1 block
   [-1, 1, GhostModuleV2, [64, 3, 2, 3, 1, 'attn']],  # 3

   # avg-conv down
   [-1, 1, ADown, [256]],  # 4-P3/8

   # elan-2 block
   [-1, 1, GhostModuleV2, [128, 3, 2, 3, 1, 'attn']],  # 5

   # avg-conv down
   [-1, 1, ADown, [512]],  # 6-P4/16

   # elan-2 block
   [-1, 1, GhostModuleV2, [256, 3, 2, 3, 1, 'attn']],  # 7

   # avg-conv down
   [-1, 1, ADown, [512]],  # 8-P5/32

   # elan-2 block
   [-1, 1, GhostModuleV2, [512, 3, 2, 3, 1, 'attn']],  # 9
  ]

# YOLOv9 head
head:
  [
   # elan-spp block
   [-1, 1, SPPELAN, [512, 256]],  # 10

   # up-concat merge
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 7], 1, Concat, [1]],  # cat backbone P4

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 13

   # up-concat merge
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [[-1, 5], 1, Concat, [1]],  # cat backbone P3

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [256, 256, 128, 1]],  # 16 (P3/8-small)

   # avg-conv-down merge
   [-1, 1, ADown, [256]],
   [[-1, 13], 1, Concat, [1]],  # cat head P4

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 19 (P4/16-medium)

   # avg-conv-down merge
   [-1, 1, ADown, [512]],
   [[-1, 10], 1, Concat, [1]],  # cat head P5

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 22 (P5/32-large)
   
   
   # multi-level reversible auxiliary branch
   
   # routing
   [5, 1, CBLinear, [[256]]], # 23
   [7, 1, CBLinear, [[256, 512]]], # 24
   [9, 1, CBLinear, [[256, 512, 512]]], # 25
   
   # conv down
   [0, 1, Conv, [64, 3, 2]],  # 26-P1/2

   # conv down
   [-1, 1, Conv, [128, 3, 2]],  # 27-P2/4

   # elan-1 block
   [-1, 1, RepNCSPELAN4, [256, 128, 64, 1]],  # 28

   # avg-conv down fuse
   [-1, 1, ADown, [256]],  # 29-P3/8
   [[23, 24, 25, -1], 1, CBFuse, [[0, 0, 0]]], # 30  

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 256, 128, 1]],  # 31

   # avg-conv down fuse
   [-1, 1, ADown, [512]],  # 32-P4/16
   [[24, 25, -1], 1, CBFuse, [[1, 1]]], # 33 

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 34

   # avg-conv down fuse
   [-1, 1, ADown, [512]],  # 35-P5/32
   [[25, -1], 1, CBFuse, [[2]]], # 36

   # elan-2 block
   [-1, 1, RepNCSPELAN4, [512, 512, 256, 1]],  # 37
   
   
   
   # detection head

   # detect
   [[31, 34, 37, 16, 19, 22], 1, DualDDetect, [nc]],  # DualDDetect(A3, A4, A5, P3, P4, P5)
  ]

---

六、成功运行结果

分别打印网络模型可以看到GhostModuleV2已经加入到模型中，并可以进行训练了。

yolov9-c-ghostnetv2：

                 from  n    params  module                                  arguments                     
  0                -1  1         0  models.common.Silence                   []                            
  1                -1  1      4032  models.common.GhostModuleV2             [3, 64, 3, 2, 3, 2, 'attn']   
  2                -1  1    113472  models.common.GhostModuleV2             [64, 128, 3, 2, 3, 2, 'attn'] 
  3                -1  1    112032  models.common.GhostModuleV2             [128, 64, 3, 2, 3, 1, 'attn'] 
  4                -1  1     41472  models.common.ADown                     [64, 256]                     
  5                -1  1    445248  models.common.GhostModuleV2             [256, 128, 3, 2, 3, 1, 'attn']
  6                -1  1    164864  models.common.ADown                     [128, 512]                    
  7                -1  1   1775232  models.common.GhostModuleV2             [512, 256, 3, 2, 3, 1, 'attn']
  8                -1  1    328704  models.common.ADown                     [256, 512]                    
  9                -1  1   3550464  models.common.GhostModuleV2             [512, 512, 3, 2, 3, 1, 'attn']
 10                -1  1    656896  models.common.SPPELAN                   [512, 512, 256]               
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 12           [-1, 7]  1         0  models.common.Concat                    [1]                           
 13                -1  1   2988544  models.common.RepNCSPELAN4              [768, 512, 512, 256, 1]       
 14                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 15           [-1, 5]  1         0  models.common.Concat                    [1]                           
 16                -1  1    814336  models.common.RepNCSPELAN4              [640, 256, 256, 128, 1]       
 17                -1  1    164352  models.common.ADown                     [256, 256]                    
 18          [-1, 13]  1         0  models.common.Concat                    [1]                           
 19                -1  1   2988544  models.common.RepNCSPELAN4              [768, 512, 512, 256, 1]       
 20                -1  1    656384  models.common.ADown                     [512, 512]                    
 21          [-1, 10]  1         0  models.common.Concat                    [1]                           
 22                -1  1   3119616  models.common.RepNCSPELAN4              [1024, 512, 512, 256, 1]      
 23                 5  1     33024  models.common.CBLinear                  [128, [256]]                  
 24                 7  1    197376  models.common.CBLinear                  [256, [256, 512]]             
 25                 9  1    656640  models.common.CBLinear                  [512, [256, 512, 512]]        
 26                 0  1      1856  models.common.Conv                      [3, 64, 3, 2]                 
 27                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
 28                -1  1    212864  models.common.RepNCSPELAN4              [128, 256, 128, 64, 1]        
 29                -1  1    164352  models.common.ADown                     [256, 256]                    
 30  [23, 24, 25, -1]  1         0  models.common.CBFuse                    [[0, 0, 0]]                   
 31                -1  1    847616  models.common.RepNCSPELAN4              [256, 512, 256, 128, 1]       
 32                -1  1    656384  models.common.ADown                     [512, 512]                    
 33      [24, 25, -1]  1         0  models.common.CBFuse                    [[1, 1]]                      
 34                -1  1   2857472  models.common.RepNCSPELAN4              [512, 512, 512, 256, 1]       
 35                -1  1    656384  models.common.ADown                     [512, 512]                    
 36          [25, -1]  1         0  models.common.CBFuse                    [[2]]                         
 37                -1  1   2857472  models.common.RepNCSPELAN4              [512, 512, 512, 256, 1]       
 38[31, 34, 37, 16, 19, 22]  1  21542822  models.yolo.DualDDetect                 [1, [512, 512, 512, 256, 512, 512]]
 yolov9-c-ghostnetv2 summary: 806 layers, 48682438 parameters, 48682406 gradients 207.7GFLOPs