devbox
繁依Fanyi0
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

YOLOv5改进 | 注意力篇 | 全新的FocusedLinearAttention聚焦线性注意力（附代码 + 修改教程）

作者：繁依Fanyi0 | 2024-07-24 08:55:57

赞

踩

yolov5改进

一、本文介绍

本文给大家带来的改进机制是FLAttention（聚焦线性注意力）是一种用于视觉Transformer模型的注意力机制(但是其也可以用在我们的YOLO系列当中从而提高检测精度)，旨在提高效率和表现力。其解决了两个在传统线性注意力方法中存在的问题：聚焦能力和特征多样性。这种方法通过一个高效的映射函数和秩恢复模块来提高计算效率和性能，使其在处理视觉任务时更加高效和有效。简言之，FLAttention是对传统线性注意力方法的一种重要改进，提高了模型的聚焦能力和特征表达的多样性。通过本文你能够了解到：FLAttention的基本原理和框架，能够在你自己的网络结构中进行添加。

专栏回顾：YOLOv5改进专栏——持续复现各种顶会内容——内含100+创新

目录

一、本文介绍

二、FLAttention的机制原理

2.1 Softmax和线性注意力机制的对比

2.2 FLAttention的提出

2.3 效果对比

三、实验效果对比

四、FLAttention代码

五、添加FLAttention到模型中

5.1 细节修改教程

5.1.1 修改一

​4.1.2 修改二

4.1.3 修改三 

4.1.4 修改四

5.2 FLAttention的yaml文件和训练截图

5.2.1 FLAttention的yaml文件一

5.2.2 FLAttention的yaml文件二 

5.2.2 FLAttention的训练过程截图 

六、全文总结 

二、FLAttention的机制原理

论文地址：官方论文地址

代码地址：官方代码地址

2.1 Softmax和线性注意力机制的对比

上面的图片是关于比较Softmax注意力和线性注意力的差异。在这张图中，Q、K、V 分别代表查询、键和值矩阵，它们的维度为 R N×d。这里提到的几个关键点包括：

1. Softmax注意力：它需要计算查询和键之间的成对相似度，导致计算复杂度为 O(N^2 d)。这种方法在计算上是昂贵的，特别是当处理大规模数据时。

2. 线性注意力：通过适当的近似手段，线性注意力可以解耦Softmax操作，并通过先计算K^{T}V来改变计算顺序，从而将复杂度降低到 O(Nd^{^{2}})。由于在现代视觉Transformer设计中通道维度 d 通常小于标记数 N（例如，在DeiT中d=64, N=196，在Swin Transformer中d=32, N=49），线性注意力模块实际上降低了总体计算成本。

此处提出了线性注意力机制的优势(为了后面提出论文提到的注意力机制在线性注意力机制上的优化)：线性注意力模块因此能够在节省计算成本的同时，享受更大的接收域和更高的吞吐量的好处。

总结：这张图片可能是在说明线性注意力如何在保持注意力机制核心功能的同时，提高计算效率，尤其是在处理大规模数据集时的优势。这种方法对于改善视觉Transformer的性能和效率具有重要意义(我下面会出将其用在RT-DETR的模型上看看效果)。

2.2 FLAttention的提出

线性注意力的限制和改进: 尽管线性注意力降低了复杂度，但现有的线性注意力方法仍存在性能下降的问题，并可能因映射函数带来额外的计算开销。为了解决这些问题，作者提出了一个新颖的聚焦线性注意力（Focused Linear Attention）模块。该模块通过简单的映射函数调整查询和键的特征方向，使注意力权重更加明显。此外，还通过深度卷积（DWC）应用于原始注意力矩阵的秩恢复模块来增加特征多样性。

Focused Linear Attention（聚焦线性注意力）是一种用于视觉Transformer模型的注意力机制(但是其也可以用在我们的YOLO系列当中从而提高检测精度)，旨在提高效率和表现力。它解决了传统线性注意力方法的两个主要问题：

1. 聚焦能力: 以往的线性注意力缺乏足够的聚焦能力，导致模型难以有效地关注重要特征。Focused Linear Attention通过改进的机制增强了这种聚焦能力。

2. 特征多样性: 传统方法在特征表达上缺乏多样性，影响了模型的表现力。Focused Linear Attention通过特殊的设计来增加特征的多样性和丰富性。

这种方法通过一个高效的映射函数和秩恢复模块来提高计算效率和性能，使其在处理视觉任务时更加高效和有效。

总结：Focused Linear Attention是对传统线性注意力方法的一种重要改进，提高了模型的聚焦能力和特征表达的多样性。

2.3 效果对比

上面的图片显示了多个视觉Transformer模型的性能和计算复杂度的比较。图中分为四个部分：

1. PVT: 对比了不同版本的PVT（Pyramid Vision Transformer），DeiT（Data-efficient Image Transformer），以及T2T（Tokens-to-Token ViT）的Top-1准确率和计算量（FLOPs）。

2. PVT v2: 类似地，展示了PVT v2、ConvNext、DAT（Deformable Attention Transformer）的性能对比。

