YOLO11改进|卷积篇|引入线性可变形卷积LDConv

news2024/11/22 9:53:33

在这里插入图片描述

目录

    • 一、【LDConv】卷积
      • 1.1【LDConv】卷积介绍
      • 1.2【LDConv】核心代码
    • 二、添加【LDConv】卷积
      • 2.1STEP1
      • 2.2STEP2
      • 2.3STEP3
      • 2.4STEP4
    • 三、yaml文件与运行
      • 3.1yaml文件
      • 3.2运行成功截图

一、【LDConv】卷积

1.1【LDConv】卷积介绍

在这里插入图片描述

下图是【LDCNV】的结构图,让我们简单分析一下运行过程和优势

  • 工作流程:
  • 输入处理(Input):输入是一个大小为 𝐶×𝐻×𝑊的特征图。
  • 卷积生成偏移量(Conv2d for Offset Generation):通过一次常规卷积操作(Conv2D)来生成对应的 偏移量(Offsets)。这些偏移量的形状为 2𝑁×𝐻×𝑊,其中 𝑁表示采样点的数量(通常是卷积核大小的平方,如3x3卷积核对应9个点)。生成的偏移会调整特征图中每个位置的采样点。
  • 生成采样点(Generating Sample Points):使用一个基准采样网格,这个网格基于常规卷积核位置的坐标定义。然后,利用之前生成的偏移量对这些采样点进行调整,形成修正后的采样点。
  • Resample(重采样):对于每个输入点,在其修正后的坐标上进行特征的采样,这就是“Deformable”卷积的核心机制。在每个卷积核的操作中,使用修正后的采样点来替代原本的固定采样点。
  • 卷积和激活(Convolution and Activation):完成采样后,经过卷积操作,并附加常规的归一化(Normalization) 和 激活(Activation,如SiLU),生成输出特征图。
  • 偏移坐标的计算流程(Offset Calculation Process):在下面的图中展示了如何将初始的采样点与偏移量相加,得到修正后的坐标。这些修正后的坐标决定了如何对输入特征图进行采样,确保每个点的采样位置根据输入内容动态变化。
  • 优势:
  • 动态感知:传统卷积在处理图像时,采样位置是固定的,限制了它对形变或非规则几何结构的适应能力。而偏移卷积通过引入动态采样点,能够自适应调整每个采样点的坐标,使得模型在面对形变、不规则目标时,依然能保持良好的特征提取能力。
  • 提升空间建模能力:由于偏移卷积允许采样点在二维空间内自由移动,这使得它可以捕捉到更复杂的空间依赖关系,尤其是那些传统卷积难以处理的局部信息(例如边界或角落的特征)。
  • 提高特征表达能力:修正采样点的位置,可以让卷积操作更精准地聚焦于感兴趣的区域,提高特征图中的重要信息的表达和捕捉能力。
  • 增强模型的鲁棒性:在面对目标发生旋转、缩放或其他形变时,偏移卷积提供了额外的灵活性,确保特征提取过程不受形变影响。这使得模型在处理各种复杂场景时具有更好的鲁棒性在这里插入图片描述

1.2【LDConv】核心代码

