学习资源站

YOLOv11改进-添加注意力机制篇-添加DAttention(DAT)注意力机制二次创新C2PSA（BestPaper）

一、本文介绍

本文给大家带来的是YOLOv11改进 DAT(Vision Transformer with Deformable Attention) 的教程， CVPR2022 上同时被评选为 Best Paper ， 由此可以证明其是一种十分 有效的 改进机制，其主要的 核心思想是： 引入可变形注意力机制和动态采样点(听着是不是和可变形动态卷积DCN挺相似)。文的讲解主要包含三方面：DAT的网络结构思想、DAttention的代码复现，如何添加DAttention到你的结构中实现涨点，下面先来分享我测试的对比图 。

二、DAT的网络结构思想

论文地址： DAT论文地址

官方地址： 官方代码的地址

2.1 DAT的主要思想和改进

DAT（Vision Transformer with Deformable Attention） 是一种引入了可变形注意力机制的视觉 Transformer ，DAT的核心思想主要包括以下几个方面：

  1. 可变形注意力（Deformable Attention） ：传统的 Transformer 使用标准的自注意力机制，这种机制会处理图像中的所有像素，导致计算量很大。而DAT引入了可变形注意力机制，它只关注图像中的一小部分关键区域。这种方法可以显著减少计算量，同时保持良好的 性能 。

  2. 动态采样点 ：在可变形注意力机制中，DAT动态地选择采样点，而不是固定地处理整个图像。这种动态选择机制使得 模型 可以更加集中地关注于那些对当前任务最重要的区域。

  3. 即插即用 ：DAT的设计允许它适应不同的图像大小和内容，使其在多种视觉任务中都能有效工作，如图像分类、对象检测等。

总结： DAT通过引入可变形注意力机制，改进了视觉Transformer的效率和性能，使其在处理复杂的视觉任务时更加高效和准确。

2.2 DAT的网络结构图

(a) 展示了可变形注意力的信息流。左侧部分，一组参考点均匀地放置在特征图上，这些点的偏移量是由查询通过偏移网络学习得到的。然后，如右侧所示，根据变形点从采样特征中投影出变形的键和值。相对位置偏差也通过变形点计算，增强了输出转换特征的多头注意力。为了清晰展示，图中仅显示了4个参考点，但在实际实现中实际上有更多的点。

(b) 展示了偏移生成网络的详细结构，每层输入和输出特征图的大小都有标注 ( 这个Offset network在网络的代码中需要控制可添加可不添加 )。

通过上面的方式产生多种参考点分布在图像上，从而提高检测的效率， 最终的效果图如下->

2.3 DAT和其他机制的对比

DAT与其他视觉Transformer模型和CNN模型中的DCN（可变形卷积网络）的对比图如下，突出了它们处理查询的不同方法 ( 图片展示的很直观，不给大家描述过程了 ) ：

三、DAT即插即用的代码块

