yolov7添加GAMAttention注意力机制，同时添加CNeB，C3C2

news/2023/12/9 19:47:06 标签: YOLO, python, 开发语言

1，common.py配置

./models/common.py文件增加以下模块

class GAMAttention(nn.Module):
       #https://paperswithcode.com/paper/global-attention-mechanism-retain-information
    def __init__(self, c1, c2, group=True,rate=4):
        super(GAMAttention, self).__init__()
        
        self.channel_attention = nn.Sequential(
            nn.Linear(c1, int(c1 / rate)),
            nn.ReLU(inplace=True),
            nn.Linear(int(c1 / rate), c1)
        )
        self.spatial_attention = nn.Sequential(
            nn.Conv2d(c1, c1//rate, kernel_size=7, padding=3,groups=rate)if group else nn.Conv2d(c1, int(c1 / rate), kernel_size=7, padding=3), 
            nn.BatchNorm2d(int(c1 /rate)),
            nn.ReLU(inplace=True),
            nn.Conv2d(c1//rate, c2, kernel_size=7, padding=3,groups=rate) if group else nn.Conv2d(int(c1 / rate), c2, kernel_size=7, padding=3), 
            nn.BatchNorm2d(c2)
        )

    def forward(self, x):
        b, c, h, w = x.shape
        x_permute = x.permute(0, 2, 3, 1).view(b, -1, c)
        x_att_permute = self.channel_attention(x_permute).view(b, h, w, c)
        x_channel_att = x_att_permute.permute(0, 3, 1, 2)
        x = x * x_channel_att
 
        x_spatial_att = self.spatial_attention(x).sigmoid()
        x_spatial_att=channel_shuffle(x_spatial_att,4) #last shuffle 
        out = x * x_spatial_att
        return out  

def channel_shuffle(x, groups=2):
        B, C, H, W = x.size()
        out = x.view(B, groups, C // groups, H, W).permute(0, 2, 1, 3, 4).contiguous()
        out=out.view(B, C, H, W) 
        return out

在yolo.py中添加：

 

elif m is GAMAttention:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
    args = [c1, c2, *args[1:]]

2，添加添加CNeB模块代码：

在 common.py 文件中添加如下代码

class LayerNorm_s(nn.Module):
    
    def __init__(self, normalized_shape, eps=1e-6, data_format="channels_last"):
        super().__init__()
        self.weight = nn.Parameter(torch.ones(normalized_shape))
        self.bias = nn.Parameter(torch.zeros(normalized_shape))
        self.eps = eps
        self.data_format = data_format
        if self.data_format not in ["channels_last", "channels_first"]:
            raise NotImplementedError
        self.normalized_shape = (normalized_shape,)
 
    def forward(self, x):
        if self.data_format == "channels_last":
            return F.layer_norm(x, self.normalized_shape, self.weight, self.bias, self.eps)
        elif self.data_format == "channels_first":
            u = x.mean(1, keepdim=True)
            s = (x - u).pow(2).mean(1, keepdim=True)
            x = (x - u) / torch.sqrt(s + self.eps)
            x = self.weight[:, None, None] * x + self.bias[:, None, None]
            return x
 
class ConvNextBlock(nn.Module):
    
    def __init__(self, dim, drop_path=0., layer_scale_init_value=1e-6):
        super().__init__()
        self.dwconv = nn.Conv2d(dim, dim, kernel_size=7, padding=3, groups=dim)  # depthwise conv
        self.norm = LayerNorm_s(dim, eps=1e-6)
        self.pwconv1 = nn.Linear(dim, 4 * dim)  
        self.act = nn.GELU()
        self.pwconv2 = nn.Linear(4 * dim, dim)
        self.gamma = nn.Parameter(layer_scale_init_value * torch.ones((dim)),
                                  requires_grad=True) if layer_scale_init_value > 0 else None
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
 
    def forward(self, x):
        input = x
        x = self.dwconv(x)
        x = x.permute(0, 2, 3, 1)  # (N, C, H, W) -> (N, H, W, C)
        x = self.norm(x)
        x = self.pwconv1(x)
        x = self.act(x)
        x = self.pwconv2(x)
        if self.gamma is not None:
            x = self.gamma * x
        x = x.permute(0, 3, 1, 2)  # (N, H, W, C) -> (N, C, H, W)
 
        x = input + self.drop_path(x)
        return x
 
class DropPath(nn.Module):
    """Drop paths (Stochastic Depth) per sample  (when applied in main path of residual blocks).
    """
 
    def __init__(self, drop_prob=None):
        super(DropPath, self).__init__()
        self.drop_prob = drop_prob
 
    def forward(self, x):
        return drop_path_f(x, self.drop_prob, self.training)
 
def drop_path_f(x, drop_prob: float = 0., training: bool = False):
    if drop_prob == 0. or not training:
        return x
    keep_prob = 1 - drop_prob
    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
    random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
    random_tensor.floor_()  # binarize
    output = x.div(keep_prob) * random_tensor
    return output
 
 
class CNeB(nn.Module):
    # CSP ConvNextBlock with 3 convolutions by iscyy/yoloair
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, 1, 1)
        self.cv2 = Conv(c1, c_, 1, 1)
        self.cv3 = Conv(2 * c_, c2, 1)
        self.m = nn.Sequential(*(ConvNextBlock(c_) for _ in range(n)))
    def forward(self, x):
        return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), dim=1))

