YOLOv5改进 | 模块缝合 | C3 融合RFCAConv增强感受野空间特征 【二次融合 小白必备】

news2024/11/13 9:35:42

秋招面试专栏推荐 :深度学习算法工程师面试问题总结【百面算法工程师】——点击即可跳转


💡💡💡本专栏所有程序均经过测试,可成功执行💡💡💡


专栏目录 :《YOLOv5入门 + 改进涨点》专栏介绍 & 专栏目录 |目前已有80+篇内容,内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进


空间注意力虽提高卷积神经网络性能,但有局限。本文介绍了感受野注意力(RFA)新机制,解决大尺寸卷积核参数共享问题RFA关注感受野空间特征,为大型卷积核提供有效权重。RFAConv操作几乎不增加计算成本,显著提升网络性能。文章在介绍主要的原理后,将手把手教学如何进行模块的代码添加和修改,并将修改后的完整代码放在文章的最后,方便大家一键运行,小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

专栏地址 YOLOv5改进+入门——持续更新各种有效涨点方法 点击即可跳转 

目录

1.原理 

2. 将C3_RFCAConv添加到yolov5网络中

2.1 C3_RFCAConv代码实现

 2.2 C3_RFCAConv的神经网络模块代码解析

2.3 新增yaml文件

2.4 注册模块

2.5 执行程序

3. 完整代码分享  

4. GFLOPs

5. 进阶

6. 总结


1.原理 

论文地址:RFAConv: Innovating Spatial Attention and Standard Convolutional Operation——点击即可跳转

官方代码:官方代码仓库——点击即可跳转

RFAConv(受体场注意卷积)是一种新颖的卷积运算,旨在解决标准卷积和现有空间注意机制的局限性,特别是在参数共享和大型卷积核方面。

RFAConv 背后的关键原则:

  1. 受体场空间特征:与专注于单个空间特征的传统空间注意不同,RFAConv 强调受体场空间特征,这些特征是根据卷积核的大小动态生成的。这种方法通过关注受体场内不同特征的重要性来增强特征提取。

  2. 解决参数共享问题:在标准卷积中,内核参数在整个输入中共享,限制了网络跨空间位置捕获不同信息的能力。RFAConv 通过将注意力机制与卷积相结合来解决此问题,为每个受体场创建非共享参数。

  3. 注意力机制集成:RFAConv 集成了一种注意力机制,该机制为接受场中的每个特征分配重要性,使网络能够专注于最重要的信息。此过程避免了 CBAM 和 CA 等传统注意力机制的局限性,这些机制在不同空间区域之间共享注意力权重。

  4. 高效轻量:尽管引入了注意力机制,但 RFAConv 仅增加了极少的计算开销和参数。它还使用组卷积等技术来高效提取接受场空间特征,使其适用于实时应用。

  5. 性能提升:通过解决空间注意力和卷积参数共享的局限性,RFAConv 增强了神经网络在分类、对象检测和分割等任务中的性能,在许多情况下优于 CBAM 和 CA 等其他基于注意力的方法。

综上所述,RFAConv 通过关注感受野空间特征进行创新,提供了一种更灵活、更强大的方法来替代标准卷积,同时保持效率并提高网络性能。

2. 将C3_RFCAConv添加到yolov5网络中

2.1 C3_RFCAConv代码实现

 关键步骤一 将下面的代码粘贴到\yolov5\models\common.py中


from einops import rearrange

class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6

class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)