下面的代码是DAT的网络结构代码. 

  1. import numpy as np
  2. import torch
  3. import torch.nn as nn
  4. import torch.nn.functional as F
  5. import einops
  6. from timm.models.layers import  trunc_normal_
  8. __all__ = ['DAttentionBaseline', 'C2PSA_DAT']
  11. class LayerNormProxy(nn.Module):
  13.     def __init__(self, dim):
  14.         super().__init__()
  15.         self.norm = nn.LayerNorm(dim)
  17.     def forward(self, x):
  18.         x = einops.rearrange(x, 'b c h w -> b h w c')
  19.         x = self.norm(x)
  20.         return einops.rearrange(x, 'b h w c -> b c h w')
  23. class DAttentionBaseline(nn.Module):
  25.     def __init__(
  26.             self, q_size=(224,224), kv_size=(224,224), n_heads=8, n_head_channels=32, n_groups=1,
  27.             attn_drop=0.0, proj_drop=0.0, stride=1,
  28.             offset_range_factor=-1, use_pe=True, dwc_pe=True,
  29.             no_off=False, fixed_pe=False, ksize=9, log_cpb=False
  30.     ):
  32.         super().__init__()
  33.         n_head_channels = int(q_size / 8)
  34.         q_size = (q_size, q_size)
  36.         self.dwc_pe = dwc_pe
  37.         self.n_head_channels = n_head_channels
  38.         self.scale = self.n_head_channels ** -0.5
  39.         self.n_heads = n_heads
  40.         self.q_h, self.q_w = q_size
  41.         # self.kv_h, self.kv_w = kv_size
  42.         self.kv_h, self.kv_w = self.q_h // stride, self.q_w // stride
  43.         self.nc = n_head_channels * n_heads
  44.         self.n_groups = n_groups
  45.         self.n_group_channels = self.nc // self.n_groups
  46.         self.n_group_heads = self.n_heads // self.n_groups
  47.         self.use_pe = use_pe
  48.         self.fixed_pe = fixed_pe
  49.         self.no_off = no_off
  50.         self.offset_range_factor = offset_range_factor
  51.         self.ksize = ksize
  52.         self.log_cpb = log_cpb
  53.         self.stride = stride
  54.         kk = self.ksize
  55.         pad_size = kk // 2 if kk != stride else 0
  58.         self.conv_offset = nn.Sequential(
  59.             nn.Conv2d(self.n_group_channels, self.n_group_channels, kk, stride, pad_size, groups=self.n_group_channels),
  60.             LayerNormProxy(self.n_group_channels),
  61.             nn.GELU(),
  62.             nn.Conv2d(self.n_group_channels, 2, 1, 1, 0, bias=False)
  63.         )
  65.         if self.no_off:
  66.             for m in self.conv_offset.parameters():
  67.                 m.requires_grad_(False)
  69.         self.proj_q = nn.Conv2d(
  70.             self.nc, self.nc,
  71.             kernel_size=1, stride=1, padding=0
  72.         )
  74.         self.proj_k = nn.Conv2d(
  75.             self.nc, self.nc,
  76.             kernel_size=1, stride=1, padding=0)
  78.         self.proj_v = nn.Conv2d(
  79.             self.nc, self.nc,
  80.             kernel_size=1, stride=1, padding=0
  81.         )
  82.         self.proj_out = nn.Conv2d(
  83.             self.nc, self.nc,
  84.             kernel_size=1, stride=1, padding=0
  85.         )
  87.         self.proj_drop = nn.Dropout(proj_drop, inplace=True)
  88.         self.attn_drop = nn.Dropout(attn_drop, inplace=True)
  90.         if self.use_pe and not self.no_off:
  91.             if self.dwc_pe:
  92.                 self.rpe_table = nn.Conv2d(
  93.                     self.nc, self.nc, kernel_size=3, stride=1, padding=1, groups=self.nc)
  94.             elif self.fixed_pe:
  95.                 self.rpe_table = nn.Parameter(
  96.                     torch.zeros(self.n_heads, self.q_h * self.q_w, self.kv_h * self.kv_w)
  97.                 )
  98.                 trunc_normal_(self.rpe_table, std=0.01)
  99.             elif self.log_cpb:
  100.                 # Borrowed from Swin-V2
  101.                 self.rpe_table = nn.Sequential(
  102.                     nn.Linear(2, 32, bias=True),
  103.                     nn.ReLU(inplace=True),
  104.                     nn.Linear(32, self.n_group_heads, bias=False)
  105.                 )
  106.             else:
  107.                 self.rpe_table = nn.Parameter(
  108.                     torch.zeros(self.n_heads, self.q_h * 2 - 1, self.q_w * 2 - 1)
  109.                 )
  110.                 trunc_normal_(self.rpe_table, std=0.01)
  111.         else:
  112.             self.rpe_table = None
  114.     @torch.no_grad()
  115.     def _get_ref_points(self, H_key, W_key, B, dtype, device):
  117.         ref_y, ref_x = torch.meshgrid(
  118.             torch.linspace(0.5, H_key - 0.5, H_key, dtype=dtype, device=device),
  119.             torch.linspace(0.5, W_key - 0.5, W_key, dtype=dtype, device=device),
  120.             indexing='ij'
  121.         )
  122.         ref = torch.stack((ref_y, ref_x), -1)
  123.         ref[..., 1].div_(W_key - 1.0).mul_(2.0).sub_(1.0)
  124.         ref[..., 0].div_(H_key - 1.0).mul_(2.0).sub_(1.0)
  125.         ref = ref[None, ...].expand(B * self.n_groups, -1, -1, -1)  # B * g H W 2
  127.         return ref
  129.     @torch.no_grad()
  130.     def _get_q_grid(self, H, W, B, dtype, device):
  132.         ref_y, ref_x = torch.meshgrid(
  133.             torch.arange(0, H, dtype=dtype, device=device),
  134.             torch.arange(0, W, dtype=dtype, device=device),
  135.             indexing='ij'
  136.         )
  137.         ref = torch.stack((ref_y, ref_x), -1)
  138.         ref[..., 1].div_(W - 1.0).mul_(2.0).sub_(1.0)
  139.         ref[..., 0].div_(H - 1.0).mul_(2.0).sub_(1.0)
  140.         ref = ref[None, ...].expand(B * self.n_groups, -1, -1, -1)  # B * g H W 2
  142.         return ref
  144.     def forward(self, x):
  145.         x = x
  146.         B, C, H, W = x.size()
  147.         dtype, device = x.dtype, x.device
  149.         q = self.proj_q(x)
  150.         q_off = einops.rearrange(q, 'b (g c) h w -> (b g) c h w', g=self.n_groups, c=self.n_group_channels)
  151.         offset = self.conv_offset(q_off).contiguous()  # B * g 2 Hg Wg
  152.         Hk, Wk = offset.size(2), offset.size(3)
  153.         n_sample = Hk * Wk
  155.         if self.offset_range_factor >= 0 and not self.no_off:
  156.             offset_range = torch.tensor([1.0 / (Hk - 1.0), 1.0 / (Wk - 1.0)], device=device).reshape(1, 2, 1, 1)
  157.             offset = offset.tanh().mul(offset_range).mul(self.offset_range_factor)
  159.         offset = einops.rearrange(offset, 'b p h w -> b h w p')
  160.         reference = self._get_ref_points(Hk, Wk, B, dtype, device)
  162.         if self.no_off:
  163.             offset = offset.fill_(0.0)
  165.         if self.offset_range_factor >= 0:
  166.             pos = offset + reference
  167.         else:
  168.             pos = (offset + reference).clamp(-1., +1.)
  170.         if self.no_off:
  171.             x_sampled = F.avg_pool2d(x, kernel_size=self.stride, stride=self.stride)
  172.             assert x_sampled.size(2) == Hk and x_sampled.size(3) == Wk, f"Size is {x_sampled.size()}"
  173.         else:
  174.             x_sampled = F.grid_sample(
  175.                 input=x.reshape(B * self.n_groups, self.n_group_channels, H, W),
  176.                 grid=pos[..., (1, 0)],  # y, x -> x, y
  177.                 mode='bilinear', align_corners=True)  # B * g, Cg, Hg, Wg
  179.         x_sampled = x_sampled.reshape(B, C, 1, n_sample)
  180.         # self.proj_k.weight = torch.nn.Parameter(self.proj_k.weight.float())
  181.         # self.proj_k.bias = torch.nn.Parameter(self.proj_k.bias.float())
  182.         # self.proj_v.weight = torch.nn.Parameter(self.proj_v.weight.float())
  183.         # self.proj_v.bias = torch.nn.Parameter(self.proj_v.bias.float())
  184.         # 检查权重的数据类型
  185.         q = q.reshape(B * self.n_heads, self.n_head_channels, H * W)
  187.         k = self.proj_k(x_sampled).reshape(B * self.n_heads, self.n_head_channels, n_sample)
  188.         v = self.proj_v(x_sampled).reshape(B * self.n_heads, self.n_head_channels, n_sample)
  190.         attn = torch.einsum('b c m, b c n -> b m n', q, k)  # B * h, HW, Ns
  191.         attn = attn.mul(self.scale)
  193.         if self.use_pe and (not self.no_off):
  195.             if self.dwc_pe:
  196.                 residual_lepe = self.rpe_table(q.reshape(B, C, H, W)).reshape(B * self.n_heads, self.n_head_channels,
  197.                                                                               H * W)
  198.             elif self.fixed_pe:
  199.                 rpe_table = self.rpe_table
  200.                 attn_bias = rpe_table[None, ...].expand(B, -1, -1, -1)
  201.                 attn = attn + attn_bias.reshape(B * self.n_heads, H * W, n_sample)
  202.             elif self.log_cpb:
  203.                 q_grid = self._get_q_grid(H, W, B, dtype, device)
  204.                 displacement = (
  205.                             q_grid.reshape(B * self.n_groups, H * W, 2).unsqueeze(2) - pos.reshape(B * self.n_groups,
  206.                                                                                                    n_sample,
  207.                                                                                                    2).unsqueeze(1)).mul(
  208.                     4.0)  # d_y, d_x [-8, +8]
  209.                 displacement = torch.sign(displacement) * torch.log2(torch.abs(displacement) + 1.0) / np.log2(8.0)
  210.                 attn_bias = self.rpe_table(displacement)  # B * g, H * W, n_sample, h_g
  211.                 attn = attn + einops.rearrange(attn_bias, 'b m n h -> (b h) m n', h=self.n_group_heads)
  212.             else:
  213.                 rpe_table = self.rpe_table
  214.                 rpe_bias = rpe_table[None, ...].expand(B, -1, -1, -1)
  215.                 q_grid = self._get_q_grid(H, W, B, dtype, device)
  216.                 displacement = (
  217.                             q_grid.reshape(B * self.n_groups, H * W, 2).unsqueeze(2) - pos.reshape(B * self.n_groups,
  218.                                                                                                    n_sample,
  219.                                                                                                    2).unsqueeze(1)).mul(
  220.                     0.5)
  221.                 attn_bias = F.grid_sample(
  222.                     input=einops.rearrange(rpe_bias, 'b (g c) h w -> (b g) c h w', c=self.n_group_heads,
  223.                                            g=self.n_groups),
  224.                     grid=displacement[..., (1, 0)],
  225.                     mode='bilinear', align_corners=True)  # B * g, h_g, HW, Ns
  227.                 attn_bias = attn_bias.reshape(B * self.n_heads, H * W, n_sample)
  228.                 attn = attn + attn_bias
  230.         attn = F.softmax(attn, dim=2)
  231.         attn = self.attn_drop(attn)
  233.         out = torch.einsum('b m n, b c n -> b c m', attn, v)
  235.         if self.use_pe and self.dwc_pe:
  236.             out = out + residual_lepe
  237.         out = out.reshape(B, C, H, W)
  239.         y = self.proj_drop(self.proj_out(out))
  240.         h, w = pos.reshape(B, self.n_groups, Hk, Wk, 2), reference.reshape(B, self.n_groups, Hk, Wk, 2)
  242.         return y
  245. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  246.     """Pad to 'same' shape outputs."""
  247.     if d > 1:
  248.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  249.     if p is None:
  250.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  251.     return p
  254. class Conv(nn.Module):
  255.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  257.     default_act = nn.SiLU()  # default activation
  259.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  260.         """Initialize Conv layer with given arguments including activation."""
  261.         super().__init__()
  262.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  263.         self.bn = nn.BatchNorm2d(c2)
  264.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  266.     def forward(self, x):
  267.         """Apply convolution, batch normalization and activation to input tensor."""
  268.         return self.act(self.bn(self.conv(x)))
  270.     def forward_fuse(self, x):
  271.         """Perform transposed convolution of 2D data."""
  272.         return self.act(self.conv(x))
  274. class PSABlock(nn.Module):
  275.     """
  276.     PSABlock class implementing a Position-Sensitive Attention block for neural networks.
  278.     This class encapsulates the functionality for applying multi-head attention and feed-forward neural network layers
  279.     with optional shortcut connections.
  281.     Attributes:
  282.         attn (Attention): Multi-head attention module.
  283.         ffn (nn.Sequential): Feed-forward neural network module.
  284.         add (bool): Flag indicating whether to add shortcut connections.
  286.     Methods:
  287.         forward: Performs a forward pass through the PSABlock, applying attention and feed-forward layers.
  289.     Examples:
  290.         Create a PSABlock and perform a forward pass
  291.         >>> psablock = PSABlock(c=128, attn_ratio=0.5, num_heads=4, shortcut=True)
  292.         >>> input_tensor = torch.randn(1, 128, 32, 32)
  293.         >>> output_tensor = psablock(input_tensor)
  294.     """
  296.     def __init__(self, c, attn_ratio=0.5, num_heads=4, shortcut=True) -> None:
  297.         """Initializes the PSABlock with attention and feed-forward layers for enhanced feature extraction."""
  298.         super().__init__()
  300.         self.attn = DAttentionBaseline(c)
  301.         self.ffn = nn.Sequential(Conv(c, c * 2, 1), Conv(c * 2, c, 1, act=False))
  302.         self.add = shortcut
  304.     def forward(self, x):
  305.         """Executes a forward pass through PSABlock, applying attention and feed-forward layers to the input tensor."""
  306.         x = x + self.attn(x) if self.add else self.attn(x)
  307.         x = x + self.ffn(x) if self.add else self.ffn(x)
  308.         return x
  311. class C2PSA_DAT(nn.Module):
  312.     """
  313.     C2PSA module with attention mechanism for enhanced feature extraction and processing.
  315.     This module implements a convolutional block with attention mechanisms to enhance feature extraction and processing
  316.     capabilities. It includes a series of PSABlock modules for self-attention and feed-forward operations.
  318.     Attributes:
  319.         c (int): Number of hidden channels.
  320.         cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
  321.         cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
  322.         m (nn.Sequential): Sequential container of PSABlock modules for attention and feed-forward operations.
  324.     Methods:
  325.         forward: Performs a forward pass through the C2PSA module, applying attention and feed-forward operations.
  327.     Notes:
  328.         This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules.
  330.     Examples:
  331.         >>> c2psa = C2PSA(c1=256, c2=256, n=3, e=0.5)
  332.         >>> input_tensor = torch.randn(1, 256, 64, 64)
  333.         >>> output_tensor = c2psa(input_tensor)
  334.     """
  336.     def __init__(self, c1, c2, n=1, e=0.5):
  337.         """Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
  338.         super().__init__()
  339.         assert c1 == c2
  340.         self.c = int(c1 * e)
  341.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  342.         self.cv2 = Conv(2 * self.c, c1, 1)
  344.         self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))
  346.     def forward(self, x):
  347.         """Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
  348.         a, b = self.cv1(x).split((self.c, self.c), dim=1)
  349.         b = self.m(b)
  350.         return self.cv2(torch.cat((a, b), 1))
  352. if __name__ == "__main__":
  353.     # Generating Sample image
  354.     image_size = (1, 64, 224, 224)
  355.     image = torch.rand(*image_size)
  357.     # Model
  358.     model = C2PSA_DAT(64, 64)
  360.     out = model(image)
  361.     print(out.size())