在 models/yolo.py文件夹下找到parse_model函数

在 for i, (f, n, m, args) in enumerate(d['backbone'] + d['head']):下方添加以下代码

elif m is CNeB:
    c1, c2 = ch[f], args[0]
    if c2 != no:
        c2 = make_divisible(c2 * gw, 8)
 
    args = [c1, c2, *args[1:]]
    if m is CNeB:
        args.insert(2, n)
        n = 1

3，添加C3C2模块：

在common.py中添加：

class C3C2(nn.Module):
    # CSP Bottleneck with 3 convolutions
    def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.conv = nn.Conv2d(c1, c_, 1, 1, autopad(1, None), groups=g, bias=False)
        self.bn = nn.BatchNorm2d(c_)
        self.act = nn.SiLU()
        self.cv1 = Conv(2 * c_, c2, 1, act=nn.Mish())
        self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))

    def forward(self, x):
        y = self.conv(x)
        return self.cv1(torch.cat((self.m(self.act(self.bn(y))), y), dim=1))

在yolo.py中添加：

4，更改配置文件

# YOLOv7 🚀, GPL-3.0 license
# parameters
nc: 4  # number of classes
depth_multiple: 0.33  # model depth multiple
width_multiple: 1.0  # layer channel multiple

# anchors
anchors:
  - [12,16, 19,36, 40,28]  # P3/8
  - [36,75, 76,55, 72,146]  # P4/16
  - [142,110, 192,243, 459,401]  # P5/32