class RFAConv(nn.Module):
    def __init__(self,in_channel,out_channel,kernel_size,stride=1):
        super().__init__()
        self.kernel_size = kernel_size

        self.get_weight = nn.Sequential(nn.AvgPool2d(kernel_size=kernel_size, padding=kernel_size // 2, stride=stride),
                                        nn.Conv2d(in_channel, in_channel * (kernel_size ** 2), kernel_size=1, groups=in_channel,bias=False))
        self.generate_feature = nn.Sequential(
            nn.Conv2d(in_channel, in_channel * (kernel_size ** 2), kernel_size=kernel_size,padding=kernel_size//2,stride=stride, groups=in_channel, bias=False),
            nn.BatchNorm2d(in_channel * (kernel_size ** 2)),
            nn.ReLU())
       
        # self.conv = nn.Sequential(nn.Conv2d(in_channel, out_channel, kernel_size=kernel_size, stride=kernel_size),
        #                           nn.BatchNorm2d(out_channel),
        #                           nn.ReLU())
        self.conv = Conv(in_channel, out_channel, k=kernel_size, s=kernel_size, p=0)

    def forward(self,x):
        b,c = x.shape[0:2]
        weight =  self.get_weight(x)
        h,w = weight.shape[2:]
        weighted = weight.view(b, c, self.kernel_size ** 2, h, w).softmax(2)  # b c*kernel**2,h,w ->  b c k**2 h w 
        feature = self.generate_feature(x).view(b, c, self.kernel_size ** 2, h, w)  #b c*kernel**2,h,w ->  b c k**2 h w  
        weighted_data = feature * weighted
        conv_data = rearrange(weighted_data, 'b c (n1 n2) h w -> b c (h n1) (w n2)', n1=self.kernel_size, # b c k**2 h w ->  b c h*k w*k
                              n2=self.kernel_size)
        return self.conv(conv_data)


class SE(nn.Module):
    def __init__(self, in_channel, ratio=16):
        super(SE, self).__init__()
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        self.fc = nn.Sequential(
            nn.Linear(in_channel, ratio, bias=False),  # 从 c -> c/r
            nn.ReLU(),
            nn.Linear(ratio, in_channel, bias=False),  # 从 c/r -> c
            nn.Sigmoid()
        )
 
    def forward(self, x):
            b, c= x.shape[0:2]
            y = self.gap(x).view(b, c)
            y = self.fc(y).view(b, c,1, 1)
            return y


class RFCBAMConv(nn.Module):
    def __init__(self,in_channel,out_channel,kernel_size=3,stride=1):
        super().__init__()
        if kernel_size % 2 == 0:
            assert("the kernel_size must be  odd.")
        self.kernel_size = kernel_size
        self.generate = nn.Sequential(nn.Conv2d(in_channel,in_channel * (kernel_size**2),kernel_size,padding=kernel_size//2,
                                                stride=stride,groups=in_channel,bias =False),
                                      nn.BatchNorm2d(in_channel * (kernel_size**2)),
                                      nn.ReLU()
                                      )
        self.get_weight = nn.Sequential(nn.Conv2d(2,1,kernel_size=3,padding=1,bias=False),nn.Sigmoid())
        self.se = SE(in_channel)

        # self.conv = nn.Sequential(nn.Conv2d(in_channel,out_channel,kernel_size,stride=kernel_size),nn.BatchNorm2d(out_channel),nn.ReLu())
        self.conv = Conv(in_channel, out_channel, k=kernel_size, s=kernel_size, p=0)
        
    def forward(self,x):
        b,c = x.shape[0:2]
        channel_attention =  self.se(x)
        generate_feature = self.generate(x)

        h,w = generate_feature.shape[2:]
        generate_feature = generate_feature.view(b,c,self.kernel_size**2,h,w)
        
        generate_feature = rearrange(generate_feature, 'b c (n1 n2) h w -> b c (h n1) (w n2)', n1=self.kernel_size,
                              n2=self.kernel_size)
        
        unfold_feature = generate_feature * channel_attention
        max_feature,_ = torch.max(generate_feature,dim=1,keepdim=True)
        mean_feature = torch.mean(generate_feature,dim=1,keepdim=True)
        receptive_field_attention = self.get_weight(torch.cat((max_feature,mean_feature),dim=1))
        conv_data = unfold_feature  * receptive_field_attention
        return self.conv(conv_data)

class RFCAConv(nn.Module):
    def __init__(self, inp, oup, kernel_size, stride=1, reduction=32):
        super(RFCAConv, self).__init__()
        self.kernel_size = kernel_size
        self.generate = nn.Sequential(nn.Conv2d(inp,inp * (kernel_size**2),kernel_size,padding=kernel_size//2,
                                                stride=stride,groups=inp,
                                                bias =False),
                                      nn.BatchNorm2d(inp * (kernel_size**2)),
                                      nn.ReLU()
                                      )
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))

        mip = max(8, inp // reduction)

        self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(mip)
        self.act = h_swish()
        
        self.conv_h = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)
        self.conv_w = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)
        self.conv = nn.Sequential(nn.Conv2d(inp,oup,kernel_size,stride=kernel_size))
        

    def forward(self, x):
        b,c = x.shape[0:2]
        generate_feature = self.generate(x)
        h,w = generate_feature.shape[2:]
        generate_feature = generate_feature.view(b,c,self.kernel_size**2,h,w)
        
        generate_feature = rearrange(generate_feature, 'b c (n1 n2) h w -> b c (h n1) (w n2)', n1=self.kernel_size,
                              n2=self.kernel_size)
        
        x_h = self.pool_h(generate_feature)
        x_w = self.pool_w(generate_feature).permute(0, 1, 3, 2)

        y = torch.cat([x_h, x_w], dim=2)
        y = self.conv1(y)
        y = self.bn1(y)
        y = self.act(y) 
        
        h,w = generate_feature.shape[2:]
        x_h, x_w = torch.split(y, [h, w], dim=2)
        x_w = x_w.permute(0, 1, 3, 2)

        a_h = self.conv_h(x_h).sigmoid()
        a_w = self.conv_w(x_w).sigmoid()
        return self.conv(generate_feature * a_w * a_h)