import torch.nn as nn
import torch
from einops import rearrange
import math
 
 
class LDConv(nn.Module):
    def __init__(self, inc, outc, num_param, stride=1, bias=None):
        super(LDConv, self).__init__()
        self.num_param = num_param
        self.stride = stride
        self.conv = nn.Sequential(nn.Conv2d(inc, outc, kernel_size=(num_param, 1), stride=(num_param, 1), bias=bias),
                                  nn.BatchNorm2d(outc),
                                  nn.SiLU())  # the conv adds the BN and SiLU to compare original Conv in YOLOv5.
        self.p_conv = nn.Conv2d(inc, 2 * num_param, kernel_size=3, padding=1, stride=stride)
        nn.init.constant_(self.p_conv.weight, 0)
        self.p_conv.register_full_backward_hook(self._set_lr)
 
    @staticmethod
    def _set_lr(module, grad_input, grad_output):
        grad_input = (grad_input[i] * 0.1 for i in range(len(grad_input)))
        grad_output = (grad_output[i] * 0.1 for i in range(len(grad_output)))
 
    def forward(self, x):
        # N is num_param.
        offset = self.p_conv(x)
        dtype = offset.data.type()
        N = offset.size(1) // 2
        # (b, 2N, h, w)
        p = self._get_p(offset, dtype)
 
        # (b, h, w, 2N)
        p = p.contiguous().permute(0, 2, 3, 1)
        q_lt = p.detach().floor()
        q_rb = q_lt + 1
 
        q_lt = torch.cat([torch.clamp(q_lt[..., :N], 0, x.size(2) - 1), torch.clamp(q_lt[..., N:], 0, x.size(3) - 1)],
                         dim=-1).long()
        q_rb = torch.cat([torch.clamp(q_rb[..., :N], 0, x.size(2) - 1), torch.clamp(q_rb[..., N:], 0, x.size(3) - 1)],
                         dim=-1).long()
        q_lb = torch.cat([q_lt[..., :N], q_rb[..., N:]], dim=-1)
        q_rt = torch.cat([q_rb[..., :N], q_lt[..., N:]], dim=-1)
 
        # clip p
        p = torch.cat([torch.clamp(p[..., :N], 0, x.size(2) - 1), torch.clamp(p[..., N:], 0, x.size(3) - 1)], dim=-1)
 
        # bilinear kernel (b, h, w, N)
        g_lt = (1 + (q_lt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_lt[..., N:].type_as(p) - p[..., N:]))
        g_rb = (1 - (q_rb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_rb[..., N:].type_as(p) - p[..., N:]))
        g_lb = (1 + (q_lb[..., :N].type_as(p) - p[..., :N])) * (1 - (q_lb[..., N:].type_as(p) - p[..., N:]))
        g_rt = (1 - (q_rt[..., :N].type_as(p) - p[..., :N])) * (1 + (q_rt[..., N:].type_as(p) - p[..., N:]))
 
        # resampling the features based on the modified coordinates.
        x_q_lt = self._get_x_q(x, q_lt, N)
        x_q_rb = self._get_x_q(x, q_rb, N)
        x_q_lb = self._get_x_q(x, q_lb, N)
        x_q_rt = self._get_x_q(x, q_rt, N)
 
        # bilinear
        x_offset = g_lt.unsqueeze(dim=1) * x_q_lt + \
                   g_rb.unsqueeze(dim=1) * x_q_rb + \
                   g_lb.unsqueeze(dim=1) * x_q_lb + \
                   g_rt.unsqueeze(dim=1) * x_q_rt
 
        x_offset = self._reshape_x_offset(x_offset, self.num_param)
        out = self.conv(x_offset)
 
        return out
 
    # generating the inital sampled shapes for the LDConv with different sizes.
    def _get_p_n(self, N, dtype):
        base_int = round(math.sqrt(self.num_param))
        row_number = self.num_param // base_int
        mod_number = self.num_param % base_int
        p_n_x, p_n_y = torch.meshgrid(
            torch.arange(0, row_number),
            torch.arange(0, base_int))
        p_n_x = torch.flatten(p_n_x)
        p_n_y = torch.flatten(p_n_y)
        if mod_number > 0:
            mod_p_n_x, mod_p_n_y = torch.meshgrid(
                torch.arange(row_number, row_number + 1),
                torch.arange(0, mod_number))
 
            mod_p_n_x = torch.flatten(mod_p_n_x)
            mod_p_n_y = torch.flatten(mod_p_n_y)
            p_n_x, p_n_y = torch.cat((p_n_x, mod_p_n_x)), torch.cat((p_n_y, mod_p_n_y))
        p_n = torch.cat([p_n_x, p_n_y], 0)
        p_n = p_n.view(1, 2 * N, 1, 1).type(dtype)
        return p_n
 
    # no zero-padding
    def _get_p_0(self, h, w, N, dtype):
        p_0_x, p_0_y = torch.meshgrid(
            torch.arange(0, h * self.stride, self.stride),
            torch.arange(0, w * self.stride, self.stride))
 
        p_0_x = torch.flatten(p_0_x).view(1, 1, h, w).repeat(1, N, 1, 1)
        p_0_y = torch.flatten(p_0_y).view(1, 1, h, w).repeat(1, N, 1, 1)
        p_0 = torch.cat([p_0_x, p_0_y], 1).type(dtype)
 
        return p_0
 
    def _get_p(self, offset, dtype):
        N, h, w = offset.size(1) // 2, offset.size(2), offset.size(3)
 
        # (1, 2N, 1, 1)
        p_n = self._get_p_n(N, dtype)
        # (1, 2N, h, w)
        p_0 = self._get_p_0(h, w, N, dtype)
        p = p_0 + p_n + offset
        return p
 
    def _get_x_q(self, x, q, N):
        b, h, w, _ = q.size()
        padded_w = x.size(3)
        c = x.size(1)
        # (b, c, h*w)
        x = x.contiguous().view(b, c, -1)
 
        # (b, h, w, N)
        index = q[..., :N] * padded_w + q[..., N:]  # offset_x*w + offset_y
        # (b, c, h*w*N)
        index = index.contiguous().unsqueeze(dim=1).expand(-1, c, -1, -1, -1).contiguous().view(b, c, -1)
 
        x_offset = x.gather(dim=-1, index=index).contiguous().view(b, c, h, w, N)
 
        return x_offset
 
    #  Stacking resampled features in the row direction.
    @staticmethod
    def _reshape_x_offset(x_offset, num_param):
        b, c, h, w, n = x_offset.size()
        x_offset = rearrange(x_offset, 'b c h w n -> b c (h n) w')
        return x_offset

