YOLOv5改进 | 2023注意力篇 | FocusedLinearAttention聚焦线性注意力
一、本文介绍
本文给大家带来的改进机制是FLAttention（聚焦线性注意力）是一种用于视觉Transformer模型的注意力机制(但是其也可以用在我们的YOLO系列当中从而提高检测精度)，旨在提高效率和表现力。其解决了两个在传统线性注意力方法中存在的问题：聚焦能力和特征多样性。这种方法通过一个高效的映射函数和秩恢复模块来提高计算效率和性能，使其在处理视觉任务时更加高效和有效。简言之，FLAttention是对传统线性注意力方法的一种重要改进，提高了模型的聚焦能力和特征表达的多样性。通过本文你能够了解到：FLAttention的基本原理和框架，能够在你自己的网络结构中进行添加。
目录
二、FLAttention的机制原理
论文地址：官方论文地址
代码地址：官方代码地址
2.1 Softmax和线性注意力机制的对比
上面的图片是关于比较Softmax注意力和线性注意力的差异。在这张图中，Q、K、V 分别代表查询、键和值矩阵，它们的维度为 R N×d。这里提到的几个关键点包括：
1. Softmax注意力：它需要计算查询和键之间的成对相似度，导致计算复杂度为 O(N^2 d)。这种方法在计算上是昂贵的，特别是当处理大规模数据时。
2. 线性注意力：通过适当的近似手段，线性注意力可以解耦Softmax操作，并通过先计算来改变计算顺序，从而将复杂度降低到 O(
)。由于在现代视觉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上是需要进行很大改动的，所以我这里进行了挺多的改动的，创作不易而且免费给大家看，所以如果能够帮助到大家希望大家能给点个赞和关注支持一下。
import torch.nn as nn
import torch
from einops import rearrange
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):
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):
return self.act(self.bn(self.conv(x)))
def forward_fuse(self, x):
return self.act(self.conv(x))
class FocusedLinearAttention(nn.Module):
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,
focusing_factor=3.0, kernel_size=5):
super().__init__()
assert dim % num_heads == 0, f"dim {dim} should be divided by num_heads {num_heads}."
self.dim = dim
self.num_heads = num_heads
head_dim = dim // num_heads
self.q = nn.Linear(dim, dim, bias=qkv_bias)
self.kv = nn.Linear(dim, dim * 2, bias=qkv_bias)
self.attn_drop = nn.Dropout(attn_drop)
self.proj = nn.Linear(dim, dim)
self.proj_drop = nn.Dropout(proj_drop)
self.sr_ratio = sr_ratio
if sr_ratio > 1:
self.sr = nn.Conv2d(dim, dim, kernel_size=sr_ratio, stride=sr_ratio)
self.norm = nn.LayerNorm(dim)
self.focusing_factor = focusing_factor
self.dwc = nn.Conv2d(in_channels=head_dim, out_channels=head_dim, kernel_size=kernel_size,
groups=head_dim, padding=kernel_size // 2)
self.scale = nn.Parameter(torch.zeros(size=(1, 1, dim)))
# self.positional_encoding = nn.Parameter(torch.zeros(size=(1, num_patches // (sr_ratio * sr_ratio), dim)))
def forward(self, x):
B, C, H, W = x.shape # 输入为四维：[批次大小, 通道数, 高度, 宽度]
dtype, device = x.dtype, x.device
# 调整输入以匹配原始模块的预期格式
x = rearrange(x, 'b c h w -> b (h w) c')
q = self.q(x)
if self.sr_ratio > 1:
x_ = x.permute(0, 2, 1).reshape(B, C, H, W)
x_ = self.sr(x_).reshape(B, C, -1).permute(0, 2, 1)
x_ = self.norm(x_)
kv = self.kv(x_).reshape(B, -1, 2, C).permute(2, 0, 1, 3)
else:
kv = self.kv(x).reshape(B, -1, 2, C).permute(2, 0, 1, 3)
k, v = kv[0], kv[1]
N = H * W # 序列长度
# 重新生成位置编码
positional_encoding = nn.Parameter(torch.zeros(size=(1, N, self.dim), device=device))
k = k + positional_encoding
focusing_factor = self.focusing_factor
kernel_function = nn.ReLU()
scale = nn.Softplus()(self.scale)
q = kernel_function(q) + 1e-6
k = kernel_function(k) + 1e-6
q = q / scale
k = k / scale
q_norm = q.norm(dim=-1, keepdim=True)
k_norm = k.norm(dim=-1, keepdim=True)
q = q ** focusing_factor
k = k ** focusing_factor
q = (q / q.norm(dim=-1, keepdim=True)) * q_norm
k = (k / k.norm(dim=-1, keepdim=True)) * k_norm
bool = False
if dtype == torch.float16:
q = q.float()
k = k.float()
v = v.float()
bool = True
q, k, v = (rearrange(x, "b n (h c) -> (b h) n c", h=self.num_heads) for x in [q, k, v])
i, j, c, d = q.shape[-2], k.shape[-2], k.shape[-1], v.shape[-1]
z = 1 / (torch.einsum("b i c, b c -> b i", q, k.sum(dim=1)) + 1e-6)
if i * j * (c + d) > c * d * (i + j):
kv = torch.einsum("b j c, b j d -> b c d", k, v)
x = torch.einsum("b i c, b c d, b i -> b i d", q, kv, z)
else:
qk = torch.einsum("b i c, b j c -> b i j", q, k)
x = torch.einsum("b i j, b j d, b i -> b i d", qk, v, z)
if self.sr_ratio > 1:
v = nn.functional.interpolate(v.permute(0, 2, 1), size=x.shape[1], mode='linear').permute(0, 2, 1)
if bool:
v = v.to(torch.float16)
x = x.to(torch.float16)
num = int(v.shape[1] ** 0.5)
feature_map = rearrange(v, "b (w h) c -> b c w h", w=num, h=num)
feature_map = rearrange(self.dwc(feature_map), "b c w h -> b (w h) c")
x = x + feature_map
x = rearrange(x, "(b h) n c -> b n (h c)", h=self.num_heads)
x = self.proj(x)
x = self.proj_drop(x)
x = rearrange(x, 'b (h w) c -> b c h w', h=H, w=W)
return 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.Attention = FocusedLinearAttention(c2)
self.add = shortcut and c1 == c2
def forward(self, x):
"""'forward()' applies the YOLO FPN to input data."""
return x + self.Attention(self.cv2(self.cv1(x))) if self.add else self.Attention(self.cv2(self.cv1(x)))
class C3_FLAttention(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.cv1 = Conv(c1, c_, 1, 1)
self.cv2 = Conv(c1, c_, 1, 1)
self.cv3 = Conv(2 * c_, c2, 1) # optional act=FReLU(c2)
self.m = nn.Sequential(*(Bottleneck(c_, c_, shortcut, g, e=1.0) for _ in range(n)))
def forward(self, x):
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在训练的适合不稳定，有的数据集可以用有的不可以用，我一开始用一个数据集跑不通换了一个就可以了。
# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license
# Parameters
nc: 80 # number of classes
depth_multiple: 0.33 # model depth multiple
width_multiple: 0.25 # layer channel multiple
anchors:
- [10,13, 16,30, 33,23] # P3/8
- [30,61, 62,45, 59,119] # P4/16
- [116,90, 156,198, 373,326] # P5/32
# YOLOv5 v6.0 backbone
backbone:
# [from, number, module, args]
[[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2
[-1, 1, Conv, [128, 3, 2]], # 1-P2/4
[-1, 3, C3, [128]],
[-1, 1, Conv, [256, 3, 2]], # 3-P3/8
[-1, 6, C3, [256]],
[-1, 1, Conv, [512, 3, 2]], # 5-P4/16
[-1, 9, C3, [512]],
[-1, 1, Conv, [1024, 3, 2]], # 7-P5/32
[-1, 3, C3, [1024]],
[-1, 1, SPPF, [1024, 5]], # 9
]
# YOLOv5 v6.0 head
head:
[[-1, 1, Conv, [512, 1, 1]],
[-1, 1, nn.Upsample, [None, 2, 'nearest']],
[[-1, 6], 1, Concat, [1]], # cat backbone P4
[-1, 3, C3, [512, False]], # 13
[-1, 1, Conv, [256, 1, 1]],
[-1, 1, nn.Upsample, [None, 2, 'nearest']],
[[-1, 4], 1, Concat, [1]], # cat backbone P3
[-1, 3, C3_FLAttention, [256, False]], # 17 (P3/8-small)
[-1, 1, Conv, [256, 3, 2]],
[[-1, 14], 1, Concat, [1]], # cat head P4
[-1, 3, C3_FLAttention, [512, False]], # 20 (P4/16-medium)
[-1, 1, Conv, [512, 3, 2]],
[[-1, 10], 1, Concat, [1]], # cat head P5
[-1, 3, C3_FLAttention, [1024, False]], # 23 (P5/32-large)
[[17, 20, 23], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)
]
5.2.2 FLAttention的yaml文件二?
下面的是放在Neck部分的截图，参数我以及设定好了，无需进行传入会根据模型输入自动计算，帮助大家省了一些事。
# YOLOv5 🚀 by Ultralytics, AGPL-3.0 license
# Parameters
nc: 80 # number of classes
depth_multiple: 0.33 # model depth multiple
width_multiple: 0.25 # layer channel multiple
anchors:
- [10,13, 16,30, 33,23] # P3/8
- [30,61, 62,45, 59,119] # P4/16
- [116,90, 156,198, 373,326] # P5/32
# YOLOv5 v6.0 backbone
backbone:
# [from, number, module, args]
[[-1, 1, Conv, [64, 6, 2, 2]], # 0-P1/2
[-1, 1, Conv, [128, 3, 2]], # 1-P2/4
[-1, 3, C3, [128]],
[-1, 1, Conv, [256, 3, 2]], # 3-P3/8
[-1, 6, C3, [256]],
[-1, 1, Conv, [512, 3, 2]], # 5-P4/16
[-1, 9, C3, [512]],
[-1, 1, Conv, [1024, 3, 2]], # 7-P5/32
[-1, 3, C3, [1024]],
[-1, 1, SPPF, [1024, 5]], # 9
]
# YOLOv5 v6.0 head
head:
[[-1, 1, Conv, [512, 1, 1]],
[-1, 1, nn.Upsample, [None, 2, 'nearest']],
[[-1, 6], 1, Concat, [1]], # cat backbone P4
[-1, 3, C3, [512, False]], # 13
[-1, 1, Conv, [256, 1, 1]],
[-1, 1, nn.Upsample, [None, 2, 'nearest']],
[[-1, 4], 1, Concat, [1]], # cat backbone P3
[-1, 3, C3, [256, False]], # 17 (P3/8-small)
[-1, 1, FocusedLinearAttention, []], # 18
[-1, 1, Conv, [256, 3, 2]],
[[-1, 14], 1, Concat, [1]], # cat head P4
[-1, 3, C3, [512, False]], # 21 (P4/16-medium)
[-1, 1, FocusedLinearAttention, []], #22
[-1, 1, Conv, [512, 3, 2]],
[[-1, 10], 1, Concat, [1]], # cat head P5
[-1, 3, C3, [1024, False]], # 25 (P5/32-large)
[-1, 1, FocusedLinearAttention, []], #26
[[18, 22, 26], 1, Detect, [nc, anchors]], # Detect(P3, P4, P5)
]
5.2.2 FLAttention的训练过程截图?
下面的是将FLAttention机制我添加到了C3和Bottleneck的训练截图。
下面的是我将FLAttention放在Neck中的截图。?
六、全文总结?
到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv5改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，目前本专栏免费阅读(暂时，大家尽早关注不迷路~)，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！