YOLO11改进|注意力机制篇|引入大核可分离卷积注意力块LSKA

于 2024-10-07 12:02:29 发布
阅读量660 收藏 10
点赞数 16
分类专栏： YOLO11改进专栏 文章标签： 神经网络 cnn YOLO
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A1983Z/article/details/142737858
版权

在这里插入图片描述

目录

一、【LSKA】注意力机制

1.1【LSKA】注意力介绍

在这里插入图片描述

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

(a) LKA-trivial:
工作流程：这个模块使用一个 𝑘×𝑘的深度可分离卷积（DW-Conv）来提取局部空间信息，之后再通过 1×1的卷积进行通道融合。最后将输入特征与经过卷积操作后的特征进行加法操作（残差连接）。
优势：这种设计简单且高效，通过深度卷积提取局部特征，再通过 1×1卷积整合不同通道的信息，能够有效减少计算量，同时保持良好的局部特征提取能力。
(b) LSKA-trivial:
工作流程：使用两个深度卷积操作，分别是 1×(2𝑑−1)和 (2𝑑−1)×1的卷积。这些卷积核通过不对称的卷积来捕获更多的局部信息。同样，在卷积操作后通过 1×1的卷积来整合通道信息，并使用残差连接将输入特征与输出相加。
优势：通过不对称的卷积设计，LSKA-trivial 可以扩大感受野，并且以较低的计算代价捕获更多的局部特征。
相对于 LKA-trivial，LSKA-trivial 的不对称卷积增强了对不同方向信息的捕捉能力，适合处理具有方向性变化的特征图。
© LKA:
工作流程：首先使用 1×(2𝑑−1)和 (2𝑑−1)×1的不对称卷积，之后引入了两个深度动态卷积（DW-D-Conv），它们的卷积核大小基于 𝑘/𝑑的比例计算。最后同样使用 1×1卷积进行通道融合，并通过残差连接将输入与输出相加。
优势：相较于 LSKA-trivial，LKA 模块在引入动态卷积（DW-D-Conv）的基础上，使得卷积核的大小能够适应输入特征图的变化，从而在保持高效计算的同时，增强了特征提取的自适应性。这种设计特别适用于需要同时处理细节信息和全局上下文的任务。
(d) LSKA:
工作流程：这是最复杂的结构，首先使用 1×(2𝑑−1)和 (2𝑑−1)×1
卷积，接着引入了两层动态卷积（DW-D-Conv），它们分别根据 𝑘/𝑑和 𝑘/𝑑的比例对卷积核大小进行调整。最后通过 1×1卷积整合通道信息，并与输入特征进行残差连接。
优势：LSKA 模块通过更多层次的动态卷积，使得其感受野进一步扩大，同时能够自适应地调整卷积核大小。这种多层设计确保了该模块不仅能够捕获局部的细节特征，同时具备很强的全局建模能力。
适合处理多尺度信息丰富且具有复杂局部结构的任务。
在这里插入图片描述

1.2【LSKA】核心代码

