YOLOv9改进策略【注意力机制篇】| MCAttention 多尺度交叉轴注意力

news2024/11/13 9:49:28

一、本文介绍

本文记录的是基于MCA注意力模块的YOLOv9目标检测改进方法研究。普通的轴向注意力难以实现长距离交互，不利于捕获分割任务中所需的空间结构或形状，而MCA注意力模块通过构建了两个并行轴向注意力之间的交互，更有效地利用多尺度特征和全局上下文，在改进YOLOv9的过程中，能够契合目标形态，更有效的获取目标的全局信息。

文章目录

  • 一、本文介绍
  • 二、MCANet原理
    • 2.1 MCA的原理：
    • 2.2 MCA的优势：
  • 三、MCA的实现代码
  • 四、添加步骤
    • 4.1 修改common.py
      • 4.1.1 基础模块1
      • 4.1.2 创新模块2⭐
    • 4.2 修改yolo.py
  • 五、yaml模型文件
    • 5.1 模型改进版本一
    • 5.2 模型改进版本二⭐
  • 六、成功运行结果

二、MCANet原理

MCANet：基于多尺度交叉轴关注的医学图像分割

MCANet（Medical Image Segmentation with Multi - Scale Cross - Axis Attention）是一种用于医学图像分割的网络，其核心组件是多尺度交叉轴注意力（Multi - Scale Cross - Axis Attention，MCA）。

2.1 MCA的原理：

  1. 回顾轴向注意力：
    • 轴向注意力将自注意力分解为两个部分，分别负责沿水平或垂直维度计算自注意力，基于此，Axial - DeepLab可沿水平和垂直方向依次聚合特征，使捕获全局信息成为可能。
    • 轴向注意力比自注意力更高效，计算复杂度从 O ( H W × H W ) O(HW \times HW) O(HW×HW)降低到 O ( H W × ( H + W ) ) O(HW \times (H + W)) O(HW×(H+W))。
    • 但在许多医学图像分割任务中，数据集相对较小，轴向注意力难以实现长距离交互，不利于捕获分割任务中所需的空间结构或形状。
  2. 多尺度交叉轴注意力：
    • MCA结构分为两个并行分支，分别计算水平和垂直轴向注意力，每个分支由三个不同核大小的1D卷积组成，用于沿一个空间维度编码多尺度上下文信息，随后通过交叉轴注意力沿另一个空间维度聚合特征。
    • 以顶部分支为例，给定特征图 F F F（编码器最后三个阶段特征图的组合），使用三个并行的1D卷积对其进行编码，输出通过求和融合并送入一个 1 × 1 1\times1 1×1卷积，公式为 F x = C o n v 1 × 1 ( ∑ i = 0 2 C o n v 1 D i x ( N o r m ( F ) ) ) F_{x} = Conv_{1\times1}\left(\sum_{i = 0}^{2}Conv1D_{i}^{x}(Norm(F))\right) Fx​=Conv1×1​(∑i=02​Conv1Dix​(Norm(F)))，其中 C o n v 1 D i x ( ⋅ ) Conv1D_{i}^{x}(\cdot) Conv1Dix​(⋅)表示沿 x x x轴维度的1D卷积， N o r m ( ⋅ ) Norm(\cdot) Norm(⋅)是层归一化， F x F_{x} Fx​是输出。对于1D卷积的核大小，设置为 1 × 7 1\times7 1×7、 1 × 11 1\times11 1×11和 1 × 21 1\times21 1×21。底部分支的输出 F y F_{y} Fy​可通过类似方式得到。
    • 对于顶部分支的 F x F_{x} Fx​，将其送入 y y y轴注意力，为更好地利用来自两个空间方向的多尺度卷积特征，计算 F x F_{x} Fx​和 F y F_{y} Fy​之间的交叉注意力，具体将 F x F_{x} Fx​作为键和值矩阵， F y F_{y} Fy​作为查询矩阵，计算过程为 F T = M H C A y ( F y , F x , F x ) F_{T} = MHCA_{y}(F_{y}, F_{x}, F_{x}) FT​=MHCAy​(Fy​,Fx​,Fx​)，其中 M H C A y ( ⋅ , ⋅ , ⋅ ) MHCA_{y}(\cdot, \cdot, \cdot) MHCAy​(⋅,⋅,⋅)表示沿 x x x轴的多头交叉注意力。底部分支以类似方式编码沿 y y y轴方向的上下文，即 F B = M H C A x ( F x , F y , F y ) F_{B} = MHCA_{x}(F_{x}, F_{y}, F_{y}) FB​=MHCAx​(Fx​,Fy​,Fy​)，其中 M H C A x ( ⋅ , ⋅ , ⋅ ) MHCA_{x}(\cdot, \cdot, \cdot) MHCAx​(⋅,⋅,⋅)表示沿 y y y轴的多头交叉注意力。
    • MCA的输出为 F o u t = C o n v 1 × 1 ( F T ) + C o n v 1 × 1 ( F B ) + F F_{out} = Conv_{1\times1}(F_{T}) + Conv_{1\times1}(F_{B}) + F Fout​=Conv1×1​(FT​)+Conv1×1​(FB​)+F。