二、添加【LDConv】卷积

2.1STEP1

首先找到ultralytics/nn文件路径下新建一个Add-module的python文件包【这里注意一定是python文件包,新建后会自动生成_init_.py】,如果已经跟着我的教程建立过一次了可以省略此步骤,随后新建一个LDConv.py文件并将上文中提到的注意力机制的代码全部粘贴到此文件中,如下图所示在这里插入图片描述

2.2STEP2

在STEP1中新建的_init_.py文件中导入增加改进模块的代码包如下图所示在这里插入图片描述

2.3STEP3

找到ultralytics/nn文件夹中的task.py文件,在其中按照下图添加在这里插入图片描述

2.4STEP4

定位到ultralytics/nn文件夹中的task.py文件中的def parse_model(d, ch, verbose=True): # model_dict, input_channels(3)函数添加如图代码,【如果不好定位可以直接ctrl+f搜索定位】

在这里插入图片描述

三、yaml文件与运行

3.1yaml文件

以下是添加【LDConv】注意力机制在Backbone中的yaml文件,大家可以注释自行调节,效果以自己的数据集结果为准

# Ultralytics YOLO 🚀, AGPL-3.0 license
# YOLO11 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=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  # [depth, width, max_channels]
  n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs

# YOLO11n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, LDConv, [128,3,2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, LDConv, [256,3,2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, LDConv, [512,3,2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, LDConv, [1024,3,2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

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

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

以上添加位置仅供参考,具体添加位置以及模块效果以自己的数据集结果为准

3.2运行成功截图

在这里插入图片描述

OK 以上就是添加【LDConv】卷积的全部过程了,后续将持续更新尽情期待

在这里插入图片描述

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

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

相关文章

Mysql高级篇(下)——主从复制

主从复制 一、概述二、作用🎈 场景示例🎈 综合示例 三、原理🎈 主从复制基本原则🎈 主从复制存在的问题 四、一主一从架构搭建🌱准备工作🌞步骤1. 配置主库(Master)2. 配置从库&…

如何搭建基于大模型的智能知识库

自从2022年底ChatGPT横空出世引爆了大模型技术浪潮,时至今日已经一年有余,如何从技术侧向商业侧落地转化是一直以来业内普遍关注的问题。 从目前企业端观察到的情况来看,基于大模型的知识库是一个比较有潜力和价值的应用场景,能够…

落伍警告:不了解AI Agent,你可能会被编程界淘汰

AI Agent火爆到什么程度? OpenAI创始人奥特曼预测,未来各行各业,每一个人都可以拥有一个AI Agent;比尔盖茨在2023年层预言:AI Agent将彻底改变人机交互方式,并颠覆整个软件行业;吴恩达教授在AI…

UE5 武器IK瞄准系统

创建空项目 创建基础蓝图类My_GameMode,My_HUD,My_PlayChar,My_PlayController 项目设置地图模式 近裁平面 0.1 My_PlayChar蓝图中添加摄像机,角色骨骼网格体,武器骨骼网格体 编辑角色骨骼,预览控制器使用特定动画,动画选择ANM_ark-47-Idle hand_r 添加插槽WeaponMes…

Stable Diffusion绘画 | 如何做到不同动作表情,人物角色保持一致性(下篇)

在 人物角色保持一致性(上篇)中,我们已经得到了自己创造的角色的各个角度头像图片: 从中选择一个符合自己需求的角度,截图保存,例如下图: 更换人物表情 进入到「图生图」页面,把上一…

短视频时代,网站建设存在的意义还有多大?

在短视频时代,网站建设的存在意义依然具有多方面的价值和作用。尽管短视频作为一种新兴的传播方式迅速发展并受到广泛欢迎,但网站作为互联网的基础设施之一,仍然在许多领域发挥着不可替代的作用。以下是具体分析: 信息深度与完整性…

医院管理新思维:Spring Boot技术应用

5系统详细实现 5.1 医生模块的实现 5.1.1 病床信息管理 医院管理系统的医生可以管理病床信息,可以对病床信息添加修改删除操作。具体界面的展示如图5.1所示。 图5.1 病床信息管理界面 5.1.2 药房信息管理 医生可以对药房信息进行添加,修改,…