import torch
import torch.nn as nn
 
 
class LSKA(nn.Module):
    def __init__(self, dim, k_size=7):
        super().__init__()
 
        self.k_size = k_size
 
        if k_size == 7:
            self.conv0h = nn.Conv2d(dim, dim, kernel_size=(1, 3), stride=(1,1), padding=(0,(3-1)//2), groups=dim)
            self.conv0v = nn.Conv2d(dim, dim, kernel_size=(3, 1), stride=(1,1), padding=((3-1)//2,0), groups=dim)
            self.conv_spatial_h = nn.Conv2d(dim, dim, kernel_size=(1, 3), stride=(1,1), padding=(0,2), groups=dim, dilation=2)
            self.conv_spatial_v = nn.Conv2d(dim, dim, kernel_size=(3, 1), stride=(1,1), padding=(2,0), groups=dim, dilation=2)
        elif k_size == 11:
            self.conv0h = nn.Conv2d(dim, dim, kernel_size=(1, 3), stride=(1,1), padding=(0,(3-1)//2), groups=dim)
            self.conv0v = nn.Conv2d(dim, dim, kernel_size=(3, 1), stride=(1,1), padding=((3-1)//2,0), groups=dim)
            self.conv_spatial_h = nn.Conv2d(dim, dim, kernel_size=(1, 5), stride=(1,1), padding=(0,4), groups=dim, dilation=2)
            self.conv_spatial_v = nn.Conv2d(dim, dim, kernel_size=(5, 1), stride=(1,1), padding=(4,0), groups=dim, dilation=2)
        elif k_size == 23:
            self.conv0h = nn.Conv2d(dim, dim, kernel_size=(1, 5), stride=(1,1), padding=(0,(5-1)//2), groups=dim)
            self.conv0v = nn.Conv2d(dim, dim, kernel_size=(5, 1), stride=(1,1), padding=((5-1)//2,0), groups=dim)
            self.conv_spatial_h = nn.Conv2d(dim, dim, kernel_size=(1, 7), stride=(1,1), padding=(0,9), groups=dim, dilation=3)
            self.conv_spatial_v = nn.Conv2d(dim, dim, kernel_size=(7, 1), stride=(1,1), padding=(9,0), groups=dim, dilation=3)
        elif k_size == 35:
            self.conv0h = nn.Conv2d(dim, dim, kernel_size=(1, 5), stride=(1,1), padding=(0,(5-1)//2), groups=dim)
            self.conv0v = nn.Conv2d(dim, dim, kernel_size=(5, 1), stride=(1,1), padding=((5-1)//2,0), groups=dim)
            self.conv_spatial_h = nn.Conv2d(dim, dim, kernel_size=(1, 11), stride=(1,1), padding=(0,15), groups=dim, dilation=3)
            self.conv_spatial_v = nn.Conv2d(dim, dim, kernel_size=(11, 1), stride=(1,1), padding=(15,0), groups=dim, dilation=3)
        elif k_size == 41:
            self.conv0h = nn.Conv2d(dim, dim, kernel_size=(1, 5), stride=(1,1), padding=(0,(5-1)//2), groups=dim)
            self.conv0v = nn.Conv2d(dim, dim, kernel_size=(5, 1), stride=(1,1), padding=((5-1)//2,0), groups=dim)
            self.conv_spatial_h = nn.Conv2d(dim, dim, kernel_size=(1, 13), stride=(1,1), padding=(0,18), groups=dim, dilation=3)
            self.conv_spatial_v = nn.Conv2d(dim, dim, kernel_size=(13, 1), stride=(1,1), padding=(18,0), groups=dim, dilation=3)
        elif k_size == 53:
            self.conv0h = nn.Conv2d(dim, dim, kernel_size=(1, 5), stride=(1,1), padding=(0,(5-1)//2), groups=dim)
            self.conv0v = nn.Conv2d(dim, dim, kernel_size=(5, 1), stride=(1,1), padding=((5-1)//2,0), groups=dim)
            self.conv_spatial_h = nn.Conv2d(dim, dim, kernel_size=(1, 17), stride=(1,1), padding=(0,24), groups=dim, dilation=3)
            self.conv_spatial_v = nn.Conv2d(dim, dim, kernel_size=(17, 1), stride=(1,1), padding=(24,0), groups=dim, dilation=3)
 
        self.conv1 = nn.Conv2d(dim, dim, 1)
 
    def forward(self, x):
        u = x.clone()
        attn = self.conv0h(x)
        attn = self.conv0v(attn)
        attn = self.conv_spatial_h(attn)
        attn = self.conv_spatial_v(attn)
        attn = self.conv1(attn)
        return u * attn
 
 
def autopad(k, p=None, d=1):  # kernel, padding, dilation
    """Pad to 'same' shape outputs."""
    if d > 1:
        k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
    if p is None:
        p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
    return p
 
 
class Conv(nn.Module):
    """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
    default_act = nn.SiLU()  # default activation
 
    def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
        """Initialize Conv layer with given arguments including activation."""
        super().__init__()
        self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
        self.bn = nn.BatchNorm2d(c2)
        self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
 
    def forward(self, x):
        """Apply convolution, batch normalization and activation to input tensor."""
        return self.act(self.bn(self.conv(x)))
 
    def forward_fuse(self, x):
        """Perform transposed convolution of 2D data."""
        return self.act(self.conv(x))
 
 
class Bottleneck(nn.Module):
    """Standard bottleneck."""
 
    def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
        """Initializes a bottleneck module with given input/output channels, shortcut option, group, kernels, and
        expansion.
        """
        super().__init__()
        c_ = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, c_, k[0], 1)
        self.cv2 = Conv(c_, c2, k[1], 1, g=g)
        self.add = shortcut and c1 == c2
 
    def forward(self, x):
        """'forward()' applies the YOLO FPN to input data."""
        return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
 
 
 
class C2f_LSKA(nn.Module):
    """CSP Bottleneck with 2 convolutions followed by LSKA attention."""
 
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        """Initialize CSP bottleneck layer with two convolutions with LSKA attention."""
        super().__init__()
        self.c = int(c2 * e)  # hidden channels
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)  # optional act=FReLU(c2)
        self.m = nn.ModuleList(Bottleneck(self.c, self.c, shortcut, g, k=((3, 3), (3, 3)), e=1.0) for _ in range(n))
        self.lska = LSKA(c2)
 
    def forward(self, x):
        """Forward pass through C2f layer followed by LSKA attention."""
        y = list(self.cv1(x).chunk(2, 1))
        y.extend(m(y[-1]) for m in self.m)
        out = self.cv2(torch.cat(y, 1))
        return self.lska(out)
 
    def forward_split(self, x):
        """Forward pass using split() instead of chunk() followed by LSKA attention."""
        y = list(self.cv1(x).split((self.c, self.c), 1))
        y.extend(m(y[-1]) for m in self.m)
        out = self.cv2(torch.cat(y, 1))
        return self.lska(out)

二、添加【LSKA】注意力机制

2.1STEP1

首先找到ultralytics/nn文件路径下新建一个Add-module的python文件包【这里注意一定是python文件包，新建后会自动生成_init_.py】，如果已经跟着我的教程建立过一次了可以省略此步骤，随后新建一个LSKA.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文件

以下是添加【LSKA】注意力机制在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, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 1, LSKA, []]
  - [-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, 14], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

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

  - [[17, 20, 23], 1, Detect, [nc]] # Detect(P3, P4, P5)

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

3.2运行成功截图

在这里插入图片描述

OK 以上就是添加【LSKA】注意力机制的全部过程了，后续将持续更新尽情期待

在这里插入图片描述

如果能为勤奋颁奖
关注
专栏目录
【YOLOv10改进-注意力机制】LSKA(Large Separable Kernel Attention)：大核分离卷积注意力模块
专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。
06-29 1188
带有大卷积核注意力（LKA）模块的视觉注意网络（VAN）在一系列基于视觉的任务上表现出色，超越了视觉Transformer（ViTs）。然而，这些LKA模块中的深度卷积层随着卷积核尺寸的增加，会导致计算和内存占用的二次增长。为了解决这些问题并使在VAN的注意力模块中使用超大卷积核成为可能，我们提出了一种大可分卷积核注意力模块家族，称为LSKA。LSKA将深度卷积层的二维卷积核分解为串联的水平和垂直一维卷积核。
YOLOv10改进 | 注意力篇 | YOLOv10引入LSK注意力机制
tsg6698的博客
06-14 569
这种先验知识可能很有用，因为在没有参考足够远距离上下文的情况下，可能会错误地检测微小的遥感物体，并且不同类型物体所需的远距离上下文可能会有所不同。与传统的卷积操作相比，大尺度卷积核能够覆盖更大的感受野，从而捕捉到更丰富的上下文信息。到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv10改进有效涨点专栏，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~在LSK.py文件里添加给出的LSK代码。
YOLOv8改进 | 注意力机制 | 添加LSKAttention大核注意力机制助力极限涨点
Snu77的博客
11-24 6896
在这篇文章中，我们将讲解如何将LSKAttention大核注意力机制应用于YOLOv8，以实现显著的性能提升。首先，我们介绍LSKAttention机制的基本原理，它主要通过将深度卷积层的2D卷积核分解为水平和垂直1D卷积核，减少了计算复杂性和内存占用。接着，我们介绍将这一机制整合到YOLOv8的方法，以及它如何帮助提高处理大型数据集和复杂视觉任务的效率和准确性。本文还将提供代码实现细节和使用方法，展示这种改进对目标检测、语义分割等方面的积极影响。
【YOLOv8改进】LSKA(Large Separable Kernel Attention)：大核分离卷积注意力模块 (论文笔记+引入代码)
专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。
05-27 765
带有大卷积核注意力（LKA）模块的视觉注意网络（VAN）在一系列基于视觉的任务上表现出色，超越了视觉Transformer（ViTs）。然而，这些LKA模块中的深度卷积层随着卷积核尺寸的增加，会导致计算和内存占用的二次增长。为了解决这些问题并使在VAN的注意力模块中使用超大卷积核成为可能，我们提出了一种大可分卷积核注意力模块家族，称为LSKA。LSKA将深度卷积层的二维卷积核分解为串联的水平和垂直一维卷积核。
YOLOv10改进 | 注意力篇 | YOLOv10引入Large Separable Kernel Attention(LSKA)注意力机制，并构建C2f_LSKA
tsg6698的博客
08-03 227
我们证明，建议的LSKA模块在货车可以实现与标准LKA模块相当的性能，并产生较低的计算复杂度和内存占用。此外，我们在货车，ViTs和最近的ConvNeXt中对LKA和LSKA的鲁棒性进行了基准测试，这些测试是在以前的工作中基本上未探索过的ImageNet数据集的五个损坏版本上进行的。我们广泛的实验结果表明，在货车中提出的LSKA模块提供了显着降低计算复杂性和内存占用的增加内核大小，同时优于ViTs，ConvNeXt，并提供类似的性能相比，在货车中的LKA模块的对象识别，对象检测，语义分割和鲁棒性测试。
YOLOv5改进 | 注意力篇 | LSKAttention大核注意力机制助力极限涨点 (附多个位置添加教程)
Snu77的博客
01-06 1929
在这篇文章中，我们将讲解如何将LSKAttention大核注意力机制应用于YOLOv5，以实现显著的性能提升。首先，我们介绍LSKAttention机制的基本原理，它主要通过将深度卷积层的2D卷积核分解为水平和垂直1D卷积核，减少了计算复杂性和内存占用。接着，我们介绍将这一机制整合到YOLOv5的方法，以及它如何帮助提高处理大型数据集和复杂视觉任务的效率和准确性。本文还将提供代码实现细节和使用方法，展示这种改进对目标检测、语义分割等方面的积极影响。通过实验YOLOv8在整合LSKAttention机制后，实
YOLOv10改进：SPPF系列改进篇 | 大核分离卷积注意力模块（ Large Separable Kernel Attention）
会AI的学姐
06-12 82
大核分离卷积注意力模块（ Large Separable Kernel Attention），实现涨点的目标并且降低计算复杂度和显存，引入到YOLOv10，与SPPF结合实现二次创新；
YOLOv8改进 - 注意力篇 - 引入LSKA注意力机制
浪子L的博客
09-29 1055
YOLOv8改进 - 注意力篇 - 引入LSKA注意力机制
YOLOv8有效改进系列及项目实战目录 包含卷积，主干 注意力，检测头等创新机制 以及 各种目标检测分割项目实战案例
热门推荐
专注于图像领域，主要研究内容包括计算机视觉和深度学习，特别是在图像分类、目标检测和图像生成等方面有深入的研究和实践经验。
05-06 2万+
大家好！欢迎阅读本专栏。本专栏涵盖了YOLO8中C2f、主干网络、检测头、注意力机制、Neck等多种结构的创新，同时也包括了 YOLO相关的基础知识以及相关项目。
吴恩达深度学习笔记：卷积神经网络（Foundations of Convolutional Neural Networks）2.5-2.6
weixin_43597208的博客
09-29 1420
构建卷积层时，你要决定过滤器的大小究竟是 1×1（原来是 1×3，猜测为口误），3×3 还是 5×5，或者要不要添加池化层。而 Inception 网络的作用就是代替你来决定，虽然网络架构因此变得更加复杂，但网络表现却非常好，我们来了解一下其中的原理。例如，这是你 28×28×192 维度的输入层，Inception 网络或 Inception 层的作用就是代替人工来确定卷积层中的过滤器类型，或者确定是否需要创建卷积层或池化层，我们演示一下。
【一起学NLP】Chapter3-使用神经网络解决问题
有朋自远方来，不亦乐乎。
10-06 625
在内部实现中，首先用零向量（np.zeros（​）​）初始化偏置，再用小的随机数（0.01 *np.random.randn（​）​）初始化权重。Trainer类的内部实现和刚才的源代码几乎相同，只是添加了一些新的功能而已，我们在需要的时候再详细说明其用法。另外，t是one-hot向量，对应的正确解标签的类标记为1，其余的标记为0。另外，Trainer类有plot（​）方法，它将fit（​）方法记录的损失（准确地说，是按照eval_interval评价的平均损失）在图上画出来。Epoch表示学习的单位。
YOLO11改进|注意力机制篇|引入上下文锚注意力机制CAA
A1983Z的博客
10-06 676
YOLO11中添加CAA注意力机制
突触可塑性与STDP：神经网络中的自我调整机制
最新发布
qq_22841387的博客
10-06 679
当一个神经元（前脉冲神经元）先发出脉冲，而另一个神经元（后脉冲神经元）随后发出脉冲时，前脉冲神经元的信息对后脉冲神经元产生了积极的影响。相反地，如果后脉冲神经元先发出脉冲，而前脉冲神经元较晚发射，那么前脉冲神经元的信息对于后脉冲神经元的作用较小，连接会被削弱（即突触权重减少）。在神经网络的学习过程中，突触可塑性（Synaptic Plasticity）是指神经元之间的连接强度（突触权重）随着时间的推移而动态变化的能力。尖峰神经网络模仿了生物神经元的脉冲发射机制，通过脉冲的时间序列编码信息。
YOLOv8 结合设计硬件感知神经网络设计的高效 Repvgg的ConvNet 网络结构 ，改进EfficientRep结构
qq_53545309的博客
10-03 348
摘要—我们提出了一种硬件高效的卷积神经网络架构，它具有类似 repvgg 的架构。Flops 或参数是评估网络效率的传统指标，这些网络对硬件（包括计算能力和内存带宽）不敏感。因此，如何设计神经网络以有效利用硬件的计算能力和内存带宽是一个关键问题。基于该方法，我们设计了 EfficientRep 系列卷积网络，该网络对高计算硬件（例如 GPU）友好，并应用于 YOLOv6 目标检测框架。首先在ultralytics/nn文件夹下，创建一个efficientrep.py文件，新增以下代码。
深度学习——线性神经网络（一、线性回归）
2301_79815102的博客
10-03 1278
介绍神经网络的整个训练过程，包括定义简单的神经网络架构，数据处理，指定损失函数和如何训练模型。
【YOLO目标检测二维码数据集】共3112张、已标注txt格式、有训练好的yolov5的模型
LINBONB的博客
09-29 393
标注数量(txt文件个数)：3112。训练好的yolov5检测模型。标注类别名称：qrcode。数据集格式：YOLO格式。
[C#]C# winform部署yolov11目标检测的onnx模型
FL1623863129的博客
10-03 1043
最后运行项目选择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。
遥感影像-实例分割数据集：iSAID 从切图到YOLO格式数据集制作详细介绍
GIS潮流
09-30 1305
开源数据集isaid标注包含实例分割，但是原始影像太大，很吃显存，一般显卡无法用原始影像直接训练，所以需要对影像进行裁剪，并生成对应的标签，因为想用yolo系列跑模型，所以将标签需要转为txt格式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值