在这里插入图片描述

2.2 MCA的优势：

  1. 引入轻量级多尺度卷积：处理病变区域或器官各种大小和形状的有效方式。
  2. 创新的注意力机制：与大多数以前的工作不同，MCA不直接应用轴向注意力来捕获全局上下文，而是构建两个并行轴向注意力之间的交互，更有效地利用多尺度特征和全局上下文。
  3. 解码器轻量级：微小型号的模型参数数量仅为 0.14 M 0.14M 0.14M，更适合实际应用场景。

论文：https://arxiv.org/pdf/2312.08866v1
源码：https://github.com/haoshao-nku/medical_seg

三、MCA的实现代码

MCA模块的实现代码如下：

class StdPool(nn.Module) :
    def __init__(self):
        super(StdPool, self).__init__()
    def forward (self, x):
        b, c, _, _ = x.size()
        std = x.view(b, c, -1).std(dim=2, keepdim=True)
        std = std.reshape(b, c, 1, 1)
        return std
        
class MCAGate (nn.Module):
    def __init__(self, k_size, pool_types=['avg', 'std']):
 
        super(MCAGate, self).__init__()
        self.pools = nn.ModuleList([])
        for pool_type in pool_types:
            if pool_type == 'avg':
                self.pools.append(nn.AdaptiveAvgPool2d(1))
            elif pool_type == 'max':
                self.pools.append(nn.AdaptiveMaxPool2d(1))
            elif pool_type == 'std':
                self.pools.append(StdPool())
            else:
                raise NotImplementedError
 
        self.conv = nn.Conv2d(1, 1, kernel_size=(1, k_size),  stride=1, padding=(0, (k_size - 1) // 2), bias=False)
        self.sigmoid = nn.Sigmoid()
        self.weight = nn.Parameter(torch.rand(2))
 
    def forward(self, x):
        feats = [pool(x) for pool in self.pools]
 
        if len(feats) == 1:
            out = feats[0]
        elif len(feats) == 2:
            weight = torch.sigmoid(self.weight)
            out = 1/2*(feats[0] + feats[1]) + weight[0] * feats[0] + weight[1] * feats[1]
        else:
            assert False, "特征提取异常"
 
        out = out.permute(0, 3, 2, 1).contiguous()
        out = self.conv(out)
        out = out.permute(0, 3, 2, 1).contiguous()
 
        out = self.sigmoid(out)
        out = out.expand_as(x)
 
        return x * out
 
class MCA(nn.Module):
    def __init__(self, channel, no_spatial=False): 
        """Constructs a MCA module.
        Args:
            inp: Number of channels of the input feature maps
            no_spatial: whether to build channel dimension interactions
        """
        super(MCA, self).__init__()
        lambd = 1.5
        gamma = 1
        temp = round(abs((math.log2(channel) - gamma) / lambd))
        kernel = temp if temp % 2 else temp - 1
 
        self.h_cw = MCAGate(3)
        self.w_hc = MCAGate(3)
        self.no_spatial = no_spatial
        if not no_spatial:
            self.c_hw = MCAGate(kernel)
 
    def forward(self, x):
        x_h = x.permute(0, 2, 1, 3).contiguous()
        x_h = self.h_cw(x_h)
        x_h = x_h.permute(0, 2, 1, 3).contiguous() 
 
        x_w = x.permute(0, 3, 2, 1).contiguous()
        x_w = self.w_hc(x_w)
        x_w = x_w.permute(0, 3, 2, 1).contiguous() 
 
        if not self.no_spatial:   
            x_c = self.c_hw(x)
            x_out = 1 / 3 * (x_c + x_h + x_w)
        else:
            x_out = 1 / 2 * (x_h + x_w)
 
        return x_out

四、添加步骤

4.1 修改common.py

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

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

4.1.1 基础模块1

模块改进方法1️⃣：直接加入MCA模块。
MCA模块添加后如下：

在这里插入图片描述

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

4.1.2 创新模块2⭐

模块改进方法2️⃣：基于MCA模块的RepNCSPELAN4。

相较方法一中的直接插入注意力模块，利用注意力模块对卷积等其他模块进行改进，其新颖程度会更高一些，训练精度可能会表现的更高。

第二种改进方法是对YOLOv9中的RepNCSPELAN4模块进行改进，将MCA注意力模块替换RepNCSPELAN4中的卷积模块。MCA注意力模块通过构建了两个并行轴向注意力之间的交互，更有效地利用多尺度特征和全局上下文，在加入到RepNCSPELAN4模块后，能够更加契合目标形态，更有效的获取目标的全局信息。

改进代码如下：

class MCARepNCSPELAN4(nn.Module):
    # csp-elan
    def __init__(self, c1, c2, c3, c4, c5=1):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        self.c = c3//2
        self.cv1 = Conv(c1, c3, 1, 1)
        self.cv2 = nn.Sequential(RepNCSP(c3//2, c4, c5), MCA(c4))
        self.cv3 = nn.Sequential(RepNCSP(c4, c4, c5), MCA(c4))
        self.cv4 = Conv(c3+(2*c4), c2, 1, 1)

    def forward(self, x):
        y = list(self.cv1(x).chunk(2, 1))
        y.extend((m(y[-1])) for m in [self.cv2, self.cv3])
        return self.cv4(torch.cat(y, 1))

    def forward_split(self, x):
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in [self.cv2, self.cv3])
        return self.cv4(torch.cat(y, 1))

在这里插入图片描述

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

4.2 修改yolo.py

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

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

MCA模块以及MCARepNCSPELAN4模块添加后如下：

在这里插入图片描述

五、yaml模型文件

5.1 模型改进版本一

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

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

将yolov9-c.yaml中的内容复制到yolov9-c-MCA.yaml文件下，修改nc数量等于自己数据中目标的数量。
在骨干网络的最后一层添加MCA模块，只需要填入一个参数，通道数。

# 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, Conv, [64, 3, 2]],  # 1-P1/2

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

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

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

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

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

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

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

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

   [-1, 1, MCA, [512]],  # 10  # 注意力添加在此处
  ]

# 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, 14], 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, 11], 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
   [[24, 25, 26, -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
   [[25, 26, -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
   [[26, -1], 1, CBFuse, [[2]]], # 36

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

   # detect
   [[32, 35, 38, 17, 20, 23], 1, DualDDetect, [nc]],  # DualDDetect(A3, A4, A5, P3, P4, P5)
  ]

5.2 模型改进版本二⭐

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

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

📌 模型的修改方法是将骨干网络中的所有RepNCSPELAN4模块替换成MCARepNCSPELAN4模块。

# 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, Conv, [64, 3, 2]],  # 1-P1/2

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

   # elan-1 block
   [-1, 1, MCARepNCSPELAN4, [256, 128, 64, 1]],  # 3

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

   # elan-2 block
   [-1, 1, MCARepNCSPELAN4, [512, 256, 128, 1]],  # 5

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

   # elan-2 block
   [-1, 1, MCARepNCSPELAN4, [512, 512, 256, 1]],  # 7

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

   # elan-2 block
   [-1, 1, MCARepNCSPELAN4, [512, 512, 256, 1]],  # 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)
  ]

六、成功运行结果

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

yolov9-c-MCA：

                 from  n    params  module                                  arguments                     
  0                -1  1         0  models.common.Silence                   []                            
  1                -1  1      1856  models.common.Conv                      [3, 64, 3, 2]                 
  2                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  3                -1  1    212864  models.common.RepNCSPELAN4              [128, 256, 128, 64, 1]        
  4                -1  1    164352  models.common.ADown                     [256, 256]                    
  5                -1  1    847616  models.common.RepNCSPELAN4              [256, 512, 256, 128, 1]       
  6                -1  1    656384  models.common.ADown                     [512, 512]                    
  7                -1  1   2857472  models.common.RepNCSPELAN4              [512, 512, 512, 256, 1]       
  8                -1  1    656384  models.common.ADown                     [512, 512]                    
  9                -1  1   2857472  models.common.RepNCSPELAN4              [512, 512, 512, 256, 1]       
 10                -1  1        10  models.common.MCA                       [512, 512]                    
 11                -1  1    656896  models.common.SPPELAN                   [512, 512, 256]               
 12                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 13           [-1, 7]  1         0  models.common.Concat                    [1]                           
 14                -1  1   3119616  models.common.RepNCSPELAN4              [1024, 512, 512, 256, 1]      
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']          
 16           [-1, 5]  1         0  models.common.Concat                    [1]                           
 17                -1  1    912640  models.common.RepNCSPELAN4              [1024, 256, 256, 128, 1]      
 18                -1  1    164352  models.common.ADown                     [256, 256]                    
 19          [-1, 14]  1         0  models.common.Concat                    [1]                           
 20                -1  1   2988544  models.common.RepNCSPELAN4              [768, 512, 512, 256, 1]       
 21                -1  1    656384  models.common.ADown                     [512, 512]                    
 22          [-1, 11]  1         0  models.common.Concat                    [1]                           
 23                -1  1   3119616  models.common.RepNCSPELAN4              [1024, 512, 512, 256, 1]      
 24                 5  1    131328  models.common.CBLinear                  [512, [256]]                  
 25                 7  1    393984  models.common.CBLinear                  [512, [256, 512]]             
 26                 9  1    656640  models.common.CBLinear                  [512, [256, 512, 512]]        
 27                 0  1      1856  models.common.Conv                      [3, 64, 3, 2]                 
 28                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
 29                -1  1    212864  models.common.RepNCSPELAN4              [128, 256, 128, 64, 1]        
 30                -1  1    164352  models.common.ADown                     [256, 256]                    
 31  [24, 25, 26, -1]  1         0  models.common.CBFuse                    [[0, 0, 0]]                   
 32                -1  1    847616  models.common.RepNCSPELAN4              [256, 512, 256, 128, 1]       
 33                -1  1    656384  models.common.ADown                     [512, 512]                    
 34      [25, 26, -1]  1         0  models.common.CBFuse                    [[1, 1]]                      
 35                -1  1   2857472  models.common.RepNCSPELAN4              [512, 512, 512, 256, 1]       
 36                -1  1    656384  models.common.ADown                     [512, 512]                    
 37          [26, -1]  1         0  models.common.CBFuse                    [[2]]                         
 38                -1  1   2857472  models.common.RepNCSPELAN4              [512, 512, 512, 256, 1]       
 39[32, 35, 38, 17, 20, 23]  1  21542822  DualDDetect                             [1, [512, 512, 512, 256, 512, 512]]
yolov9-c-MCA summary: 975 layers, 50999600 parameters, 50999568 gradients, 238.9 GFLOPs

yolov9-c-MCARepNCSPELAN4：

                 from  n    params  module                                  arguments                     
  0                -1  1         0  models.common.Silence                   []                            
  1                -1  1      1856  models.common.Conv                      [3, 64, 3, 2]                 
  2                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]               
  3                -1  1    138910  models.common.MCARepNCSPELAN4           [128, 256, 128, 64, 1]        
  4                -1  1    164352  models.common.ADown                     [256, 256]                    
  5                -1  1    552222  models.common.MCARepNCSPELAN4           [256, 512, 256, 128, 1]       
  6                -1  1    656384  models.common.ADown                     [512, 512]                    
  7                -1  1   1676834  models.common.MCARepNCSPELAN4           [512, 512, 512, 256, 1]       
  8                -1  1    656384  models.common.ADown                     [512, 512]                    
  9                -1  1   1676834  models.common.MCARepNCSPELAN4           [512, 512, 512, 256, 1]       
 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   3119616  models.common.RepNCSPELAN4              [1024, 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    912640  models.common.RepNCSPELAN4              [1024, 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    131328  models.common.CBLinear                  [512, [256]]                  
 24                 7  1    393984  models.common.CBLinear                  [512, [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  DualDDetect                             [1, [512, 512, 512, 256, 512, 512]]
yolov9-c-MCARepNCSPELAN4 summary: 1090 layers, 48268966 parameters, 48268934 gradients, 226.6 GFLOPs

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2148678.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

2.4 卷积2

2.4 卷积2

2.4.2 复正弦波与整体方案 在2.3节中，我们提出了关于复正弦输入的频域输出及其意义的两个问题。为了研究这些问题，我们让一个具有真实脉冲响应 h [ n ] h[n] h[n]（即 h Q [ n ] 0 h_Q[n] 0 hQ​[n]0）的LTI系统通过输入复正弦…
阅读更多...
数据结构（Day16）

数据结构（Day16）

一、学习内容 1、有关顺序表的操作（功能函数） 1、创建顺序表 Plist create_list(){Plist L malloc(sizeof(list)); // 为顺序表分配内存空间if(NULL L){printf("申请空间失败\n");return NULL; // 如果内存分配失败，返回 NU…
阅读更多...
RTMP协议在无人机巡检中的应用场景

RTMP协议在无人机巡检中的应用场景

为什么要用无人机巡检 好多开发者对无人机巡检技术方案，相对陌生，实际上，无人机巡检就是利用无人机对特定区域或设施进行定期或不定期的检查。这种巡检方式相比传统的人工巡检具有显著的优势，包括速度快、覆盖广、风险低、准确性…
阅读更多...
Tornado 是一个 Python 异步网络库和 web 框架

Tornado 是一个 Python 异步网络库和 web 框架

Tornado 是一个 Python 异步网络库和 web 框架，它最初由 FriendFeed 开发，后来被 Facebook 收购并开源。Tornado 因其非阻塞的 I/O 操作和优秀的性能而广受欢迎，特别是在需要处理大量并发连接的应用中。Tornado 的底层实现主要依赖于 Python …
阅读更多...
神经网络通俗理解学习笔记(0) numpy、matplotlib

神经网络通俗理解学习笔记(0) numpy、matplotlib

Numpy numpynumpy 基本介绍Ndarray对象及其创建Numpy数组的基础索引numpy数组的合并与拆分（重要）numpy数组的矩阵运算Numpy数组的统计运算numpy中的arg运算numpy中的神奇索引和比较 Matplotlib numpy numpy 基本介绍 numpy 大多数机器学习库都用了这个…
阅读更多...
【Linux入门】基本指令（一）

【Linux入门】基本指令（一）

目录 一.使用环境 二.快捷键 三. 登录与用户管理 1.ssh root[ip地址] 2.whoami 3.ls /home 4.adduser [用户名] 5.passwd [用户名] 四.目录文件操作 1.ls 2.pwd 3.cd 4.touch 5.mkdir 6.rm 7.cp 五.命令手册 一.使用环境 云服务器：市面上有很多&am…
阅读更多...
Python 中的 typing 模块常见用法

Python 中的 typing 模块常见用法

typing 模块是 Python 提供的一个标准库，主要用于为函数、变量和类定义类型提示（Type Hints），从而提高代码的可读性和类型安全性。虽然 Python 是动态类型语言，但通过 typing 模块，开发者可以明确指定变量和…
阅读更多...
TMStarget学习——Functional Connectivity

TMStarget学习——Functional Connectivity

今天基于结构像和功能像数据试验操作TMStarget 的第二个功能模块Functional Connectivity。参考季老师的文档PPT来学习的，整个处理过程蛮长的，可能配置原因一路上报错也比较多，下面还是逐步记录吧，后面采用连更的方式直到跑通后再…
阅读更多...
C++ 中的继承（详细讲解）

C++ 中的继承（详细讲解）

一、继承的概念以及定义 1、继承概念 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保 持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象 程序设计的…
阅读更多...
微波无源器件 功分器 4 一种用于天线阵列的紧凑宽带四路双极化波导功分器

微波无源器件 功分器 4 一种用于天线阵列的紧凑宽带四路双极化波导功分器

摘要： 一种新型紧凑和高效率，在一个同相2x4方案(四路)显示双极化的功分器的设计和仿真被提出了，两个基本的正交模式TE10和TE01在四个方波导处同相输出通过使用四个3端口个四个E面和两个H面功分结构。此功分末端接了两个商用波导(WR75)端口&am…
阅读更多...
青柠视频云——如何开启HTTPS服务?

青柠视频云——如何开启HTTPS服务?

前言 由于青柠视频云的语音对讲会使用到HTTPS服务，这里我们说一下如何申请证书以及如何在实战中部署并且配置使用。 一、证书申请 1、进入控制台 我们拿阿里云的免费个人证书为例，首先登录阿里云，在控制台找到数字证书管理服务，进…
阅读更多...
膨胀罐选型计算和其他事项

膨胀罐选型计算和其他事项

膨胀罐，也称定压罐、气压罐，广泛应用于空调、太阳能、锅炉等暖通系统以及供水和消防设备，缓冲系统压力波动，消除水锤，起到稳压卸荷的作用。在空调、太阳能、锅炉、地暖等闭式循环系统中，膨胀罐的作用是在工…
阅读更多...
3.数据类型

3.数据类型

作业系统链接 Python 是一门面向对象友好的语言，支持多种内置数据类型，包括整数（int）、浮点数（float）、布尔值（bool）、字符串（str）、列表（list&am…
阅读更多...
直流电表如何在新能源领域进行应用

直流电表如何在新能源领域进行应用

直流电表在新能源领域的应用广泛且深入，其高精度、实时监测和数据分析能力为新能源系统的运行、管理和优化提供了重要支持。 一、太阳能光伏发电系统 在太阳能光伏发电系统中，直流电表扮演着至关重要的角色。太阳能电池板将光能转化为直流电能&#xf…
阅读更多...
.NET 一直跻身 30 大Github最活跃开源项目之列。

.NET 一直跻身 30 大Github最活跃开源项目之列。

大家好，我是编程乐趣。 一直以来都在介绍.Net的热门开源项目，今天来说说.Net本身。 .Net在GitHub上也是一个开源项目，.NET 是一个由 Microsoft 和 .NET 社区共同维护的开源跨平台框架。 自 2017 年以来，.NET 一直是 GitHub 上最…
阅读更多...
新手教学系列——非正常关机导致MySQL权限表（db）损坏及修复详解

新手教学系列——非正常关机导致MySQL权限表（db）损坏及修复详解

在使用MySQL的过程中，我们常常会遇到一些问题，尤其是当服务器或主机非正常关机或重启时，MySQL的某些表，特别是权限表（如 mysql.db 表），可能会损坏，导致数据库无法启动或访问。这种情况对生产环境的数据库系统来说是相当严重的，因此掌握修复方法非常重要。 本篇文章将…
阅读更多...
分享两个ADG监控脚本

分享两个ADG监控脚本

分享两个监控脚本，用于监控Oracle ADG的状态，如果状态异常则发送邮件告警 脚本一： 利用语句查询日志的应用状态，如果长时间未应用则邮件告警，提醒DBA检查ADG的状态是否异常； 阈值条件：最近一…
阅读更多...
关于用matplotlib.pyplot加载图片颜色不对的解决方法

关于用matplotlib.pyplot加载图片颜色不对的解决方法

1.原理：用opencv加载的图片是BGR存储的。而用matplotlib.pyplot 需要RGB的格式,故在加载之前使用下面的语句改成RGB格式。 img2 cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # 或使用 # img2 img[:, :, ::-1]#将图像img的颜色通道进行反转。 ::-1 表示在最后一个维度…
阅读更多...
财富通公司开发维修售后小程序，解决售后维修问题

财富通公司开发维修售后小程序，解决售后维修问题

财富通公司为广大用户开发的维修售后小程序，旨在便捷地解决售后维修问题，提升用户体验，增强客户粘性。以下是该小程序如何具体解决售后维修问题的几个关键点： 一. 一站式报修流程 1.简化操作：用户只需通过小程序几步…
阅读更多...
智能监控-智能管理系统解决方案

智能监控-智能管理系统解决方案

一、引言 在数字化浪潮席卷全球的今天，智能化管理已成为各行业不可或缺的一部分。物联网智能监控管理系统解决方案，凭借其强大的功能性和易用性，为网络传输、环境监测及安全控制提供了全面的智能管理手段。该系统集成了I/O网络模块、高精度传…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023