3. Swin: 对比了Swin Transformer、CvT（Convolutional vision Transformer），以及CoTNet（Contextual Transformer Network）的模型。

4. CSwin: 展示了CSwin Transformer、MViTv2、CoAtNet的性能对比。

在每个图中，还包括了作者提出的FLatten版本的Transformer模型（标记为“Ours”），其在每个分类中都显示了相对较高的准确率或者在相似的FLOPs计算量下具有竞争力的准确率。

右侧的表格详细列出了不同模型的分辨率（Reso）、参数数量（#Params）、计算量（Flops）和Top-1准确率。表中突出了FLatten版本的Transformer模型在Top-1准确率上相对于原始模型的提升（括号中的百分点）。

个人总结：这张图片展示了通过改进的线性注意力模块，即FLatten模型，在保持或稍微增加计算量的前提下，提高了Transformer架构的图像识别准确率。

三、实验效果对比

四、FLAttention代码

在场的FocusedLinearAttention代码是用于Transformer的想要将其用于YOLO上是需要进行很大改动的，所以我这里进行了挺多的改动的，创作不易而且免费给大家看，所以如果能够帮助到大家希望大家能给点个赞和关注支持一下。

  1. import torch.nn as nn
  2. import torch
  3. from einops import rearrange
  4.  
  5. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  6.     # Pad to 'same' shape outputs
  7.     if d > 1:
  8.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  9.     if p is None:
  10.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  11.     return p
  12.  
  13.  
  14. class Conv(nn.Module):
  15.     # Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)
  16.     default_act = nn.SiLU()  # default activation
  17.  
  18.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  19.         super().__init__()
  20.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  21.         self.bn = nn.BatchNorm2d(c2)
  22.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  23.  
  24.     def forward(self, x):
  25.         return self.act(self.bn(self.conv(x)))
  26.  
  27.     def forward_fuse(self, x):
  28.         return self.act(self.conv(x))
  29.  
  30.  
  31. class FocusedLinearAttention(nn.Module):
  32.     def __init__(self, dim, num_patches=64, num_heads=8, qkv_bias=True, qk_scale=None, attn_drop=0.0, proj_drop=0.0, sr_ratio=1,
  33.                  focusing_factor=3.0, kernel_size=5):
  34.         super().__init__()
  35.         assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
  36.         self.dim = dim
  37.         self.num_heads = num_heads
  38.         head_dim = dim // num_heads
  39.  
  40.         self.q = nn.Linear(dim, dim, bias=qkv_bias)
  41.         self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
  42.         self.attn_drop = nn.Dropout(attn_drop)
  43.         self.proj = nn.Linear(dim, dim)
  44.         self.proj_drop = nn.Dropout(proj_drop)
  45.  
  46.         self.sr_ratio = sr_ratio
  47.         if sr_ratio > 1:
  48.             self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
  49.             self.norm = nn.LayerNorm(dim)
  50.  
  51.         self.focusing_factor = focusing_factor
  52.         self.dwc = nn.Conv2d(in_channels=head_dim, out_channels=head_dim, kernel_size=kernel_size,
  53.                              groups=head_dim, padding=kernel_size // 2)
  54.         self.scale = nn.Parameter(torch.zeros(size=(1, 1, dim)))
  55.         # self.positional_encoding = nn.Parameter(torch.zeros(size=(1, num_patches // (sr_ratio * sr_ratio), dim)))
  56.  
  57.  
  58.     def forward(self, x):
  59.         B, C, H, W = x.shape  # 输入为四维：[批次大小, 通道数, 高度, 宽度]
  60.         dtype, device = x.dtype, x.device
  61.         # 调整输入以匹配原始模块的预期格式
  62.         x = rearrange(x, 'b c h w -> b (h w) c')
  63.         q = self.q(x)
  64.         if self.sr_ratio > 1:
  65.             x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
  66.             x_ = self.sr(x_).reshape(B, C, -1).permute(0, 2, 1)
  67.             x_ = self.norm(x_)
  68.             kv = self.kv(x_).reshape(B, -1, 2, C).permute(2, 0, 1, 3)
  69.         else:
  70.             kv = self.kv(x).reshape(B, -1, 2, C).permute(2, 0, 1, 3)
  71.         k, v = kv[0], kv[1]
  72.         N = H * W  # 序列长度
  73.         # 重新生成位置编码
  74.         positional_encoding = nn.Parameter(torch.zeros(size=(1, N, self.dim), device=device))
  75.         k = k + positional_encoding
  76.         focusing_factor = self.focusing_factor
  77.         kernel_function = nn.ReLU()
  78.         scale = nn.Softplus()(self.scale)
  79.         q = kernel_function(q) + 1e-6
  80.         k = kernel_function(k) + 1e-6
  81.         q = q / scale
  82.         k = k / scale
  83.         q_norm = q.norm(dim=-1, keepdim=True)
  84.         k_norm = k.norm(dim=-1, keepdim=True)
  85.         q = q ** focusing_factor
  86.         k = k ** focusing_factor
  87.         q = (q / q.norm(dim=-1, keepdim=True)) * q_norm
  88.         k = (k / k.norm(dim=-1, keepdim=True)) * k_norm
  89.         bool = False
  90.         if dtype == torch.float16:
  91.             q = q.float()
  92.             k = k.float()
  93.             v = v.float()
  94.             bool = True
  95.         q, k, v = (rearrange(x, "b n (h c) -> (b h) n c", h=self.num_heads) for x in [q, k, v])
  96.         i, j, c, d = q.shape[-2], k.shape[-2], k.shape[-1], v.shape[-1]
  97.         z = 1 / (torch.einsum("b i c, b c -> b i", q, k.sum(dim=1)) + 1e-6)
  98.         if i * j * (c + d) > c * d * (i + j):
  99.             kv = torch.einsum("b j c, b j d -> b c d", k, v)
  100.             x = torch.einsum("b i c, b c d, b i -> b i d", q, kv, z)
  101.         else:
  102.             qk = torch.einsum("b i c, b j c -> b i j", q, k)
  103.             x = torch.einsum("b i j, b j d, b i -> b i d", qk, v, z)
  104.         if self.sr_ratio > 1:
  105.             v = nn.functional.interpolate(v.permute(0, 2, 1), size=x.shape[1], mode='linear').permute(0, 2, 1)
  106.         if bool:
  107.             v = v.to(torch.float16)
  108.             x = x.to(torch.float16)
  109.  
  110.         num = int(v.shape[1] ** 0.5)
  111.         feature_map = rearrange(v, "b (w h) c -> b c w h", w=num, h=num)
  112.         feature_map = rearrange(self.dwc(feature_map), "b c w h -> b (w h) c")
  113.         x = x + feature_map
  114.         x = rearrange(x, "(b h) n c -> b n (h c)", h=self.num_heads)
  115.  
  116.         x = self.proj(x)
  117.         x = self.proj_drop(x)
  118.         x = rearrange(x, 'b (h w) c -> b c h w', h=H, w=W)
  119.         return x
  120.  
  121.  
  122. class Bottleneck(nn.Module):
  123.     """Standard bottleneck."""
  124.  
  125.     def __init__(self, c1, c2, shortcut=True, g=1, k=(3, 3), e=0.5):
  126.         """Initializes a bottleneck module with given input/output channels, shortcut option, group, kernels, and
  127.         expansion.
  128.         """
  129.         super().__init__()
  130.         c_ = int(c2 * e)  # hidden channels
  131.         self.cv1 = Conv(c1, c_, k[0], 1)
  132.         self.cv2 = Conv(c_, c2, k[1], 1, g=g)
  133.         self.Attention = FocusedLinearAttention(c2)
  134.         self.add = shortcut and c1 == c2
  135.  
  136.     def forward(self, x):
  137.         """'forward()' applies the YOLO FPN to input data."""
  138.         return x + self.Attention(self.cv2(self.cv1(x))) if self.add else self.Attention(self.cv2(self.cv1(x)))
  139.  
  140.  
  141. class C3_FLAttention(nn.Module):
  142.     # CSP Bottleneck with 3 convolutions
  143.     def __init__(self, c1, c2, n=1, shortcut=True, g=1, e=0.5):  # ch_in, ch_out, number, shortcut, groups, expansion
  144.         super().__init__()
  145.         c_ = int(c2 * e)  # hidden channels
  146.         self.cv1 = Conv(c1, c_, 1, 1)
  147.         self.cv2 = Conv(c1, c_, 1, 1)
  148.         self.cv3 = Conv(2 * c_, c2, 1)  # optional act=FReLU(c2)
  149.         self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
  150.  
  151.     def forward(self, x):
  152.         return self.cv3(torch.cat((self.m(self.cv1(x)), self.cv2(x)), 1))

五、添加FLAttention到模型中

5.1 细节修改教程

5.1.1 修改一

我们找到如下的目录'yolov5-master/models'在这个目录下创建一个文件目录(注意是目录，因为我这个专栏会出很多的更新，这里用一种一劳永逸的方法)文件目录起名modules，然后在下面新建一个文件，将我们的代码复制粘贴进去。

​

​4.1.2 修改二

然后新建一个__init__.py文件，然后我们在里面添加一行代码。注意标记一个'.'其作用是标记当前目录。

4.1.3 修改三 

然后我们找到如下文件''models/yolo.py''在开头的地方导入我们的模块按照如下修改->

(如果你看了我多个改进机制此处只需要添加一个即可，无需重复添加)

​​​​

4.1.4 修改四

然后我们找到parse_model方法，按照如下修改->

到此就修改完成了，复制下面的ymal文件即可运行。

5.2 FLAttention的yaml文件和训练截图

5.2.1 FLAttention的yaml文件一

同时我发现这个FLAttention在训练的适合不稳定，有的数据集可以用有的不可以用，我一开始用一个数据集跑不通换了一个就可以了。

  1. # YOLOv5 
    声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/繁依Fanyi0/article/detail/873809
    推荐阅读
    相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。