爆改YOLOv8 |YOLOv8融合SEAM注意力机制

已于 2024-08-22 21:27:45 修改
阅读量302 收藏 3
点赞数 11
分类专栏： 爆改yolov8，即插即用 文章标签： YOLO 深度学习 人工智能 yolov8 目标检测 计算机视觉
于 2024-08-22 21:26:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43986124/article/details/141438249
版权

1，本文介绍

SEAM（Spatially Enhanced Attention Module）是一个注意力网络模块，旨在解决面部遮挡导致的响应损失问题。通过使用深度可分离卷积和残差连接的组合，SEAM模块增强未遮挡面部的响应。深度可分离卷积在每个通道上独立操作，减少了参数量，但忽略了通道间的关系。为了解决这一问题，SEAM将不同深度卷积的输出通过1x1卷积结合，再通过两层全连接网络融合每个通道的信息，以提升通道间的联系，从而弥补遮挡造成的损失。

本文将讲解如何将SEAM融合进yolov8

话不多说，上代码！

2， 将SEAM融合进yolov8

2.1 步骤一

找到如下的目录'ultralytics/nn/modules'，然后在这个目录下创建一个seam.py文件，文件名字可以根据你自己的习惯起，然后将seam的核心代码复制进去

import torch
import torch.nn as nn
 
__all__ = ['SEAM', 'MultiSEAM']
 
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,  n=1, reduction=16):
        super(SEAM, self).__init__()
        c2 = c1
        self.DCovN = nn.Sequential(
            # nn.Conv2d(c1, c2, kernel_size=3, stride=1, padding=1, groups=c1),
            # nn.GELU(),
            # nn.BatchNorm2d(c2),
            *[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)
 
 
def DcovN(c1, c2, depth, kernel_size=3, patch_size=3):
    dcovn = nn.Sequential(
        nn.Conv2d(c1, c2, kernel_size=patch_size, stride=patch_size),
        nn.SiLU(),
        nn.BatchNorm2d(c2),
        *[nn.Sequential(
            Residual(nn.Sequential(
                nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=kernel_size, stride=1, padding=1, groups=c2),
                nn.SiLU(),
                nn.BatchNorm2d(c2)
            )),
            nn.Conv2d(in_channels=c2, out_channels=c2, kernel_size=1, stride=1, padding=0, groups=1),
            nn.SiLU(),
            nn.BatchNorm2d(c2)
        ) for i in range(depth)]
    )
    return dcovn
 
class MultiSEAM(nn.Module):
    def __init__(self, c1,  depth=1, kernel_size=3, patch_size=[3, 5, 7], reduction=16):
        super(MultiSEAM, self).__init__()
        c2 = c1
        self.DCovN0 = DcovN(c1, c2, depth, kernel_size=kernel_size, patch_size=patch_size[0])
        self.DCovN1 = DcovN(c1, c2, depth, kernel_size=kernel_size, patch_size=patch_size[1])
        self.DCovN2 = DcovN(c1, c2, depth, kernel_size=kernel_size, patch_size=patch_size[2])
        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()
        )
 
    def forward(self, x):
        b, c, _, _ = x.size()
        y0 = self.DCovN0(x)
        y1 = self.DCovN1(x)
        y2 = self.DCovN2(x)
        y0 = self.avg_pool(y0).view(b, c)
        y1 = self.avg_pool(y1).view(b, c)
        y2 = self.avg_pool(y2).view(b, c)
        y4 = self.avg_pool(x).view(b, c)
        y = (y0 + y1 + y2 + y4) / 4
        y = self.fc(y).view(b, c, 1, 1)
        y = torch.exp(y)
        return x * y.expand_as(x)

2.2 步骤二

首先找到如下的目录'ultralytics/nn/modules'，然后在这个目录下找到init文件,在init中添加如下代码.

from .seam import (
    MultiSEAM,
    SEAM
)

同时在init.py中的如下位置添加SEAM，MultiSEAM

2.3 步骤三

在task.py中导入SEAM

2.4 步骤四

在task.py中添加如下代码.

到此注册成功,复制后面的yaml文件直接运行即可

有两种yaml文件，可以自行选择

yaml文件一（seam)

# 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 GFLOP
 