开源项目带来的思考

分享一位在Hacker News上的一个帖子,该开源作者在Github上年收入达到10万美元,你不得不承认,个人开源项目的影响力还是很大的。 这条帖子讲述了一位Laravel的开发者,是如何在Github上做到年收入10万美元。该帖子一发布&#xff0c…

rust使用tokio

Rust 是一种系统编程语言,它强调安全、并发和高性能。tokio 是一个基于 Rust 的异步运行时库,专门用于构建异步应用程序。使用 tokio 可以轻松地管理异步任务,并实现高效的并发。 添加依赖: cargo add tokio -F full 示例: 示例1: fn main() {let rt = tokio::runti…

RabbitMQ事务模块

目录 消息分发​​​​​​​ 负载均衡 幂等性保障 顺序性保障 顺序性保障方案 二号策略:分区消费 三号策略:消息确认机制 四号策略: 消息积压 RabbitMQ集群 选举过程 RabbitMQ是基于AMQP协议实现的,该协议实现了事务机制,要么全部成功,要么全…

软件设计师:03操作系统原理

文章目录 一、操作系统地位图二、前趋图(PV操作)三、移臂调度算法(1)最短移臂调度算法(2)先来先服务(3)最短寻道时间优先(4)扫描算法或电梯调度算法&#xff…

大模型~合集8

我自己的原文哦~ https://blog.51cto.com/whaosoft/11566472 # From r to Q∗ 这就是OpenAI神秘的Q*?斯坦福:语言模型就是Q函数 近日,斯坦福大学一个团队的一项新研究似乎为这一研究方向的潜力提供了佐证,其声称现在已经取得非…

【Linux-基础IO】磁盘的存储管理详解

磁盘的存储管理 由于一个磁盘中包含了大量的扇区,为了方便管理,我们对磁盘进行了分区,其中每个分区又进一步划分为多个块组(Block Group),每个块组中包含该块组的数据存储情况以及具体的数据 假设有一个8…

分层解耦-01.三层架构

一.对案例的思考 所有的代码都在这一个controller文件中,虽然该代码不复杂。但是如果针对大型项目,代码会很复杂。而且不利于项目的维护,复用性差。因此要修改该代码,使其满足维护方便,复用性好的特点。因此要用到一个…

VMware ESXi更改https的TLS协议版本

简要概述 TLS 1.0 和 1.1 是已弃用的协议,具有广为人知的缺点和漏洞。应在所有接口上启用 TLS 1.2,并在支持的情况下禁用 SSLv3、TL 1.1 和 1.0。强制要求 TLS 1.2 可能会破坏 vSphere 的第三方集成和加载项。在实施 TLS 1.2 后仔细测试这些集成&#x…

游戏报错x3daudio1_7.dll缺失怎么回事?总结几个有效解决方法分享

1. x3daudio1_7.dll 简介 1.1 定义 x3daudio1_7.dll 是一个动态链接库(DLL)文件,它与 Microsoft DirectX 音频组件紧密相关。该文件主要负责处理三维(3D)音频效果,提供给游戏和多媒体应用程序以增强用户体…

HDLBits中文版,标准参考答案 | 3.1.2 Multiplexers | 多路复用器

关注 望森FPGA 查看更多FPGA资讯 这是望森的第 9 期分享 作者 | 望森 来源 | 望森FPGA 目录 1 2-to-1 multiplexer | 2 对 1 多路复用器 2 2-to-1 bus multiplexer | 2 对 1 总线多路复用器 3 9-to-1 multiplexer | 9 对 1 多路复用器 4 256-to-1 multiplexer | 256 对 …

CPU、GPU、显卡

CPU VS GPUCPU(Central Processing Unit),中央处理器GPU(Graphics Processing Unit),图形处理单元GPU 的技术演变CUDA(Compute Unified Device Architecture) 显卡(Video…

【数据结构与算法】Greedy Algorithm

1) 贪心例子 称之为贪心算法或贪婪算法,核心思想是 将寻找最优解的问题分为若干个步骤每一步骤都采用贪心原则,选取当前最优解因为没有考虑所有可能,局部最优的堆叠不一定让最终解最优 贪心算法是一种在每一步选择中都采取在当前状态下最好…

华为OD机试 - 冠亚军排名(Python/JS/C/C++ 2024 E卷 100分)

华为OD机试 2024E卷题库疯狂收录中,刷题点这里 专栏导读 本专栏收录于《华为OD机试真题(Python/JS/C/C)》。 刷的越多,抽中的概率越大,私信哪吒,备注华为OD,加入华为OD刷题交流群,…