四、添加DAT到你的网络中

4.1 修改一

第一还是建立文件，我们找到如下 ultralytics /nn文件夹下建立一个目录名字呢就是'Addmodules'文件夹( 用群内的文件的话已经有了无需新建) ！然后在其内部建立一个新的py文件将核心代码复制粘贴进去即可。

​

4.2 修改二

第二步我们在该目录下创建一个新的py文件名字为'__init__.py'( 用群内的文件的话已经有了无需新建) ，然后在其内部导入我们的检测头如下图所示。

4.3 修改三

第三步我门中到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块( 用群内的文件的话已经有了无需重新导入直接开始第四步即可) ！

从今天开始以后的教程就都统一成这个样子了，因为我默认大家用了我群内的文件来进行修改！！

​

4.4 修改四

按照我的添加在parse_model里添加即可。

到此就修改完成了，大家可以复制下面的yaml文件运行。

五、DAT的yaml文件和运行记录

5.1 DAT的yaml文件1

此版本训练信息：YOLO11-C2PSA-DAT summary: 321 layers, 2,621,723 parameters, 2,621,707 gradients, 6.5 GFLOPs 

  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  9.   s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  10.   m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  11.   l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  12.   x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
  14. # YOLO11n backbone
  15. backbone:
  16.   # [from, repeats, module, args]
  17.   - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  18.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  19.   - [-1, 2, C3k2, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2, [1024, True]]
  26.   - [-1, 1, SPPF, [1024, 5]] # 9
  27.   - [-1, 2, C2PSA_DAT, [1024]] # 10
  29. # YOLO11n head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
  39.   - [-1, 1, Conv, [256, 3, 2]]
  40.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  41.   - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)
  43.   - [-1, 1, Conv, [512, 3, 2]]
  44.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  45.   - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)
  47.   - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.2 DAT的yaml文件2