# 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, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f, [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, [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, SEAM, []]  # 16
 
  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 19 (P4/16-medium)
  - [-1, 1, SEAM, []]  # 20
 
  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f, [1024]]  # 23 (P5/32-large)
  - [-1, 1, SEAM, []]  # 24
 
  - [[16, 20, 24], 1, Detect, [nc]]  # Detect(P3, P4, P5)

yaml文件二（multiseam)


# 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 GFLOP
 
# 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, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2f, [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, [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, MultiSEAM, []]  # 16
 
  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]]  # cat head P4
  - [-1, 3, C2f, [512]]  # 19 (P4/16-medium)
  - [-1, 1, MultiSEAM, []]  # 20
 
  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]]  # cat head P5
  - [-1, 3, C2f, [1024]]  # 23 (P5/32-large)
  - [-1, 1, MultiSEAM, []]  # 24
 
  - [[16, 20, 24], 1, Detect, [nc]]  # Detect(P3, P4, P5)

# 关于SEAM添加的位置还可以放在颈部,针对不同数据集位置不同,效果不同

不知不觉已经看完了哦，动动小手留个点赞吧--_--

不想敲代码！！！
关注
  • 11
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
YOLOv8改进 | 注意力机制 | 添加YOLO-Face提出的SEAM注意力机制优化物体遮挡检测（附代码 + 修改教程）
Snu77的博客
03-11 5645
本文重点YOLOFaceV2介绍遮挡改进注意力网络模块（SEAM）和排斥损失（Repulsion Loss）。注意力网络模块旨在补偿被遮挡面部的响应损失，通过增强未遮挡面部的响应来实现这一目标。SEAM模块通过深度可分离卷积和残差连接的组合来实现，其中深度可分离卷积按通道进行操作，虽然可以学习不同通道的重要性并减少参数量，但忽略了通道间的信息关系。为了弥补这一损失，不同深度卷积的输出通过点对点（1x1）卷积组合。然后使用两层全连接网络融合每个通道的信息，以增强所有通道之间的联系。
YOLOv8改进 | 注意力机制 | 用于增强小目标感受野的RFEM
kay_545
06-18 555
yolov8，yolov8改进，小目标检测
YOLOv8添加GAM注意力机制
zhaodaandedifang的博客
07-03 465
运行成功界面文章引入了3D-permutation 与多层感知器的通道注意力和卷积空间注意力子模块。在CIFAR-100和ImageNet-1K上对所提出的图像分类机制的评估表明，此注意力机制优于最近的几个注意力机制，包括ResNet和轻量级的MobileNet。全称为Global Attention Mechanism.
YOLOv8添加EMA注意力机制
zhaodaandedifang的博客
05-01 968
简单记录YOLOv8添加各种模块的改进，文章所写都已运行成功。
YOLOv8添加CBAM注意力机制
zhaodaandedifang的博客
05-01 806
简单记录YOLOv8添加各种模块的改进，文章所写都已运行成功。
SEAM:弱监督语义分割的自监督等变注意机制，CVPR 2020（口头）
05-29
在本文中，我们提出了一种自监督的等变注意机制（SEAM）来发现额外的监督并缩小差距。 我们的方法基于观察到等方差是完全监督语义分割中的隐式约束，其像素级标签在数据增强期间采用与输入图像相同的空间变换。 ...
seam：在IE8中部分richface组件不能兼容的解决办法
10-30
seam：在IE8中部分richface组件不能兼容的解决办法
seam_seamcarving_
10-01
Seam Carving，又称为能量最小路径法或图像拉伸，是一种在不改变图像视觉质量的前提下，动态调整图像大小的技术。该方法由Ariel Shamir和Shai Avidan于2007年提出，主要用于图像缩放，尤其在保留图像重要特征的同时...
MATLAB_Seam_Carving_seamcarving_
09-30
通过阅读和理解这些代码，你可以深入学习seam carving的工作机制，并可以进一步修改和优化代码，适应不同的图像处理需求。 总的来说，seam carving是一种创新的图像缩放技术，它能够智能地保留图像的关键内容。在...
JbossSeam中文开发指南.docx
09-19
Jboss Seam中文开发指南 Jboss Seam是基于Java EE 5.0的框架，提供了一个基于组件的架构，能够帮助开发者快速构建企业级应用程序。Seam框架提供了一个统一的编程模型，能够将JSF、EJB、JPA等技术整合在一起，提供了...
创建干净虚拟环境对YOLOV8进行打包
yljxh的博客
08-19 623
打开Pycharm，打开需要打包的文件所在文件夹，点击Settings => Python Interpreter => Add Interpreter，参考下图，点击确定即可。另外，还需要在exe同级目录下，拷贝程序中使用到的资源，要不然exe找不到，我试了放到_internal里面不行。输入命令之后，等待即可，因为依赖环境比较多，时间稍微有点长，大概几分钟，最后出现这样子就打包成功了。直接双击DemoWindow.exe，看能不能正常打开，哈哈，果然不让你一次成功，提示找不到文件。
yolov8 出现loss 为nan
最新发布
zhaoluruoyan89的博客
08-21 181
这篇博客警示读者在购买用于深度学习的显卡时要避开那些导致RuntimeWarning: All-NaN slice encountered的问题。作者强调这些Tensor核心存在严重缺陷，不适宜进行深度学习任务，建议大家在选购时务必谨慎。方法二：将混合精度训练AMP 设置为False。方法一：降低cuda和pytorch 版本号。
使用X-AnyLabeling自动标注数据集（以yolov10模型为例，多图详细介绍）
Bruce Che 的专栏
08-16 701
X-AnyLabeling 是一款全新的交互式自动标注工具，其基于AnyLabeling进行构建和二次开发，在此基础上扩展并支持了许多的模型和功能，并借助Segment Anything和YOLO等主流模型提供强大的 AI 支持。无须任何复杂配置，下载即用，支持自定义模型，极大提升用户标注效率！
YOLOv7-face人脸检测
CSPhD-winston的博客
08-17 135
【代码】YOLOv7-face人脸检测。
YOLOv8改进 | 融合改进 | C2f融合新颖的可扩张残差注意力模块助力小目标检测【完整代码】
kay_545
08-16 574
yolov8，模块缝合，yolov8改进，yolov8_C2f_DWR
[数据集][目标检测]道路积水检测数据集VOC+YOLO格式2699张1类别
FL1623863129的博客
08-21 174
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。图片数量(jpg文件个数)：2699。标注数量(xml文件个数)：2699。标注数量(txt文件个数)：2699。标注类别名称:["water"]water 框数 = 3777。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
[数据集][目标检测]集装箱缺陷检测数据集VOC+YOLO格式4127张3类别
FL1623863129的博客
08-21 153
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。标注类别名称:["Dent","Hole","Rust"]图片数量(jpg文件个数)：4127。标注数量(xml文件个数)：4127。标注数量(txt文件个数)：4127。使用标注工具：labelImg。Dent 框数 = 4943。标注规则：对类别进行画矩形框。
Yolov5 CPU调用
在路上@Amos
08-16 134
【YOLOv5】调用本地摄像头_yolov5调用摄像头-CSDN博客使用YOLOv5实现单摄像头实时目标检测_yolov5摄像头实时检测-CSDN博客
RK3568笔记五十五：yolov10训练部署测试
08-17 85
若该文为原创文章，转载请注明原文出处。yolov8还没熟悉，yolov10就出来了，本篇记录使用yolov10训练自己的数据，并部署到rk3568上。参考大佬的博客。
SEAM注意力机制特点
05-02
SEAM（Selective Exponential Attention Mechanism）是一种注意力机制，它在自然语言处理任务中被广泛应用。SEAM具有以下几个特点： 1. 选择性：SEAM通过选择性地关注输入序列中的不同部分来提高模型的性能。它可以根据任务的需要，有选择地关注与任务相关的信息，忽略与任务无关的信息。 2. 指数级加权：SEAM使用指数级加权来计算注意力权重。这种加权方式可以使得模型更加关注与任务相关的信息，同时减少对与任务无关的信息的关注。 3. 上下文感知：SEAM能够感知上下文信息，即它可以根据输入序列中前面的内容来调整注意力权重。这样可以更好地捕捉到序列中的长距离依赖关系。 4. 可解释性：SEAM生成的注意力权重可以解释模型在决策过程中关注的重要信息。这样可以增加模型的可解释性，使得用户能够更好地理解模型的决策过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值