YOLOv8改进 | 模块缝合 | C2f融合多尺度表征学习模块 【含OD、RTDETR、OBB等yaml文件】

于 2024-08-29 13:23:00 发布
阅读量815 收藏 10
点赞数 20
文章标签： YOLO 深度学习 目标检测 面试 人工智能 python 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67647321/article/details/141675935
版权

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

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

专栏目录 ：《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有100+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进——点击即可跳转

本文介绍的Multi-Scale是基于不同核大小的卷积如何影响不同尺度对象的检测性能研究。其成果是一种新策略，可以显著增强实时目标检测器在多尺度特征表示上的能力。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。 

专栏地址：YOLOv8改进——更新各种有效涨点方法——点击即可跳转  

目录

1. 原理 

2. 将C2f_MSBlock添加到yolov8网络中

2.1 C2f_MSBlock代码实现

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

2.3 更改init.py文件

2.4 添加yaml文件

2.5 注册模块

2.6 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1. 原理 

论文地址：YOLO-MS: Rethinking Multi-Scale Representation Learning for Real-time Object Detection——点击即可跳转

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

多尺度块（MS-Block）是增强实时物体检测中多尺度特征表示能力的关键组件。以下是其主要原理的分解：

  1. 分层特征融合：MS-Block 采用受 Res2Net 模型启发的分层特征融合策略。它将输入特征图分成多个组，每个组单独处理。第一组不做任何修改就通过，而后续组则通过倒置瓶颈层处理，这些层涉及具有不同内核大小的深度卷积。这使网络能够有效地捕获多尺度特征。

  2. 带深度卷积的倒置瓶颈：MS-Block 使用带深度卷积的倒置瓶颈结构，而不是标准卷积。这种方法可以有效地使用大内核，从而增强了块捕获不同尺度特征的能力，而不会产生过多的计算成本。

  3. 通道交互：经过反向瓶颈层处理后，特征图被连接起来并通过 1x1 卷积。这最后一步促进了前面步骤中提取的不同尺度特征之间的交互，确保输出特征图包含丰富的多尺度表示。

  4. 多尺度表示效率：MS-Block 旨在平衡计算效率和捕获多尺度特征的能力。通过调整深度卷积中使用的分支数量和内核大小，可以优化该块以在对象检测任务中实现速度和准确性之间的更好权衡。

MS在实时对象检测中特别有用，因为速度和准确性都至关重要，因为它允许模型有效地学习和表示多个尺度的特征，同时保持较高的推理速度。

2. 将C2f_MSBlock添加到yolov8网络中

2.1 C2f_MSBlock代码实现

关键步骤一: 将下面代码粘贴到在/ultralytics/ultralytics/nn/modules/block.py中，并在该文件的__all__中添加“C2f_MSBlock”


class MSBlockLayer(nn.Module):
    def __init__(self, inc, ouc, k) -> None:
        super().__init__()
        
        self.in_conv = Conv(inc, ouc, 1)
        self.mid_conv = Conv(ouc, ouc, k, g=ouc)
        self.out_conv = Conv(ouc, inc, 1)
    
    def forward(self, x):
        return self.out_conv(self.mid_conv(self.in_conv(x)))