class Bottleneck_RFAConv(Bottleneck):
    """Standard bottleneck with RFAConv."""

    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):  # ch_in, ch_out, shortcut, groups, kernels, expand
        super().__init__(c1, c2, shortcut, g, k, e)
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = RFAConv(c_, c2, k[1])

class C3_RFAConv(C3):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(Bottleneck_RFAConv(c_, c_, shortcut, g, k=(1, 3), e=1.0) for _ in range(n)))

class Bottleneck_RFCBAMConv(Bottleneck):
    """Standard bottleneck with RFCBAMConv."""

    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):  # ch_in, ch_out, shortcut, groups, kernels, expand
        super().__init__(c1, c2, shortcut, g, k, e)
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = RFCBAMConv(c_, c2, k[1])

class C3_RFCBAMConv(C3):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(Bottleneck_RFCBAMConv(c_, c_, shortcut, g, k=(1, 3), e=1.0) for _ in range(n)))

class Bottleneck_RFCAConv(Bottleneck):
    """Standard bottleneck with RFCBAMConv."""

    def __init__(self, c1, c2, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, shortcut, groups, kernels, expand
        super().__init__(c1, c2, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1)
        self.cv2 = RFCAConv(c_, c2, 3)

class C3_RFCAConv(C3):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        c_ = int(c2 * e)  # hidden channels
        self.m = nn.Sequential(*(Bottleneck_RFCAConv(c_, c_, shortcut, g, e=1.0) for _ in range(n)))

2.2 C3_RFCAConv的神经网络模块代码解析

1. RFAConv 模块

RFAConv 是一种基于动态卷积的模块,它的核心思想是根据输入生成卷积核权重并应用于特征图上,具备空间自适应特性。

  • get_weight:

    • 先通过 AvgPool2d 池化和 Conv2d 来生成与输入特征图相匹配的权重,这些权重控制卷积核在不同空间位置的响应。

  • generate_feature:

    • 通过深度可分离卷积生成多个特征图(数量为卷积核的大小平方倍),每个特征图捕获不同的局部信息。

  • weighted_data:

    • 权重和生成的特征图通过 softmax 进行加权,并通过 rearrange 操作进行重构,最终输出的特征图经过卷积层得到输出。这一操作类似于对每个空间位置应用不同的卷积核(动态卷积)。

2. SE 模块

SE(Squeeze-and-Excitation)模块是一种经典的通道注意力机制。

  • gap (Global Average Pooling): 对特征图的每个通道进行全局平均池化,得到每个通道的全局信息。

  • fc (Fully Connected): 通过两个全连接层,对特征图通道进行缩放。它先将特征图的通道数缩小,再恢复为原始通道数,并通过 Sigmoid 激活生成注意力权重。

  • 最终,SE模块会对输入的每个通道进行重新加权,增强重要通道,抑制无关通道。

3. RFCAConv 模块

RFCAConv 模块是 RFAConvCA(Coordinate Attention)的结合体,结合了动态卷积与坐标注意力。

  • generate: 使用深度可分离卷积生成多个特征图。

  • pool_hpool_w: 类似于 CA 注意力机制,分别在高度和宽度维度进行全局平均池化,捕捉每个方向上的全局信息。

  • conv1: 将池化后的特征通过 1x1 卷积和激活函数进行处理,然后将其分成高度和宽度两个部分。

  • conv_hconv_w: 分别生成高度和宽度的注意力权重(通过 Sigmoid),这些权重会用来调整特征图的空间表示,类似于 CA 中的注意力机制。

  • 输出: 将生成的特征图与高度和宽度的注意力权重相乘,提升空间上的特征表达能力,最终通过卷积层输出。

4. Bottleneck_RFAConv 模块

这是标准的瓶颈结构结合了 RFAConv。其中:

  • cv1: 用标准卷积进行初始特征提取。

  • cv2: 用 RFAConv 替换标准的第二层卷积,利用其动态卷积特性,增强空间信息的表达。

5. C3_RFCAConv 模块

这个模块基于 C3 结构,使用了 Bottleneck_RFCAConv,在其瓶颈结构中引入了 RFCAConv,从而结合了动态卷积和坐标注意力机制。


总结

  • RFAConv 主要实现了动态卷积,能够根据输入自适应调整卷积核的权重。

  • RFCAConv 则结合了 RFAConvCoordinate Attention,通过坐标注意力机制增强了特征的空间表达。

  • Bottleneck_RFAConv 模块是将这些卷积整合到标准的神经网络结构中,增强了其特征提取能力。

这些模块的设计思想是为了提升模型的感受野和空间感知能力,同时通过注意力机制增强特征选择性。

2.3 新增yaml文件

关键步骤二在下/yolov5/models下新建文件 yolov5_C3_RFCAConv.yaml并将下面代码复制进去

  • 目标检测yaml文件 
# Ultralytics YOLOv5 🚀, AGPL-3.0 license

# Parameters
nc: 80 # number of classes
depth_multiple: 1.0 # model depth multiple
width_multiple: 1.0 # layer channel multiple
anchors:
  - [10, 13, 16, 30, 33, 23] # P3/8
  - [30, 61, 62, 45, 59, 119] # P4/16
  - [116, 90, 156, 198, 373, 326] # P5/32

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

# YOLOv5 v6.0 head
head: [
    [-1, 1, Conv, [512, 1, 1]],
    [-1, 1, nn.Upsample, [None, 2, "nearest"]],
    [[-1, 6], 1, Concat, [1]], # cat backbone P4
    [-1, 3, C3, [512, False]], # 13

    [-1, 1, Conv, [256, 1, 1]],
    [-1, 1, nn.Upsample, [None, 2, "nearest"]],
    [[-1, 4], 1, Concat, [1]], # cat backbone P3
    [-1, 3, C3, [256, False]], # 17 (P3/8-small)

    [-1, 1, Conv, [256, 3, 2]],
    [[-1, 14], 1, Concat, [1]], # cat head P4
    [-1, 3, C3, [512, False]], # 20 (P4/16-medium)

    [-1, 1, Conv, [512, 3, 2]],
    [[-1, 10], 1, Concat, [1]], # cat head P5
    [-1, 3, C3, [1024, False]], # 23 (P5/32-large)

    [[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)
  ]
  • 语义分割yaml文件
# Ultralytics YOLOv5 🚀, AGPL-3.0 license

# Parameters
nc: 80 # number of classes
depth_multiple: 1.0 # model depth multiple
width_multiple: 1.0 # layer channel multiple
anchors:
  - [10, 13, 16, 30, 33, 23] # P3/8
  - [30, 61, 62, 45, 59, 119] # P4/16
  - [116, 90, 156, 198, 373, 326] # P5/32

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

# YOLOv5 v6.0 head
head: [
    [-1, 1, Conv, [512, 1, 1]],
    [-1, 1, nn.Upsample, [None, 2, "nearest"]],
    [[-1, 6], 1, Concat, [1]], # cat backbone P4
    [-1, 3, C3, [512, False]], # 13

    [-1, 1, Conv, [256, 1, 1]],
    [-1, 1, nn.Upsample, [None, 2, "nearest"]],
    [[-1, 4], 1, Concat, [1]], # cat backbone P3
    [-1, 3, C3, [256, False]], # 17 (P3/8-small)

    [-1, 1, Conv, [256, 3, 2]],
    [[-1, 14], 1, Concat, [1]], # cat head P4
    [-1, 3, C3, [512, False]], # 20 (P4/16-medium)

    [-1, 1, Conv, [512, 3, 2]],
    [[-1, 10], 1, Concat, [1]], # cat head P5
    [-1, 3, C3, [1024, False]], # 23 (P5/32-large)

    [[17, 20, 23], 1, Segment, [nc, anchors, 32, 256]], # Segment (P3, P4, P5)
  ]

温馨提示:本文只是对yolov5基础上添加模块,如果要对yolov5n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。


# YOLOv5n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
 
# YOLOv5s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
 
# YOLOv5l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
 
# YOLOv5m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
 
# YOLOv5x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple

2.4 注册模块

关键步骤三在yolo.py的parse_model函数替换添加C3_RFCAConv

2.5 执行程序

在train.py中,将cfg的参数路径设置为yolov5_C3_RFCAConv.yaml的路径

建议大家写绝对路径,确保一定能找到

 🚀运行程序,如果出现下面的内容则说明添加成功🚀    

                 from  n    params  module                                  arguments
  0                -1  1      7040  models.common.Conv                      [3, 64, 6, 2, 2]
  1                -1  1     73984  models.common.Conv                      [64, 128, 3, 2]
  2                -1  3    180808  models.common.C3_RFCAConv               [128, 128, 3]
  3                -1  1    295424  models.common.Conv                      [128, 256, 3, 2]
  4                -1  6   1213584  models.common.C3_RFCAConv               [256, 256, 6]
  5                -1  1   1180672  models.common.Conv                      [256, 512, 3, 2]
  6                -1  9   6719704  models.common.C3_RFCAConv               [512, 512, 9]
  7                -1  1   4720640  models.common.Conv                      [512, 1024, 3, 2]
  8                -1  3  10199184  models.common.C3_RFCAConv               [1024, 1024, 3]
  9                -1  1   2624512  models.common.SPPF                      [1024, 1024, 5]
 10                -1  1    525312  models.common.Conv                      [1024, 512, 1, 1]
 11                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']
 12           [-1, 6]  1         0  models.common.Concat                    [1]
 13                -1  3   2757632  models.common.C3                        [1024, 512, 3, False]
 14                -1  1    131584  models.common.Conv                      [512, 256, 1, 1]
 15                -1  1         0  torch.nn.modules.upsampling.Upsample    [None, 2, 'nearest']
 16           [-1, 4]  1         0  models.common.Concat                    [1]
 17                -1  3    690688  models.common.C3                        [512, 256, 3, False]
 18                -1  1    590336  models.common.Conv                      [256, 256, 3, 2]
 19          [-1, 14]  1         0  models.common.Concat                    [1]
 20                -1  3   2495488  models.common.C3                        [512, 512, 3, False]
 21                -1  1   2360320  models.common.Conv                      [512, 512, 3, 2]
 22          [-1, 10]  1         0  models.common.Concat                    [1]
 23                -1  3   9971712  models.common.C3                        [1024, 1024, 3, False]
 24      [17, 20, 23]  1    457725  Detect                                  [80, [[10, 13, 16, 30, 33, 23], [30, 61, 62, 45, 59, 119], [116, 90, 156, 198, 373, 326]], [256, 512, 1024]]
YOLOv5_C3_RFCAConv summary: 641 layers, 47196349 parameters, 47196349 gradients, 114.3 GFLOPs

3. 完整代码分享  

https://pan.baidu.com/s/1aPhHxLJuM6zUp-it0KI78w?pwd=jncq

提取码: jncq 

4. GFLOPs

关于GFLOPs的计算方式可以查看:百面算法工程师 | 卷积基础知识——Convolution

未改进的GFLOPs

img

改进后的GFLOPs

5. 进阶

可以结合损失函数或者卷积模块进行多重改进

YOLOv5改进 | 损失函数 | EIoU、SIoU、WIoU、DIoU、FocuSIoU等多种损失函数——点击即可跳转

6. 总结

C3_RFCAConv模块结合了 C2f 结构和 RFCAConv卷积层的设计,旨在增强模型的特征提取能力,特别是在空间和通道维度上的表达。C3通过多分支结构将输入特征分解并逐层融合,提升了特征多样性,而 RFCAConv 引入了动态卷积和坐标注意力机制。具体来说,RFCAConv通过自适应地生成卷积核权重,实现了对不同空间位置的卷积操作优化,并通过在高度和宽度维度上分别进行全局池化,生成相应的注意力权重,提升了特征的空间感知能力。在 C3_RFCAConv中,多个 Bottleneck_RFCAConv模块被堆叠使用,每个模块对特征进行动态卷积和注意力增强,逐步融合和强化不同层次的特征信息,从而提高了模型的感受野和对重要特征的选择性,使其在处理复杂视觉任务时更加高效。

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

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

相关文章

飞牛fnOS安装KDE桌面

飞牛fnOS安装KDE桌面 这段时间新出的nas系统飞牛os真不错,基于debian的可折腾性又高了不少,今天就来给这个系统装个桌面,插上显示器也能当个电脑自己进自己的管理界面,播放下视频,上上网啥的。 文章目录 飞牛fnOS安装…

问卷调查,动静IP应该如何选择?

在探讨问卷调查这一领域时,选择使用动态IP还是静态IP,成为了许多从业者及市场研究者面临的重要决策,它不仅关乎数据收集的效率与质量,还直接影响到问卷调查的合法性与安全性。本文将从多个维度深入分析这两种IP类型的优劣&#xf…

python-网页自动化(三)

如果遇到使用 ajax 加载的网页,页面元素可能不是同时加载出来的,这个时候尝试在 get 方法执行完 成时获取网页源代码可能并非浏览器完全加载完成的页面。所以,这种情况下需要设置延时等待一定时间,确保全部节点都加载出来。 那么&…

每日一练8:dd爱框框(含链接)

1.链接 登录—专业IT笔试面试备考平台_牛客网 2.题目 3.代码 #include<iostream> #include<vector>using namespace std;const int N 1e7 5;int n,x;vector<int> v(N);int main() {cin >> n >> x;for(int i 0; i < n;i) cin >> v…

服务端性能测试:行业流行性能监控工具介绍

行业流行性能监控工具有哪些 Linux 自带命令 Vmstat&#xff0c;Top 等 Nmon Collectd InfluxDB Grafana Prometheus Grafana 行业流行性能监控工具的介绍 Linux 自带命令 Vmstat&#xff0c;Top 等 vmstat 和 top 都是 Linux 系统自带的命令&#xff0c;提供了实时的…

每日一练:轮转数组

一、题目要求 给定一个整数数组 nums&#xff0c;将数组中的元素向右轮转 k 个位置&#xff0c;其中 k 是非负数。 示例 1: 输入: nums [1,2,3,4,5,6,7], k 3 输出: [5,6,7,1,2,3,4] 解释: 向右轮转 1 步: [7,1,2,3,4,5,6] 向右轮转 2 步: [6,7,1,2,3,4,5] 向右轮转 3 步: …

hive时间函数

一、随机示例&#xff08;想到哪里写哪里&#xff09; 1.系统时间函数 查询 select current_timestamp --当前格式化时间,current_date --当前格式化日期,unix_timestamp() --当前unix时间戳 结果&#xff1a; 2.时间函数转换 查询 --将时间戳转化为格式化时间 sel…

微片水凝胶如何用于4D生物打印?快来了解一下!

大家好&#xff0c;今天我们来聊聊一项4D 活细胞生物打印技术——《Jammed Micro-Flake Hydrogel for 4D Living Cell Bioprinting》发表于《Advanced Materials》。在组织器官再生应用中&#xff0c;构建具有复杂几何形状和功能的载细胞结构至关重要。而水凝胶基4D生物墨水的发…

免费 U 盘数据恢复 - 用 4 种免费方法从随身U 盘恢复文件

如何在不使用软件的情况下从 USB 驱动器恢复已删除的文件&#xff1f;如何取消删除 USB 闪存驱动器&#xff1f;首先&#xff0c;不要对拇指驱动器进行任何进一步的更改。然后下载奇客数据恢复&#xff0c;这是一款免费的U 盘恢复工具&#xff0c;能够从各种问题中恢复笔式驱动…

网络层协议-ARP协议

网络层协议-ARP协议 1&#xff09;概述 ARP&#xff1a;地址解析协议&#xff0c;作用&#xff1a;根据IP地址查询MAC地址 数据包发送前需要进行封包&#xff0c;在数据链路层需要封装源mac地址是自己的mac&#xff0c;目的mac地址是别人&#xff0c;但是不知道别人的mac地址…

西门子WinCC开发笔记(一):winCC西门子组态软件介绍、安装

文为原创文章&#xff0c;转载请注明原文出处 本文章博客地址&#xff1a;https://hpzwl.blog.csdn.net/article/details/142060535 长沙红胖子Qt&#xff08;长沙创微智科&#xff09;博文大全&#xff1a;开发技术集合&#xff08;包含Qt实用技术、树莓派、三维、OpenCV、Op…

C++11第三弹:lambda表达式 | 新的类功能 | 模板的可变参数

&#x1f308;个人主页&#xff1a; 南桥几晴秋 &#x1f308;C专栏&#xff1a; 南桥谈C &#x1f308;C语言专栏&#xff1a; C语言学习系列 &#x1f308;Linux学习专栏&#xff1a; 南桥谈Linux &#x1f308;数据结构学习专栏&#xff1a; 数据结构杂谈 &#x1f308;数据…

为什么RAG对下一代AI开发至关重要

RAG&#xff08;检索增强生成&#xff09;是一种突破性技术&#xff0c;它将信息检索与文本生成相结合&#xff0c;以提高人工智能系统的知识和准确性。利用 RAG 可以帮助开发人员确保应用程序响应具有最丰富的上下文和准确性&#xff0c;因为它可以访问原始模型训练之外的精选…

解决samba无权限创建文件问题

将我服务器利用samba工具映射到到电脑后&#xff0c;没有权限在特定的文件里写文件&#xff0c;比如在mcu这个文件夹里面没有写文件的权限。 查看mcu文件夹的用户属性&#xff0c;属于root属性。 rootzwzn2064-CVN-Z690D5-GAMING-PRO:/home/zwzn2064# ls -ll total 9714860 dr…

MySQL 自学笔记(入门基础篇,含示例)

目录 一、基础1.变量2.运算符 二、数据库与表1.创建数据库2.表的增删与修改&#xff08;1&#xff09;表的创建与删除&#xff08;2&#xff09;表的修改&#xff08;3&#xff09;其他指令 3.属性约束4.数据操作&#xff08;1&#xff09;数据更新&#xff08;2&#xff09;数…

Hive任务优化参数整理

Hive本身是个基于hdfs的结构化数据管理工具&#xff0c;虽然在后面的发展中允许底层接入其他的数据源&#xff0c;比如第三方数据服务这种基础架构&#xff0c;但是它从立意上来说&#xff0c;它不适合用来做高性能查询引擎&#xff0c;反而在传统离线数据仓库中它有着自身的优…

在连通无向图中寻找正反向各通过每条边一次的路径(中国邮递员问题)

在连通无向图中寻找正反向各通过每条边一次的路径(中国邮递员问题) 引言问题定义算法思路具体步骤第一步:找出所有奇度顶点第二步:将奇度顶点配对,并添加最短路径第三步:构造欧拉回路伪代码C语言实现引言 在图论中,中国邮递员问题(Chinese Postman Problem, CPP)是一…

高精度E4990A参数资料keysight是德e4990a阻抗分析仪

Keysight E4990A 阻抗分析仪的规格&#xff1a; 工作频率选项&#xff1a; 20 Hz 至 10 MHz20 Hz 至 20 MHz20 Hz 至 30 MHz20 Hz 至 50 MHz20 Hz 至 120 MHz选项分别为 010 / 020 / 030 / 050 / 120 测量参数&#xff1a;lZl、lYl、O、R、X、G、B、L、C、D、Q、复合 Z、复合…

DBA 的 AI 助手 | MySQL 清理 undo log 居然用了 10 个小时?

社区王牌专栏《一问一实验&#xff1a;AI 版》全新改版归来&#xff0c;得到了新老读者们的关注。其中不乏对 ChatDBA 感兴趣的读者前来咨询&#xff0c;表达了想试用体验 ChatDBA 的意愿&#xff0c;对此我们表示感谢 &#x1f91f;。 目前&#xff0c;ChatDBA 还在最后的准备…

keil调试技巧 keil中的debug调试技巧单片机调试技巧 定位单片机程序异常位置 定位程序异常错误原因计算程序执行时间多少

单片机常用调试技巧(B站UP分享) 如何查看程序运行时间 使用Event Recorder 组件 查看运行时间 https://blog.csdn.net/twx11213030422/article/details/114013796 https://blog.csdn.net/weixin_43866583/article/details/125874888?spm1001.2101.3001.6661.1&utm_med…