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

于 2024-10-07 11:15:37 发布
阅读量466 收藏 6
点赞数 10
分类专栏： YOLO11改进专栏 文章标签： 计算机视觉 深度学习 人工智能 YOLO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1983Z/article/details/142737153
版权

在这里插入图片描述

目录

一、【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】卷积的全部过程了，后续将持续更新尽情期待

在这里插入图片描述

如果能为勤奋颁奖
关注
专栏目录
YOLOv11改进 | Conv篇 | YOLOv11引入24年最新卷积模块LDConv
tsg6698的博客
10-04 183
针对上述问题，本文提出了一种线性可变形卷积算法（LDConv），该算法为卷积核提供了任意数目的参数和任意的采样形状，从而为网络开销和性能之间的权衡提供了更丰富的选择。在LDConv中，定义了一种新的坐标生成算法，用于为任意大小的卷积核生成不同的初始采样位置。到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv11改进有效涨点专栏，本专栏目前为新开的，后期我会根据各种前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~
YOLOv10改进 | Conv篇 | YOLOv10引入24年最新卷积模块LDConv
tsg6698的博客
09-04 735
针对上述问题，本文提出了一种线性可变形卷积算法（LDConv），该算法为卷积核提供了任意数目的参数和任意的采样形状，从而为网络开销和性能之间的权衡提供了更丰富的选择。综上LDConv模块通过其独特的设计和创新点，克服了传统卷积操作和Deformable Conv的局限性，实现了更高效、灵活的特征提取能力，为提升卷积神经网络的性能提供了新的可能性。线性增长的参数数量：LDConv通过生成不同初始采样位置的卷积核，使卷积参数的数量呈现线性增长趋势，从而更好地适应目标形状的变化。
YOLO11改进|卷积篇|引入可变核卷积AKConv
A1983Z的博客
10-02 942
YOLO11中添加AKConv卷积
YOLOv5改进 | 卷积模块| 可变形卷积DCN【CVPR2017】
kay_545
06-26 1082
yolov5，yolov5改进，DCNConv
YOLO11改进|注意力机制篇|引入MLCA轻量级注意力机制
A1983Z的博客
10-01 1461
YOLO11中添加MLCA轻量级注意力机制
YOLOv8改进 | 卷积模块 | 用DWConv卷积替换Conv【轻量化网络】
kay_545
05-18 2289
YOLOv8改进，yolov8，yolov8创新，yolov8涨点
YOLOv5改进 | 卷积模块| 动态卷积模块ODConv【完整代码 + 小白必备】
kay_545
07-01 1202
yolov5涨点，yolov5，ODConv卷积
YOLO | 全维动态卷积 (ODConv)
走向CTO的路上...
05-17 1083
全维动态卷积 (ODConv) 是一种新颖的卷积神经网络 (CNN) 架构，引入动态注意力机制来增强特征表示并提高目标检测性能。它将动态卷积的概念扩展到多个维度，从而实现更灵活、更自适应的特征提取。ODConv 是一种新颖的动态卷积神经网络架构，通过引入动态注意力机制来增强特征表示并提高目标检测性能。它将动态卷积的概念扩展到多个维度，从而实现更灵活、更自适应的特征提取。ODConv 在各种目标检测任务中表现出显着的有效性，尤其是在具有复杂背景或小对象的场景中。
YOLOv8改进 | Conv篇 | YOLOv8引入24年最新卷积模块LDConv(轻量)
tsg6698的博客
09-04 545
针对上述问题，本文提出了一种线性可变形卷积算法（LDConv），该算法为卷积核提供了任意数目的参数和任意的采样形状，从而为网络开销和性能之间的权衡提供了更丰富的选择。综上LDConv模块通过其独特的设计和创新点，克服了传统卷积操作和Deformable Conv的局限性，实现了更高效、灵活的特征提取能力，为提升卷积神经网络的性能提供了新的可能性。线性增长的参数数量：LDConv通过生成不同初始采样位置的卷积核，使卷积参数的数量呈现线性增长趋势，从而更好地适应目标形状的变化。
YOLO11改进 | 卷积模块 | 添加选择性内核SKConv【附完整代码一键运行】
kay_545
10-03 685
yolo11，yolo11改进，SKConv
YOLOv10改进 | Conv改进篇 | YOLOv10引入LDConv卷积和C2f-LDConv全网独家创新(来自SCI 2024）
qq_45972324的博客
09-06 239
摘要：基于卷积运算的神经网络在深度学习领域取得了显著的成果，但标准卷积运算存在两个固有缺陷。一方面，卷积运算局限于本地窗口，因此无法从其他位置捕获信息，并且其采样的形状是固定的。另一方面，卷积核的大小固定为 k × k，这是一个固定的方形，参数的数量往往随着大小而增长。虽然 Deformable Convolution （Deformable Conv） 解决了标准卷积的固定采样问题，但参数的数量也趋于平方增长，Deformable Conv 没有探索不同初始样本形状对网络性能的影响。
ade20k 街景图像【数据集】及其【论文出处】ADE20K数据集 超过25000张图像的语义分割数据集
阿利同学的博客
10-04 717
ade20k 街景图像【数据集】及其【论文出处】ADE20K数据集是一个包含超过25000张图像的语义分割数据集，这些图像被密集注释，覆盖室内和室外场景。 它由MIT发布，包含100个事物类别和50个物质类别， 用于训练和验证的图像数量分别为20210和2000。 ADE20K数据集的特点包括丰富的场景多样性和详细的语义标注，使得它成为训练和评估语义分割模型的重要资源。 数据集组成： ADE20K数据集分为训练集、验证集和测试集，其中训练集包含20,210张图像，验证集包含2,000张图像。测试集的图像
红外画面空中目标检测系统源码分享
xuehaishijue的博客
10-02 1280
数据集信息展示在现代计算机视觉领域，尤其是在空中目标检测的研究中，数据集的构建与选择至关重要。本研究所采用的数据集名为“Air Vehicles”，专门针对红外画面中的空中目标检测任务而设计。该数据集包含四个主要类别，分别是“Airplane”（飞机）、“Bird”（鸟类）、“Drone”（无人机）和“Helicopter”（直升机）。这些类别的选择不仅涵盖了多种常见的空中目标，还反映了当前无人机技术和航空活动的快速发展。
[C#]C# winform部署yolov11目标检测的onnx模型
FL1623863129的博客
10-03 1028
最后运行项目选择x64 Debug即可，由于初次运行可能报错，如果报错请查看https://blog.csdn.net/FL1623863129/article/details/135424751。（2）下载模型：https://github.com/ultralytics/assets/releases/download/v8.3.0/yolo11n.pt。（4）然后将yolo11.onnx模型放进FIRC\bin\x64\Debug\weights。
【目标检测】集装箱编码检测数据集3420张VOC+YOLO格式
最新发布
lwx666sl的博客
10-06 259
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：3427。标注数量(xml文件个数)：3427。标注数量(txt文件个数)：3427。标注类别名称:["number"]number 框数 = 3449。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
51c视觉~CV~合集2
whaosoft~aiotの开发板商城
10-04 1304
作者提出只依据已有的正常表面图像样本，通过一定的技术手段对缺陷样本进行检测，很好的将最近研究火热的GAN应用于框架中，这一年，课题组的老师也一直讨论这种方法的可行性，缺陷的检测要不要有缺陷样本，从稀疏自编码，小样本学习再到计算机视觉研究热点之一的零样本学习，得出结论：大多数工业产品表面缺陷检测是需要缺陷样本或者人为制作的缺陷样本，论文虽然是没有直接使用生产线上的缺陷样本，但是通过算法人为的产生了缺陷样本，并很好的融合和GAN在图像修复领域的强大能力，整个框架的设计很巧妙。使用前需要先安装 SAM 2。
计算机视觉（CV）技术的优势和挑战
mwssx的博客
10-01 567
计算机视觉（CV）技术是研究和开发让计算机能够“看”和理解图像和视频的技术。它在许多领域具有广泛的应用，包括自动驾驶车辆、医学影像分析、安防监控等。这些例子说明了计算机视觉技术的优势和挑战，同时也展示了该技术在各个领域中的潜力和发展方向。
YOLOv7改进：Unified-loU，用于高品质目标检测的统一loU ，2024年8月最新IoU
09-29 281
Unified-loU，用于高品质目标检测的统一loU ，2024年8月最新IoU
目标检测 DETR（2020）
qq_51352130的博客
09-29 1203
DETR全称是Detection Transformer，是首个基于Transformer的端到端目标检测网络，最大的特点就是不需要预定义的先验anchor，也不需要NMS的后处理策略（少了这两部分可以少很多的超参数和计算），用集合的思想回归出100个query之后再用匈牙利算法二分图匹配的方式得到最终的正样本和负样本，第一个实现了端到端的目标检测。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值