注意力机制我这里其实是添加了三个但是实际一般生效就只添加一个就可以了，所以大家可以自行注释来尝试.

此版本训练信息：YOLO11-DAT summary: 361 layers, 2,983,579 parameters, 2,983,563 gradients, 7.2 GFLOPs 

  1. # Ultralytics YOLO 🚀, AGPL-3.0 license
  2. # YOLO11 object detection model with P3-P5 outputs. For Usage examples see https://docs.ultralytics.com/tasks/detect
  4. # Parameters
  5. nc: 80 # number of classes
  6. scales: # model compound scaling constants, i.e. 'model=yolo11n.yaml' will call yolo11.yaml with scale 'n'
  7.   # [depth, width, max_channels]
  8.   n: [0.50, 0.25, 1024] # summary: 319 layers, 2624080 parameters, 2624064 gradients, 6.6 GFLOPs
  9.   s: [0.50, 0.50, 1024] # summary: 319 layers, 9458752 parameters, 9458736 gradients, 21.7 GFLOPs
  10.   m: [0.50, 1.00, 512] # summary: 409 layers, 20114688 parameters, 20114672 gradients, 68.5 GFLOPs
  11.   l: [1.00, 1.00, 512] # summary: 631 layers, 25372160 parameters, 25372144 gradients, 87.6 GFLOPs
  12.   x: [1.00, 1.50, 512] # summary: 631 layers, 56966176 parameters, 56966160 gradients, 196.0 GFLOPs
  14. # YOLO11n backbone
  15. backbone:
  16.   # [from, repeats, module, args]
  17.   - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  18.   - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  19.   - [-1, 2, C3k2, [256, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2, [512, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2, [512, True]]
  24.   - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2, [1024, True]]
  26.   - [-1, 1, SPPF, [1024, 5]] # 9
  27.   - [-1, 2, C2PSA, [1024]] # 10
  29. # YOLO11n head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2, [512, False]] # 13
  35.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  36.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  37.   - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)
  38.   - [-1, 1, DAttentionBaseline, []] # 17 (P3/8-small)  小目标检测层输出位置增加注意力机制
  40.   - [-1, 1, Conv, [256, 3, 2]]
  41.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  42.   - [-1, 2, C3k2, [512, False]] # 20 (P4/16-medium)
  43.   - [-1, 1, DAttentionBaseline, []] # 21 (P4/16-medium) 中目标检测层输出位置增加注意力机制
  45.   - [-1, 1, Conv, [512, 3, 2]]
  46.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  47.   - [-1, 2, C3k2, [1024, True]] # 24 (P5/32-large)
  48.   - [-1, 1, DAttentionBaseline, []] # 25 (P5/32-large) 大目标检测层输出位置增加注意力机制
  50.   # 注意力机制我这里其实是添加了三个但是实际一般生效就只添加一个就可以了，所以大家可以自行注释来尝试.
  51.   # 具体在那一层用注意力机制可以根据自己的数据集场景进行选择。
  52.   # 如果你自己配置注意力位置注意from[17, 21, 25]位置要对应上对应的检测层！
  53.   - [[17, 21, 25], 1, Detect, [nc]] # Detect(P3, P4, P5)

5.3 训练代码

大家可以创建一个py文件将我给的代码复制粘贴进去，配置好自己的文件路径即可运行。 

  1. import warnings
  2. warnings.filterwarnings('ignore')
  3. from ultralytics import YOLO
  5. if __name__ == '__main__':
  6.     model = YOLO('ultralytics/cfg/models/v8/yolov8-C2f-FasterBlock.yaml')
  7.     # model.load('yolov8n.pt') # loading pretrain weights
  8.     model.train(data=r'替换数据集yaml文件地址',
  9.                 # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
  10.                 cache=False,
  11.                 imgsz=640,
  12.                 epochs=150,
  13.                 single_cls=False,  # 是否是单类别检测
  14.                 batch=4,
  15.                 close_mosaic=10,
  16.                 workers=0,
  17.                 device='0',
  18.                 optimizer='SGD', # using SGD
  19.                 # resume='', # 如过想续训就设置last.pt的地址
  20.                 amp=False,  # 如果出现训练损失为Nan可以关闭amp
  21.                 project='runs/train',
  22.                 name='exp',
  23.                 )

5.4 DAT的训练过程截图

六、本文总结

到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv11改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充， 目前本专栏免费阅读(暂时，大家尽早关注不迷路~) ，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~