YOLOv8改进 | 模块缝合 | C2f 融合RVB + EMA注意力机制【二次融合 + 结构图】

已于 2024-09-11 12:55:18 修改
阅读量362 收藏 15
点赞数 11
文章标签： YOLO 目标检测 深度学习 人工智能 python 面试 YOLOv8改进
于 2024-09-11 12:54:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67647321/article/details/142136772
版权

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

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

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

C2f-RVB 模块是结合了 C2f、RepViT Block 和 EMA 注意力机制的优势，实现了轻量化和高效的模型设计。C2f 模块利用轻量级的 ELAN 注意力机制缓解梯度消失问题，并有效提取关键特征。RepViT Block (RVB) 作为 RepViT 模型的核心组件，通过重新排列 MobileNetV3 模块的 3x3 深度可分离卷积并整合成统一分支。EMA 注意力机制通过对历史数据进行指数移动平均，有效降低噪声或异常值的影响，提高模型的鲁棒性。文章在介绍主要的原理后，将手把手教学如何进行模块的代码添加和修改，并将修改后的完整代码放在文章的最后，方便大家一键运行，小白也可轻松上手实践。以帮助您更好地学习深度学习目标检测YOLO系列的挑战。

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

目录

1.原理 

2. 将C2f_RVB_EMA添加到yolov8网络中

2.1 C2f_RVB_EMA代码实现

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

2.3 更改init.py文件

2.4 添加yaml文件

2.5 注册模块

2.6 执行程序

3. 完整代码分享

4. GFLOPs

5. 进阶

6. 总结

1.原理 

论文地址：Efficient Multi-Scale Attention Module with Cross-Spatial Learning——点击即可跳转

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

C2f-RVB是轻量级网络模块的关键组件，旨在实现高效的特征提取和融合。

核心原理：

  1. C2f-RVB结构：YOLOv8网络中的C2f结构，利用轻量级的特征提取来防止梯度消失并有效捕获关键特征。C2f结构包括Conv层和ELAN机制以增强性能。C2f-RVB模块是此结构的扩展，其中集成了RepViT Blocks来替换Bottleneck层。RepViT Blocks通过在推理过程中重新参数化网络架构来提高特征表示和处理效率。

  2. RepViT Blocks：是C2f-RVB的核心。RepViT Blocks包括深度卷积和通道间交互机制，可增强特征多样性和表达力，在处理轻量级网络任务时特别有用。这使得模型能够捕捉到更丰富的细节，而不会显著增加计算成本。

  3. EMA注意力机制：C2f-RVB中引入了EMA注意力机制来平滑特征权重，减轻检测任务中来自低级特征的噪音。该机制使网络能够更准确地聚焦于重要特征，同时减少背景噪音带来的干扰，提高检测鲁棒性。

总体而言，C2f-RVB模块旨在优化特征提取和融合，专注于提高准确性，同时保持适合在实时应用中部署的轻量级架构。

2. 将C2f_RVB_EMA添加到yolov8网络中

2.1 C2f_RVB_EMA代码实现

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


from timm.models.layers import SqueezeExcite