class MSBlock(nn.Module):
    def __init__(self, inc, ouc, kernel_sizes, in_expand_ratio=3., mid_expand_ratio=2., layers_num=3, in_down_ratio=2.) -> None:
        super().__init__()
        
        in_channel = int(inc * in_expand_ratio // in_down_ratio)
        self.mid_channel = in_channel // len(kernel_sizes)
        groups = int(self.mid_channel * mid_expand_ratio)
        self.in_conv = Conv(inc, in_channel)
        
        self.mid_convs = []
        for kernel_size in kernel_sizes:
            if kernel_size == 1:
                self.mid_convs.append(nn.Identity())
                continue
            mid_convs = [MSBlockLayer(self.mid_channel, groups, k=kernel_size) for _ in range(int(layers_num))]
            self.mid_convs.append(nn.Sequential(*mid_convs))
        self.mid_convs = nn.ModuleList(self.mid_convs)
        self.out_conv = Conv(in_channel, ouc, 1)
        
        self.attention = None
    
    def forward(self, x):
        out = self.in_conv(x)
        channels = []
        for i,mid_conv in enumerate(self.mid_convs):
            channel = out[:,i * self.mid_channel:(i+1) * self.mid_channel,...]
            if i >= 1:
                channel = channel + channels[i-1]
            channel = mid_conv(channel)
            channels.append(channel)
        out = torch.cat(channels, dim=1)
        out = self.out_conv(out)
        if self.attention is not None:
            out = self.attention(out)  
        return out

class C3_MSBlock(C3):
    def __init__(self, c1, c2, n=1, kernel_sizes=[1, 3, 3], in_expand_ratio=3., mid_expand_ratio=2., layers_num=3, in_down_ratio=2., 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(*(MSBlock(c_, c_, kernel_sizes, in_expand_ratio, mid_expand_ratio, layers_num, in_down_ratio) for _ in range(n)))

class C2f_MSBlock(C2f):
    def __init__(self, c1, c2, n=1, kernel_sizes=[1, 3, 3], in_expand_ratio=3., mid_expand_ratio=2., layers_num=3, in_down_ratio=2., shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(MSBlock(self.c, self.c, kernel_sizes, in_expand_ratio, mid_expand_ratio, layers_num, in_down_ratio) for _ in range(n))

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

这段代码实现了一个多尺度特征提取模块，分为三个主要类：MSBlockLayer、MSBlock 和 C2f_MSBlock。以下是每个类的详细解释：

1. MSBlockLayer 类

  • 功能: 实现一个基本的卷积层序列，用于处理特定尺度的特征图。

  • 构造函数参数:

    • inc: 输入通道数。

    • ouc: 输出通道数。

    • k: 卷积核大小。

  • 构造函数内容:

    • self.in_conv: 1x1卷积，用于调整输入通道数。

    • self.mid_conv: 使用深度可分离卷积（group convolution）的中间卷积层，卷积核大小为k。

    • self.out_conv: 1x1卷积，将通道数还原为输入通道数。

  • forward函数: 顺序执行in_conv、mid_conv 和 out_conv，返回处理后的特征图。

2. MSBlock 类

  • 功能: 实现一个多尺度特征块，包含多个 MSBlockLayer 组成的分支，每个分支对应不同的卷积核大小。

  • 构造函数参数:

    • inc: 输入通道数。

    • ouc: 输出通道数。

    • kernel_sizes: 卷积核大小的列表，用于指定每个分支的卷积核大小。

    • in_expand_ratio: 输入通道扩展倍率。

    • mid_expand_ratio: 中间通道扩展倍率。

    • layers_num: 每个分支中MSBlockLayer的层数。

    • in_down_ratio: 输入通道缩减倍率。

  • 构造函数内容:

    • in_channel: 计算扩展后的输入通道数。

    • self.mid_channel: 每个分支的通道数。

    • groups: 深度卷积的组数（与通道数有关）。

    • self.in_conv: 用于调整输入特征图通道数的卷积层。

    • self.mid_convs: 一个包含多个分支的模块列表，每个分支使用不同的卷积核大小。

    • self.out_conv: 用于将多分支输出融合成最终输出的1x1卷积。

    • self.attention: 暂时未使用的注意力机制模块。

  • forward函数: 先通过in_conv处理输入，然后在各个分支中进行特征提取，最后通过拼接和卷积生成输出。如果定义了注意力机制，还会对输出进行进一步处理。

3. C2f_MSBlock 类

  • 功能: 继承自 C2f 类，是一个容器类，用于在其中集成多个 MSBlock。

  • 构造函数参数:

    • c1: 输入通道数。

    • c2: 输出通道数。

    • n: MSBlock 的数量。

    • kernel_sizes: 卷积核大小的列表。

    • 其他参数 (in_expand_ratio, mid_expand_ratio, layers_num, in_down_ratio, shortcut, g, e): 用于配置 MSBlock 和 C2f 类的各种特性。

  • 构造函数内容:

    • self.m: 包含多个 MSBlock 的模块列表，每个 MSBlock 按照指定参数进行初始化。

总结

这个代码通过 MSBlockLayer 实现了基础的多尺度特征提取单元，再通过 MSBlock 将这些单元组合成多分支模块，每个分支负责提取不同尺度的特征。最后，C2f_MSBlock 类将多个 MSBlock 组合在一起，用于构建更复杂的多尺度特征提取网络。这种设计能够有效地捕捉图像中不同尺度的特征，提高模型的检测能力。

2.3 更改init.py文件

关键步骤二：修改modules文件夹下的__init__.py文件，先导入函数   

然后在下面的__all__中声明函数  

2.4 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_C2f_MSBlock.yaml文件，粘贴下面的内容

  • OD【目标检测】
# 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]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# 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_MSBlock, [128, [1, 3, 3], 3, 2, 3, 2]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_MSBlock, [256, [1, 5, 5], 3, 2, 3, 2]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_MSBlock, [512, [1, 7, 7], 3, 2, 3, 2]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_MSBlock, [1024, [1, 9, 9], 3, 2, 3, 2]]
  - [-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, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 18 (P4/16-medium)

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

  - [[15, 18, 21], 1, Detect, [nc]]  # Detect(P3, P4, P5)
  • RTDETR
# 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]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# 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_MSBlock, [128, [1, 3, 3], 3, 2, 3, 2]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_MSBlock, [256, [1, 5, 5], 3, 2, 3, 2]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_MSBlock, [512, [1, 7, 7], 3, 2, 3, 2]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_MSBlock, [1024, [1, 9, 9], 3, 2, 3, 2]]
  - [-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, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 18 (P4/16-medium)

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

  - [[15, 18, 21], 1, RTDETRDecoder, [nc]] # Detect(P3, P4, P5)
  • Seg【语义分割】
# 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]  # YOLOv8n summary: 225 layers,  3157200 parameters,  3157184 gradients,   8.9 GFLOPs
  s: [0.33, 0.50, 1024]  # YOLOv8s summary: 225 layers, 11166560 parameters, 11166544 gradients,  28.8 GFLOPs
  m: [0.67, 0.75, 768]   # YOLOv8m summary: 295 layers, 25902640 parameters, 25902624 gradients,  79.3 GFLOPs
  l: [1.00, 1.00, 512]   # YOLOv8l summary: 365 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPs
  x: [1.00, 1.25, 512]   # YOLOv8x summary: 365 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPs

# 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_MSBlock, [128, [1, 3, 3], 3, 2, 3, 2]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_MSBlock, [256, [1, 5, 5], 3, 2, 3, 2]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_MSBlock, [512, [1, 7, 7], 3, 2, 3, 2]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_MSBlock, [1024, [1, 9, 9], 3, 2, 3, 2]]
  - [-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, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 18 (P4/16-medium)

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

  - [[15, 18, 21], 1, Segment, [nc, 32, 256]] # Segment(P3, P4, P5)

温馨提示：因为本文只是对yolov8基础上添加模块，如果要对yolov8n/l/m/x进行添加则只需要指定对应的depth_multiple 和 width_multiple。不明白的同学可以看这篇文章： yolov8yaml文件解读——点击即可跳转  

# YOLOv8n
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.25  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8s
depth_multiple: 0.33  # model depth multiple
width_multiple: 0.50  # layer channel multiple
max_channels: 1024 # max_channels
 
# YOLOv8l 
depth_multiple: 1.0  # model depth multiple
width_multiple: 1.0  # layer channel multiple
max_channels: 512 # max_channels
 
# YOLOv8m
depth_multiple: 0.67  # model depth multiple
width_multiple: 0.75  # layer channel multiple
max_channels: 768 # max_channels
 
# YOLOv8x
depth_multiple: 1.33  # model depth multiple
width_multiple: 1.25  # layer channel multiple
max_channels: 512 # max_channels

2.5 注册模块

关键步骤四：在task.py的parse_model函数中注册

2.6 执行程序

在train.py中，将model的参数路径设置为yolov8_C2f_MSBlock.yaml的路径

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

from ultralytics import YOLO
import warnings
warnings.filterwarnings('ignore')
from pathlib import Path
 
if __name__ == '__main__':
 
 
    # 加载模型
    model = YOLO("ultralytics/cfg/v8/yolov8.yaml")  # 你要选择的模型yaml文件地址
    # Use the model
    results = model.train(data=r"你的数据集的yaml文件地址",
                          epochs=100, batch=16, imgsz=640, workers=4, name=Path(model.cfg).stem)  # 训练模型

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

                   from  n    params  module                                       arguments
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]
  2                  -1  1      6416  ultralytics.nn.modules.block.C2f_MSBlock     [32, 32, 1, [1, 3, 3], 3, 2, 3, 2]
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]
  4                  -1  2     42816  ultralytics.nn.modules.block.C2f_MSBlock     [64, 64, 2, [1, 5, 5], 3, 2, 3, 2]
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]
  6                  -1  2    165504  ultralytics.nn.modules.block.C2f_MSBlock     [128, 128, 2, [1, 7, 7], 3, 2, 3, 2]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    379008  ultralytics.nn.modules.block.C2f_MSBlock     [256, 256, 1, [1, 9, 9], 3, 2, 3, 2]
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 12                  -1  1    148224  ultralytics.nn.modules.block.C2f             [384, 128, 1]
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 15                  -1  1     37248  ultralytics.nn.modules.block.C2f             [192, 64, 1]
 16                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]
 17            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 18                  -1  1    123648  ultralytics.nn.modules.block.C2f             [192, 128, 1]
 19                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]
 20             [-1, 9]  1         0  ultralytics.nn.modules.conv.Concat           [1]
 21                  -1  1    493056  ultralytics.nn.modules.block.C2f             [384, 256, 1]
 22        [15, 18, 21]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLOv8_C2f_MSBlock summary: 609 layers, 3036000 parameters, 3035984 gradients, 8.6 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1CYdp-yXZZFv0ye9sDEZw2w?pwd=vwri

提取码: vwri 

4. GFLOPs

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

未改进的YOLOv8nGFLOPs

img

改进后的GFLOPs

5. 进阶

可以与其他的注意力机制或者损失函数等结合，进一步提升检测效果

6. 总结

Multi-Scale Block (MS-Block) 是一种旨在增强实时目标检测中多尺度特征表示能力的核心组件。它通过分层特征融合策略，将输入特征图分成多个分支，并利用倒置瓶颈结构中的深度可分离卷积对不同分支进行处理。每个分支采用不同大小的卷积核，以有效捕捉不同尺度的特征，同时控制计算开销。之后，这些分支的输出会被拼接，并通过一个1x1卷积层进行通道间的交互，从而整合多尺度信息，生成具有丰富特征表示的输出特征图。MS-Block的设计重点在于在保持计算效率的同时，显著提高多尺度特征的捕捉能力，从而在实时目标检测中实现速度与精度的平衡。

kay_545
关注
  • 20
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
YOLOv8改进 | 融合改进 | C2f结合可变形大核注意力超越自注意力【含Seg、OBB、OD代码】
kay_545
07-23 791
yolov8改进，yolov8， C2f_DLKA
YOLOv8改进 | 融合改进 | C2f融合分布移位卷积DSConv​【附 目标检测，语义分割，OBB等yaml文件】
kay_545
07-24 1059
yolov8，c2f_DSConv,yolov8改进
YOLOv8改进有效系列目录 | 包含卷积、主干、检测头、注意力机制、Neck上百种创新机制
热门推荐
Snu77的博客
12-30 8万+
Hello，各位读者们好，本专栏自开设两个月以来已经更新改进教程120+余篇其中包含C2f、主干、检测头、注意力机制、Neck多种结构上创新，也有损失函数和一些细节点上的创新，订阅本专栏以后你不仅可以收获跟专栏的阅读权限，同时可以进Qq群，里面包含集成我所有创新的YOLO最新目录，和我本人录制的视频讲解教程，如果你想要在YOLOv8系列收获一篇论文，我相信订阅本专栏后你一定会有所收获~YOLOv8改进有效系列目录。
YOLOv8改进 | 融合改进 | C2f融合重写星辰网络之Rewrite the Stars⭐【CVPR2024】
kay_545
08-17 1232
yolov8,yolov8改进，yolov8融合改进，模块缝合，c2f_star
YOLOv8改进 | 主干网络 | 十字形通用视觉主干CSWin Transformer【OD, Seg,OBB】
kay_545
08-05 1015
yolov8，yolov8改进，CSWin Transformer
YOLOv8改进 | 主干网络 | ⭐重写星辰Rewrite the Stars⭐【CVPR2024】
kay_545
07-25 1559
StarNet通过引入一种称为星操作（Star Operation）的核心创新，实现了在紧凑网络中高效处理图像的目标。星操作通过两个线性变换后的特征进行元素级乘法，生成一个高维非线性特征空间，类似于多项式核函数的效果。StarNet采用一个四阶段的分层架构，每个阶段通过卷积层下采样分辨率并增加通道数，从而逐步抽象图像特征。每个网络块中使用深度卷积、批量归一化和ReLU6激活函数，简化设计以提高效率。通道扩展固定为4倍，网络宽度在每个阶段翻倍，以平衡计算负载和学习能力。
《YOLOv8改进有效涨点》专栏介绍 & 专栏目录 | 目前已有100+篇内容，内含各种Head检测头、损失函数Loss、Backbone、Neck、NMS等创新点改进
kay_545
07-15 1648
yolov8改进目录，yolov8创新机制
YOLOv10改进 | 代码逐行解析(二) | 从yaml文件到模型定义（新手入门必读系列）
Snu77的博客
07-10 1180
本文给大家带来的是YOLOv10项目的解读，之前给大家分析了YOLOv10的项目文件分析，这一篇文章给大家带来的是模型训练从我们的yaml文件定义到模型的定义部分的讲解，我们一般只知道如何去训练模型，和配置yaml文件，但是对于yaml文件是如何输入到模型里，模型如何将yaml文件解析出来的确是不知道的，本文的内容接上一篇的代码逐行解析(一) 项目目录分析，本文对于小白来说非常友好，非常推荐大家进行阅读，深度的了解模型的工作原理已经流程，下面我们从yaml文件来讲解。
YOLOv8 改进 | 注意力机制 | 处理原始SE通道信息丢失问题的ESE【含分割，检测，OBByaml文件】
kay_545
07-27 867
yolov8改进，yolov8， EffectiveSELayer
万字长文，YOLOv8 yaml 文件解析 | 一文搞定 YOLOv8 分类任务，检测任务，分割任务，关键点任务
YOLOv8项目贡献者
08-24 9669
YOLOv8 yaml 文件解析 | 一文搞定 YOLOv8 分类任务，检测任务，分割任务，关键点任务
YOLOv8改进 | Conv篇 | 2024.1月最新成果可变形卷积DCNv4（适用检测、Seg、分类、Pose、OBB）
Snu77的博客
01-22 7967
本文给大家带来的改进机制是2024-1月的最新成果DCNv4，其是DCNv3的升级版本，效果可以说是在目前的卷积中名列前茅了，同时该卷积具有轻量化的效果！一个DCNv4参数量下降越15Wparameters左右，。它主要通过两个方面对前一版本DCNv3进行改进：首先，它移除了空间聚合中的softmax归一化，这样做增强了其动态特性和表达能力；其次，它优化了内存访问过程，以减少冗余操作，从而加快处理速度。
爆改YOLOv8|利用分层特征融合策略MSBlock改进yolov8,暴力涨点
最新发布
weixin_43986124的博客
08-28 406
分层特征融合策略MSBlock，yolov8改进
垃圾分类笔记YOLOV5（一）-pip换源-口罩识别-训练自己的数据集
sjsn_z的博客
08-24 236
YOLOV5-pip换源-口罩识别-训练自己的数据集
YOLOv10改进 | 独家创新- 注意力篇 | YOLOv10结合全新多尺度动态增强注意力机制DSAttention(全网独家创新)
tsg6698的博客
08-25 245
(4). 通道注意力增强：DSAttention在进行多尺度卷积之前，利用池化操作结合1x1卷积进行通道注意力的计算，通过Adaptive Pooling层提取通道间的全局信息，并通过Sigmoid激活函数强化重要的特征通道，从而提升特征选择的精度。这些多尺度特征融合能够更全面地捕捉图像中不同尺寸的目标物体，提升特征的表达能力。(5). 最终特征融合：该机制在多尺度卷积和注意力模块之后，使用1x1卷积进行最终特征的融合和压缩，从而有效地减少参数量和计算复杂度，并在保证特征表达能力的同时提高了模型的效率。
基于yolov8的PCB缺陷检测系统python源码+onnx模型+评估指标曲线+精美GUI界面
FL1623863129的博客
08-28 263
基于YOLOv8的PCB缺陷检测系统是一种高效且准确的解决方案，用于识别印刷电路板（PCB）在生产过程中出现的各种缺陷，如短路、断路、孔洞等。在构建基于YOLOv8的PCB缺陷检测系统时，首先需要构建一个包含各种PCB缺陷的图像数据集，并进行标注以便系统学习和识别。训练完成后，将模型部署到实际环境中，通过摄像头或图像传感器获取PCB的实时图像，并自动进行缺陷检测和识别。（2）切换到自己安装的yolov8环境后，并切换到源码目录，执行python main.py即可运行启动界面，进行相应的操作即可。
[数据集][目标检测]光伏发电板红外图像鸟粪检测数据集VOC+YOLO格式173张1类别
FL1623863129的博客
08-23 608
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。图片数量(jpg文件个数)：173。标注数量(xml文件个数)：173。标注数量(txt文件个数)：173。标注类别名称:["guano"]使用标注工具：labelImg。guano 框数 = 574。标注规则：对类别进行画矩形框。
YOLOv8改进 | 融合改进 | C2f融合Faster模块提升检测速度【完整代码 + 主要代码解析】
kay_545
08-26 710
yolov8，yolov8改进，yolov8融合，c2f_Faster
YOLOv9改进策略【注意力机制篇】| 引入MobileNetv4中的Mobile MQA，提高模型效率
qq_42591591的博客
08-25 1288
本文记录的是基于Mobile MQA模块的YOLOv9目标检测改进方法研究。中的是用于模型加速，减少内存访问的模块，相比其他全局的自注意力，
YoloV8改进策略：主干网络改进|CAS-ViT在YoloV8中的创新应用与显著性能提升
m0_47867638的博客
08-27 246
在深度学习与计算机视觉领域，模型效率与性能之间的平衡一直是研究者和开发者关注的焦点。特别是在实时检测与识别任务中，如YoloV8这类高效的目标检测模型，其主干网络的选择对整体性能具有决定性作用。近期，我们通过将CAS-ViT（卷积加性自注意力视觉Transformer）创新性地引入到YoloV8中，替换其原有的主干网络，实现了令人瞩目的性能提升，这一改进不仅彰显了CAS-ViT的强大潜力，也为YoloV8的进一步优化开辟了新路径。
yolov8-obb.yaml
01-12
抱歉，根据提供的引用内容，我无法回答关于yolov8-obb.yaml的问题。引用提到了训练命令和模型部署，而引用提到了YOLOv5的源码和项目文件导航。没有提到yolov8-obb.yaml的相关信息。如果您有关于yolov8-obb.yaml的具体问题，请提供更多的信息或引用内容，以便我能够更好地回答您的问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kay_545

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值