# yolov7 backbone by yoloair
backbone:
  # [from, number, module, args]
  [[-1, 1, Conv, [32, 3, 1]],  # 0
   [-1, 1, Conv, [64, 3, 2]],  # 1-P1/2
   [-1, 1, Conv, [64, 3, 1]],
   [-1, 1, Conv, [128, 3, 2]],  # 3-P2/4
   [-1, 1, CNeB, [128]],
   [-1, 1, Conv, [256, 3, 2]],
   [-1, 1, MP, []],
   [-1, 1, Conv, [128, 1, 1]],
   [-3, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [128, 3, 2]],
   [[-1, -3], 1, Concat, [1]],  # 16-P3/8
   [-1, 1, Conv, [128, 1, 1]],
   [-2, 1, Conv, [128, 1, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [-1, 1, Conv, [128, 3, 1]],
   [[-1, -3, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [512, 1, 1]],
   [-1, 1, MP, []],
   [-1, 1, Conv, [256, 1, 1]],
   [-3, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [256, 3, 2]],
   [[-1, -3], 1, Concat, [1]],
   [-1, 1, Conv, [256, 1, 1]],
   [-2, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [-1, 1, Conv, [256, 3, 1]],
   [[-1, -3, -5, -6], 1, Concat, [1]],
   [-1, 1, Conv, [1024, 1, 1]],
   [-1, 1, MP, []],
   [-1, 1, Conv, [512, 1, 1]],
   [-3, 1, Conv, [512, 1, 1]],
   [-1, 1, Conv, [512, 3, 2]],
   [[-1, -3], 1, Concat, [1]],
   [-1, 1, CNeB, [1024]],
   [-1, 1, Conv, [256, 3, 1]],
  ]

# yolov7 head by yoloair
head:
  [[-1, 1, SPPCSPC, [512]],
   [-1, 1, Conv, [256, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [31, 1, Conv, [256, 1, 1]],
   [[-1, -2], 1, Concat, [1]],
   [-1, 1, C3C2, [128]],
   [-1, 1, Conv, [128, 1, 1]],
   [-1, 1, nn.Upsample, [None, 2, 'nearest']],
   [18, 1, Conv, [128, 1, 1]],
   [[-1, -2], 1, Concat, [1]],
   [-1, 1, C3C2, [128]],
   [-1, 1, MP, []],
   [-1, 1, Conv, [128, 1, 1]],
   [-3, 1, GAMAttention, [128]],
   [-1, 1, Conv, [128, 3, 2]],
   [[-1, -3, 44], 1, Concat, [1]],
   [-1, 1, C3C2, [256]],
   [-1, 1, MP, []],
   [-1, 1, Conv, [256, 1, 1]],
   [-3, 1, Conv, [256, 1, 1]],
   [-1, 1, Conv, [256, 3, 2]],
   [[-1, -3, 39], 1, Concat, [1]],
   [-1, 3, C3C2, [512]],

# 检测头 -----------------------------
   [49, 1, RepConv, [256, 3, 1]],
   [55, 1, RepConv, [512, 3, 1]],
   [61, 1, RepConv, [1024, 3, 1]],

   [[62,63,64], 1, IDetect, [nc, anchors]],   # Detect(P3, P4, P5)
  ]

如果是mish的错误就是pytorch版本不对（重新建一个环境）：

pip install torch==1.12.0+cu113 torchvision==0.13.0+cu113 --extra-index-url https://download.pytorch.org/whl/cu113 


http://www.niftyadmin.cn/n/5040590.html

相关文章

学习记忆——宫殿篇——记忆宫殿——记忆桩——学校

学习记忆——宫殿篇——记忆宫殿——记忆桩——学校

教室 桶 走道 桌子 暖气 窗台 后背 窗帘 监视器 白盒子 教师 讲台 表 投影仪 音响 窗 喇叭 黑板 门 栏杆 椅子 食堂 桶 刷卡器 柱子 桌子 风扇 灯罩 一列椅子 地面 大门空间 电视 活动室 盘子 纸盒 油桶 称 水桶 展牌 帘子 消防栓 毯子 储物箱 宿舍 梯子 坐垫 挂件 吊兰 君子…
阅读更多...
GO语言从入门到实战-Go语言课程介绍

GO语言从入门到实战-Go语言课程介绍

为什么选择 Go 语言来完成这么大一个项目呢？我们不妨回到 Go 语言的源头看一看。 Go 语言的初步设想始于 2007 年，当时 Go 语言的三位创始人是想通过开发一种新型的语言来解决 Google 在软件开发中面临的问题： 多核硬件架构；超大…
阅读更多...
高云FPGA系列教程（10）：letter-shell移植

高云FPGA系列教程（10）：letter-shell移植

文章目录 letter-shell简介letter-shell源码获取letter-shell移植函数和变量应用示例 本文是高云FPGA系列教程的第10篇文章。 shell，中文是外壳的意思，就是操作系统的外壳。通过shell命令可以操作和控制操作系统，比如Linux中的Shell命令就包括…
阅读更多...
Vue2中10种组件通信方式和实践技巧

Vue2中10种组件通信方式和实践技巧

目录 1，props / $emit1.1，一个需求方法1方法2 1.2，v-model 和 .syncv-model.sync 2，$children / $parent3，ref4，$attrs / $listeners$attrs$listenersinheritAttrs1.1 的问题的第3种解决方法 5，…
阅读更多...
TypeScript逆变 ：条件、推断和泛型的应用

TypeScript逆变 ：条件、推断和泛型的应用

TypeScript逆变 ：条件、推断和泛型的应用 1 一个类型问题 有一个名为 test 的函数，它接受两个参数。第一个参数是函数 fn，第二个参数 options 受到 fn 参数的限制。乍一看，这个问题貌似并不复杂，不是吗？糊…
阅读更多...
竞赛选题 基于深度学习的动物识别 - 卷积神经网络 机器视觉 图像识别

竞赛选题 基于深度学习的动物识别 - 卷积神经网络 机器视觉 图像识别

文章目录 0 前言1 背景2 算法原理2.1 动物识别方法概况2.2 常用的网络模型2.2.1 B-CNN2.2.2 SSD 3 SSD动物目标检测流程4 实现效果5 部分相关代码5.1 数据预处理5.2 构建卷积神经网络5.3 tensorflow计算图可视化5.4 网络模型训练5.5 对猫狗图像进行2分类 6 最后 0 前言 &#…
阅读更多...
nvm下载安装教程

nvm下载安装教程

前言 nvm 官网地址：https://nvm.uihtm.com 一、nvm 下载 进入 nvm github 地址，下载最新版本：https://github.com/coreybutler/nvm-windows/releases 点击选择当前最新版本。 滑动到底部，点击 nvm-setup.exe 下载安装文件。 接…
阅读更多...
Idea操作Git合并另一个分支的部分提交

Idea操作Git合并另一个分支的部分提交

现有master、dev两个分支，master有提交1、2、3、4、5、6、7，dev是从master提交的3拉出来的分支（Reset Current Branch to Here…，Mixed模式），有提交1、2、3，现在的需求是dev分支只需要合并maste…
阅读更多...
力扣刷题-数组-另一种双指针-有序数组的平方

力扣刷题-数组-另一种双指针-有序数组的平方

给你一个按 非递减顺序 排序的整数数组 nums，返回 每个数字的平方 组成的新数组，要求也按 非递减顺序 排序。 示例 1： 输入：nums [-4,-1,0,3,10] 输出：[0,1,9,16,100] 解释：平方后，数组变为 [1…
阅读更多...
YOLOv5，YOLOv8添加ASFF（自适应空间特征融合）

YOLOv5，YOLOv8添加ASFF（自适应空间特征融合）

ASFF：Adaptively Spatial Feature Fusion (自适应空间特征融合) 论文来源：Learning Spatial Fusion for Single-Shot Object Detection 代码地址：ASFF 1.背景 不同特征尺度之间的不一致性是基于特征金字塔的单阶段检测器的主要缺陷。 本文…
阅读更多...
云可观测性：提升云环境中应用程序可靠性

云可观测性：提升云环境中应用程序可靠性

随着云计算的兴起和广泛应用，越来越多的企业将其应用程序和服务迁移到云环境中。在这个高度动态的环境中，确保应用程序的可靠性和可管理性成为了一个迫切的需求。云可观测性作为一种解决方案，针对这一需求提供了有效的方法和工具。本文将介绍…
阅读更多...
【UE 粒子练习】07——创建动画拖尾类型粒子

【UE 粒子练习】07——创建动画拖尾类型粒子

效果 步骤 1. 将动画序列“Idle_ModifyBones”添加到场景中 2. 新建一个材质，命名为“Mat_AnimTrails” 材质混合模式设置为半透明，着色模型设置为无光照，设置材质为双面 材质节点如下 3. 新建一个粒子系统，命名为“P_AnimTrail”…
阅读更多...
JavaScript学习记录 | DOM事件流 事件冒泡-事件捕获-事件委托

JavaScript学习记录 | DOM事件流 事件冒泡-事件捕获-事件委托

目录 DOM事件流常见面试题事件冒泡与事件捕获事件冒泡使用场景事件捕获使用场景事件冒泡和事件捕获区别 事件委托 - 利用事件冒泡机制事件委托应用场景支持事件委托的事件事件委托的优缺点 DOM事件流 DOM事件流的三个阶段：捕获阶段 -> 目标阶段 -> 冒泡阶段 …
阅读更多...
用户与权限管理

用户与权限管理

文章目录 用户与权限管理1. 用户管理1.1 MYSQL用户1.2 登录MySQL服务器1.3 创建用户1.4 修改用户1.5 删除用户1.6 修改密码1. 修改当前用户密码2. 修改其他用户密码 1.7 MYSQL8密码管理 2. 权限管理2.1 权限列表2.2 授予权限的原则2.3 授予权限2.4 查看权限2.5 收回权限 3. 权限…
阅读更多...
Vue 使用vue-cli构建SPA项目（超详细）

Vue 使用vue-cli构建SPA项目（超详细）

目录 一、什么是vue-cli 二，构建SPA项目 三、 运行SPA项目 前言： 在我们搭建SPA项目时候，我们必须去检查我们是否搭建好NodeJS环境 cmd窗口输入以下指令：去检查 node -v npm -v 一、什么是vue-cli Vue CLI（Vu…
阅读更多...
C语言基础知识点（九）数据类型溢出

C语言基础知识点（九）数据类型溢出

char a101; int sum200; a27;suma; printf("%d\n",sum); 参考答案：D 72. char类型的范围是-128---127，当a27 ，之后a的值超出可表示范围会变为-128. a为char型,-128~127,a101,a27后溢出a-128: a127时不溢出 01111111(127补码)…
阅读更多...
最新文章

Copyright @ 2022~2023