class EMA(nn.Module):
    def __init__(self, channels, factor=8):
        super(EMA, self).__init__()
        self.groups = factor
        assert channels // self.groups > 0
        self.softmax = nn.Softmax(-1)
        self.agp = nn.AdaptiveAvgPool2d((1, 1))
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))
        self.gn = nn.GroupNorm(channels // self.groups, channels // self.groups)
        self.conv1x1 = nn.Conv2d(channels // self.groups, channels // self.groups, kernel_size=1, stride=1, padding=0)
        self.conv3x3 = nn.Conv2d(channels // self.groups, channels // self.groups, kernel_size=3, stride=1, padding=1)

    def forward(self, x):
        b, c, h, w = x.size()
        group_x = x.reshape(b * self.groups, -1, h, w)  # b*g,c//g,h,w
        x_h = self.pool_h(group_x)
        x_w = self.pool_w(group_x).permute(0, 1, 3, 2)
        hw = self.conv1x1(torch.cat([x_h, x_w], dim=2))
        x_h, x_w = torch.split(hw, [h, w], dim=2)
        x1 = self.gn(group_x * x_h.sigmoid() * x_w.permute(0, 1, 3, 2).sigmoid())
        x2 = self.conv3x3(group_x)
        x11 = self.softmax(self.agp(x1).reshape(b * self.groups, -1, 1).permute(0, 2, 1))
        x12 = x2.reshape(b * self.groups, c // self.groups, -1)  # b*g, c//g, hw
        x21 = self.softmax(self.agp(x2).reshape(b * self.groups, -1, 1).permute(0, 2, 1))
        x22 = x1.reshape(b * self.groups, c // self.groups, -1)  # b*g, c//g, hw
        weights = (torch.matmul(x11, x12) + torch.matmul(x21, x22)).reshape(b * self.groups, 1, h, w)
        return (group_x * weights.sigmoid()).reshape(b, c, h, w)


class Conv2d_BN(torch.nn.Sequential):
    def __init__(self, a, b, ks=1, stride=1, pad=0, dilation=1,
                 groups=1, bn_weight_init=1, resolution=-10000):
        super().__init__()
        self.add_module('c', torch.nn.Conv2d(
            a, b, ks, stride, pad, dilation, groups, bias=False))
        self.add_module('bn', torch.nn.BatchNorm2d(b))
        torch.nn.init.constant_(self.bn.weight, bn_weight_init)
        torch.nn.init.constant_(self.bn.bias, 0)

    @torch.no_grad()
    def fuse_self(self):
        c, bn = self._modules.values()
        w = bn.weight / (bn.running_var + bn.eps)**0.5
        w = c.weight * w[:, None, None, None]
        b = bn.bias - bn.running_mean * bn.weight / \
            (bn.running_var + bn.eps)**0.5
        m = torch.nn.Conv2d(w.size(1) * self.c.groups, w.size(
            0), w.shape[2:], stride=self.c.stride, padding=self.c.padding, dilation=self.c.dilation, groups=self.c.groups,
            device=c.weight.device)
        m.weight.data.copy_(w)
        m.bias.data.copy_(b)
        return m
    

class Residual(nn.Module):
    def __init__(self, fn):
        super(Residual, self).__init__()
        self.fn = fn

    def forward(self, x):
        return self.fn(x) + x

class SEAM(nn.Module):
    def __init__(self, c1, c2, n, reduction=16):
        super(SEAM, self).__init__()
        if c1 != c2:
            c2 = c1
        self.DCovN = nn.Sequential(
            *[nn.Sequential(
                Residual(nn.Sequential(
                    nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=3, stride=1, padding=1, groups=c2),
                    nn.GELU(),
                    nn.BatchNorm2d(c2)
                )),
                nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=1, stride=1, padding=0, groups=1),
                nn.GELU(),
                nn.BatchNorm2d(c2)
            ) for i in range(n)]
        )
        self.avg_pool = torch.nn.AdaptiveAvgPool2d(1)
        self.fc = nn.Sequential(
            nn.Linear(c2, c2 // reduction, bias=False),
            nn.ReLU(inplace=True),
            nn.Linear(c2 // reduction, c2, bias=False),
            nn.Sigmoid()
        )

        self._initialize_weights()
        # self.initialize_layer(self.avg_pool)
        self.initialize_layer(self.fc)


    def forward(self, x):
        b, c, _, _ = x.size()
        y = self.DCovN(x)
        y = self.avg_pool(y).view(b, c)
        y = self.fc(y).view(b, c, 1, 1)
        y = torch.exp(y)
        return x * y.expand_as(x)

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.xavier_uniform_(m.weight, gain=1)
            elif isinstance(m, nn.BatchNorm2d):
                nn.init.constant_(m.weight, 1)
                nn.init.constant_(m.bias, 0)

    def initialize_layer(self, layer):
        if isinstance(layer, (nn.Conv2d, nn.Linear)):
            torch.nn.init.normal_(layer.weight, mean=0., std=0.001)
            if layer.bias is not None:
                torch.nn.init.constant_(layer.bias, 0)

class RepViTBlock(nn.Module):
    def __init__(self, inp, oup, use_se=True):
        super(RepViTBlock, self).__init__()

        self.identity = inp == oup
        hidden_dim = 2 * inp

        self.token_mixer = nn.Sequential(
            RepVGGDW(inp),
            SqueezeExcite(inp, 0.25) if use_se else nn.Identity(),
        )
        self.channel_mixer = Residual(nn.Sequential(
                # pw
                Conv2d_BN(inp, hidden_dim, 1, 1, 0),
                nn.GELU(),
                # pw-linear
                Conv2d_BN(hidden_dim, oup, 1, 1, 0, bn_weight_init=0),
            ))

    def forward(self, x):
        return self.channel_mixer(self.token_mixer(x))

class RepViTBlock_EMA(RepViTBlock):
    def __init__(self, inp, oup, use_se=True):
        super().__init__(inp, oup, use_se)
        
        self.token_mixer = nn.Sequential(
            RepVGGDW(inp),
            EMA(inp) if use_se else nn.Identity(),
        )
class C2f_RVB(C2f):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(RepViTBlock(self.c, self.c, False) for _ in range(n))

class C2f_RVB_EMA(C2f):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__(c1, c2, n, shortcut, g, e)
        self.m = nn.ModuleList(RepViTBlock_EMA(self.c, self.c) for _ in range(n))

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

C2f_RVB 模块是 C2f 结构的扩展，集成了 RepViTBlocks，通过高效的重新参数化和特征提取来提高性能。

  1. C2f 结构：基础 C2f 模块融合多尺度特征，同时保持轻量级结构。它由多个具有深度卷积和高效特征融合机制的层组成。原始 C2f 专注于捕获丰富的特征表示，同时平衡计算成本。

  2. RepViT 块集成：C2f_RVB 模块中引入的 RepViTBlock 通过添加重新参数化的卷积进一步增强了 C2f 的功能。这使模块能够通过在推理过程中更有效地融合特征来适应不同的计算环境。 RepViT 模块还包括深度卷积和可选的挤压和激发 (SE) 模块，以提高空间注意力。

  3. 通道和标记混合：每个 RepViTBlock 都使用 标记混合（深度卷积和 SE/EMA 注意力）和 通道混合（逐点卷积）的组合。标记混合器提取不同的特征表示，而通道混合器增强通道间关系，从而实现更有效的特征融合。

  4. 通过重新参数化提高效率：RepViTBlock 在推理过程中将多分支结构重新参数化为单分支配置，在保持模型准确性的同时减少计算开销。这使得 C2f_RVB 模块既轻量又具有计算效率。

  5. EMA Attention:C2f_RVB 还可以在 token 混合阶段利用EMA注意力机制，其中 EMA 有助于平滑特征权重并减少浅层噪声，从而增强模型在实时或低功耗环境下的鲁棒性。

C2f_RVB 模块将 C2f 的多尺度特征融合与 RepViTBlocks 的高效特征提取相结合，使其成为需要高精度和计算效率的轻量级模型的理想选择。

2.3 更改init.py文件

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

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

2.4 添加yaml文件

关键步骤三：在/ultralytics/ultralytics/cfg/models/v8下面新建文件yolov8_C2f_RVB_EMA.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_RVB, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_RVB, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_RVB_EMA, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_RVB_EMA, [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_RVB, [512]]  # 12

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

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f_RVB, [512]]  # 18 (P4/16-medium)

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

  - [[15, 18, 21], 1, Detect, [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_RVB, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f_RVB, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f_RVB_EMA, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f_RVB_EMA, [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_RVB, [512]]  # 12

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

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f_RVB, [512]]  # 18 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f_RVB, [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_RVB_EMA.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      4800  ultralytics.nn.modules.block.C2f_RVB         [32, 32, 1, True]
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]
  4                  -1  2     25088  ultralytics.nn.modules.block.C2f_RVB         [64, 64, 2, True]
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]
  6                  -1  2     92480  ultralytics.nn.modules.block.C2f_RVB_EMA     [128, 128, 2, True]
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]
  8                  -1  1    241728  ultralytics.nn.modules.block.C2f_RVB_EMA     [256, 256, 1, True]
  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     94976  ultralytics.nn.modules.block.C2f_RVB         [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     24960  ultralytics.nn.modules.block.C2f_RVB         [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     70400  ultralytics.nn.modules.block.C2f_RVB         [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    271872  ultralytics.nn.modules.block.C2f_RVB         [384, 256, 1]
 22        [15, 18, 21]  1    897664  ultralytics.nn.modules.head.Detect           [80, [64, 128, 256]]
YOLOv8_C2f_RVB_EMA summary: 396 layers, 2466384 parameters, 2466368 gradients, 7.3 GFLOPs

3. 完整代码分享

https://pan.baidu.com/s/1fh-V-OfrTZLp2ioz4qoJZA?pwd=rn5u

 提取码: rn5u 

4. GFLOPs

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

未改进的YOLOv8nGFLOPs

img

改进后的GFLOPs

5. 进阶

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

6. 总结

C2f_RVB 模块结合了多尺度特征融合和高效的特征提取，通过引入 RepViTBlock 实现了轻量化和高性能的设计。它基于 C2f 结构，专注于捕捉丰富的特征表示，同时保持较低的计算成本。模块中每个 RepViTBlock 包含了 token mixing 和 channel mixing，通过深度卷积和点卷积增强不同通道之间的特征关系，进一步优化特征融合效率。此外，C2f_RVB 使用了 重参数化 技术，将多分支结构在推理阶段简化为单分支，大幅减少了计算开销，而不会降低模型的表现。同时，模块可以通过 EMA注意力机制 平滑特征权重，减少来自浅层的噪声干扰，提升模型在实际应用中的鲁棒性。总体而言，C2f_RVB 通过多尺度融合、轻量化卷积和注意力机制，实现了高效的特征提取和较低的计算负担，适用于需要精度和效率平衡的任务。

kay_545
关注
  • 11
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
电子-一种生产BVVB-S、RVB+电线产品的自定心模具
09-15
标题中的“电子-一种生产BVVB-S、RVB+电线产品的自定心模具”表明了本文档关注的是电子行业中电线产品的生产技术，特别是涉及到一种特殊的自定心模具在制造BVVB-S和RVB+电线过程中的应用。这些电线通常用于电力传输...
RVB开发帮助和文档
06-20
在本压缩包“RVB开发帮助和文档”中，包含了针对RVB机器视觉开发平台4.2版的重要资源，这是一套专为图像处理和机器视觉应用设计的开发工具。以下将详细介绍其中涉及的主要知识点： 1. **RVB机器视觉开发平台**： ...
如何开发支持RVB的相机中间件
06-20
图像处理方面，包括图像的预处理（如去噪、直方图均衡化）、后处理（如锐化、融合）以及图像分析。预处理是为了提高图像质量，便于后续处理；后处理则是为了优化图像显示效果或增强某些特征。在中间件中，我们需要...
阿里平头哥RVB2601 MOSBUD 移动主站
07-03
阿里平头哥RVB2601 MOSBUD 移动主站是一款基于Modbus通信协议的设备，专为移动应用场景设计。这款主站能够连接并控制多台遵循Modbus协议的从站设备，实现数据交换和设备管理。在本文中，我们将详细探讨Modbus移动...
游泳池溺水目标检测数据集 10000张 带标注 voc yolo
2301_78240361的博客
09-10 676
游泳池溺水目标检测数据集 10000张 带标注 voc yolo
[数据集][目标检测]西红柿缺陷检测数据集VOC+YOLO格式17318张3类别
FL1623863129的博客
09-05 623
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。标注类别名称:["Bad","Good","Unripe"]图片数量(jpg文件个数)：17318。标注数量(xml文件个数)：17318。标注数量(txt文件个数)：17318。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
【目标检测数据集】铁轨表面缺损检测数据集4789张VOC+YOLO格式
最新发布
lwx666sl的博客
09-10 195
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。标注类别名称:["Spalling","Trilho_bom"]{脱裂、良好}图片数量(jpg文件个数)：4789。标注数量(xml文件个数)：4789。标注数量(txt文件个数)：4789。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
yolo-2
默子昂
09-10 344
创建ui/ 目录，下面所有文件都在ui下面。
基于yolov8的电动车佩戴头盔检测系统python源码+onnx模型+评估指标曲线+精美GUI界面
FL1623863129的博客
09-06 506
基于YOLOv8的电动车佩戴头盔检测系统利用了YOLOv8这一先进的目标检测模型，旨在提高电动车骑行者的安全意识，减少因未佩戴头盔而导致的交通事故风险。在实际应用中，系统可以实时处理来自摄像头或视频流的图像，快速检测骑行者的头盔佩戴情况，并在检测到未佩戴头盔时发出警报，提醒骑行者注意安全。此外，该系统还具备用户友好的界面，能够直观展示检测结果和相关信息，如检测耗时、目标数量等，便于用户监控和管理。基于YOLOv8的电动车佩戴头盔检测系统不仅提升了骑行安全，也为智能交通系统的发展提供了新的技术支持。
YOLOv9改进策略【注意力机制篇】| PSA极化自我关注： 实现高质量像素回归
qq_42591591的博客
09-06 1316
本文记录的是基于PSA注意力模块的YOLOv9目标检测方法研究。PSA模块。本文将其应用到YOLOv9的检测任务中，使模型能够更好地捕捉图像中的细节信息，以实现目标检测任务中准确识别和定位。
基于yolov8的包装盒纸板破损缺陷测系统python源码+onnx模型+评估指标曲线+精美GUI界面
FL1623863129的博客
09-06 424
基于YOLOv8的包装盒纸板破损缺陷检测系统是一种高效、智能的解决方案，旨在提高生产线上包装盒纸板的质量检测效率与准确性。该系统利用YOLOv8这一前沿的深度学习模型，通过其强大的目标检测能力，能够实时识别并标记出包装盒纸板上的各种破损缺陷，如划痕、撕裂、孔洞等。该系统不仅具备高效准确的检测能力，还支持多类别检测，覆盖了包装盒纸板可能出现的多种破损情况。综上所述，基于YOLOv8的包装盒纸板破损缺陷检测系统是工业生产中不可或缺的重要工具，为制造商提供了高效、可靠的解决方案。【模型可以检测出类别】
[数据集][目标检测]抽烟检测数据集VOC+YOLO格式22559张2类别
FL1623863129的博客
09-06 528
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。标注类别名称:["cig-pack","smoke"]图片数量(jpg文件个数)：22559。标注数量(xml文件个数)：22559。标注数量(txt文件个数)：22559。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
基于YOLOv8的风力涡轮机表面损坏检测系统
tsg6698的博客
09-10 176
（该系统可以根据数据训练出的yolov8的权重文件，运用在其他检测系统上，如火焰检测，口罩检测等等，可以根据检测目标更改UI界面。通过PYQT构建UI界面，包含图片检测，视频检测，摄像头实时检测。基于YOLOv8的风力涡轮机表面损坏检测系统 (价格85)包含 [损坏] 1个类。
[数据集][目标检测]电梯内广告牌电动车检测数据集VOC+YOLO格式2787张4类别
FL1623863129的博客
09-05 432
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)标注类别名称:["advertising","bike","ebike","person"]特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。图片数量(jpg文件个数)：2787。标注数量(xml文件个数)：2787。标注数量(txt文件个数)：2787。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
基于ONNX-YOLOv10-Object-Detection项目实现yolov10模型onnx-python推理
a486259的博客
09-08 871
项目依赖：onnxruntime-gpu、opencv-python、imread-from-url、cap-from-youtube、ultralytics。
目标检测-YOLOv6
午夜的行人
09-06 861
YOLOv6 的设计目标是在提高模型检测精度的同时，进一步优化速度和效率，特别是在推理速度和部署便捷性方面。它采用了更先进的网络架构和优化技巧，在保持高性能的同时，极大地提升了推理速度。YOLOv6 使用了锚点自由检测机制，这意味着模型不再依赖于预定义的锚点框，能够自动适应不同的目标大小，简化了训练和推理过程，并且提升了小目标的检测能力。YOLOv6 在推理速度上优于 YOLOv5，尤其是在移动设备和嵌入式设备上，得益于其轻量化的设计和高效的推理优化，使其更加适合实时应用场景。YOLOv6 引入了新的。
目标检测-YOLOv7
午夜的行人
09-06 928
YOLOv7 重构了检测头（Head），相比 YOLOv6 使用的 YOLOHead 模块，YOLOv7 引入了更加轻量化的架构，并通过深度可分离卷积（Depthwise Separable Convolutions）进一步减少了计算开销，同时保证检测精度。在 YOLOv6 以及早期的 YOLO 系列模型中，标签分配是基于固定的 IoU 阈值进行的，而 YOLOv7 通过动态调整标签分配策略，能够更有效地匹配目标与预测框，提高检测效果，尤其对小目标的检测性能有所提升。YOLOv7 采用了。
基于yolov8的血细胞检测计数系统python源码+onnx模型+评估指标曲线+精美GUI界面
FL1623863129的博客
09-08 591
该系统通过收集并预处理包含各种血细胞类型的图像或视频数据，利用YOLOv8算法进行模型训练，从而学习血细胞的特征和分类信息。在实时检测阶段，系统能够快速接收并处理图像或视频输入，准确识别并计数血细胞，生成详细的统计报告。基于YOLOv8的血细胞检测与计数系统是一种利用深度学习技术，特别是YOLOv8目标检测算法，实现高效、准确血细胞识别的系统。（2）切换到自己安装的yolov8环境后，并切换到源码目录，执行python main.py即可运行启动界面，进行相应的操作即可。【模型可以检测出类别】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

kay_545

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

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

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

打赏作者

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

抵扣说明：

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

余额充值