学习资源站

YOLOv11改进-添加注意力机制-添加TripletAttention三重注意力机制（附代码加机制原理加添加教程）

一、本文介绍

本文给大家带来的改进是 Triplet Attention三重注意力机制 。这个机制，它通过三个 不同的 视角来分析输入的数据，就好比三个人从不同的角度来观察同一幅画，然后共同决定哪些部分最值得注意。三重注意力机制的主要思想是在网络中引入了一种新的注意力模块，这个模块包含三个分支，分别关注图像的不同维度。 比如说，一个分支可能专注于图像的宽度，另一个分支专注于高度，第三个分支则聚焦于图像的深度，即色彩和纹理等特征 。这样一来，网络就能够更全面地理解图像内容，就像是得到了一副三维眼镜，能够看到图片的立体效果一样。

二、Triplet Attention机制原理

​

论文地址： 官方论文地址

代码地址： 官方代码地址

​

2.1 Triplet Attention的基本原理

三重注意力（Triplet Attention） 的基本原理是利用三支结构捕获输入数据的跨维度交互，从而计算注意力权重。这个方法能够构建输入通道或空间位置之间的相互依赖性，而且计算代价小。三重注意力由三个分支组成，每个分支负责捕获空间维度H或W与通道维度C之间的交互特征。通过对每个分支中的输入张量进行排列变换，然后通过Z池操作和一个大小为k×k的卷积层，生成注意力权重。这些权重是通过一个S形激活层生成的，然后应用于排列变换后的输入张量，再变换回原来的输入形状

三重注意力（Triplet Attention）的主要改进点包括：

  1. 跨维度的注意力权重计算 : 通过一个创新的三支结构捕获通道、高度、宽度三个维度之间的交互关系来计算注意力权重。

  2. 旋转操作和残差变换 : 通过旋转输入张量和应用残差变换来建立不同维度间的依赖，这是三重 注意力机制 中的关键步骤。

  3. 维度间依赖性的重要性 : 强调在计算注意力权重时，捕获跨维度依赖性的重要性，这是三重注意力的核心直觉和设计理念。

下面的图片是三重注意力的一个抽象表示图，展示了三个分支如何捕获跨维度交互。图中的每个子图表示三重注意力中的一个分支：

​

1. 分支（a）: 这个分支直接处理输入张量，没有进行旋转，然后通过残差变换来提取特征。

2. 分支（b）: 这个分支首先沿着宽度（W）和通道（C）的维度旋转输入张量，然后进行残差变换。

3. 分支（c）: 这个分支沿着高度（H）和通道（C）的维度旋转输入张量，之后同样进行残差变换。

总结 ： 通过这样的设计，三重注意力 模型 能够有效地捕获输入张量中的空间和通道维度之间的交互关系。这种方法使模型能够构建通道与空间位置之间的相互依赖性，提高模型对特征的理解能力。

2.2 Triplet Attention和其它简单注意力机制的对比

下面的图片是论文中三重注意力机制和其它注意力机制的一个对比大家有兴趣可以看看，横向扩展以下自己的知识库。

​

这张图片是一幅对比不同注意力模块的图示，其中包括：

1.Squeeze Excitation (SE) Module:
这个模块使用全局平均池化 ( Global Avg Pool) 生成通道描述符，接着通过两个全连接层（1x1 Conv），中间使用ReLU激活 函数 ，最后通过Sigmoid函数生成每个通道的权重。

2. Convolutional Block Attention Module (CBAM):
首先使用全局平均池化和全局最大池化（GAP + GMP）结合，再通过一个卷积层和ReLU激活函数，最后经过另一个卷积层和Sigmoid函数生成注意力权重。

3. Global Context (GC) Module:
从一个1x1卷积层开始，经过Softmax函数进行归一化，接着进行另一个1x1卷积，然后使用LayerNorm和最终的1x1卷积，通过广播加法结合原始特征图。

4. Triplet Attention (我们的方法):
分为三个分支，每个分支进行不同的处理：通道池化后的7x7卷积，Z池化，再接一个7x7卷积，然后是批量归一化和Sigmoid函数。每个分支都有一个Permute操作来调整维度。最后，三个分支的结果通过平均池化聚合起来生成最终的注意力权重。

每种模块都设计用于处理特征图（C x H x W），其中C是通道数，H是高度，W是宽度。这些模块通过不同方式计算注意力权重，增强网络对特征的重要部分的关注度，从而在各种视觉任务中提高性能。图片中的符号⊗代表 矩阵乘法 ，⊕代表广播元素级加法。

2.3 Triplet Attention的实现流程

下面的图片是三重注意力（Triplet Attention）的具体实现流程图 。 图中详细展示了三个分支如何处理输入张量，并最终合成三重注意力。下面是对这个过程的描述：

​

  1. 上部分支 : 负责计算通道维度C和空间维度W的注意力权重。这个分支对输入张量进行Z池化（Z-Pool）操作，然后通过一个卷积层（Conv），接着用Sigmoid函数生成注意力权重。

  2. 中部分支 : 负责捕获通道维度C与空间维度H和W之间的依赖性。这个分支首先进行相同的Z池化和卷积操作，然后同样通过Sigmoid函数生成注意力权重。

  3. 下部分支 : 用于捕获空间维度之间的依赖性。这个分支保持输入的身份（Identity，即不改变输入），执行Z池化和卷积操作，之后也通过Sigmoid函数生成注意力权重。

每个分支在生成注意力权重后，会对输入进行排列（Permutation），然后将三个分支的输出进行平均聚合（Avg）， 最终得到三重注意力输出 。

这种结构通过不同的旋转和排列操作，能够综合不同维度上的信息，更好地捕获数据的内在特征，同时这种方法在计算上是高效的，并且可以作为一个模块加入到现有的网络架构中，增强网络对复杂 数据结构 的理解和处理能力。

三、 Triplet Attention的完整代码

核心代码的使用方式看章节四！ 

  1. import torch
  2. import torch.nn as nn
  4. __all__ = ['C2PSA_TripleAttention', 'TripletAttention']
  6. class BasicConv(nn.Module):
  7.     def __init__(self, in_planes, out_planes, kernel_size, stride=1, padding=0, dilation=1, groups=1, relu=True,
  8.                  bn=True, bias=False):
  9.         super(BasicConv, self).__init__()
  10.         self.out_channels = out_planes
  11.         self.conv = nn.Conv2d(in_planes, out_planes, kernel_size=kernel_size, stride=stride, padding=padding,
  12.                               dilation=dilation, groups=groups, bias=bias)
  13.         self.bn = nn.BatchNorm2d(out_planes, eps=1e-5, momentum=0.01, affine=True) if bn else None
  14.         self.relu = nn.ReLU() if relu else None
  16.     def forward(self, x):
  17.         x = self.conv(x)
  18.         if self.bn is not None:
  19.             x = self.bn(x)
  20.         if self.relu is not None:
  21.             x = self.relu(x)
  22.         return x
  25. class ZPool(nn.Module):
  26.     def forward(self, x):
  27.         return torch.cat((torch.max(x, 1)[0].unsqueeze(1), torch.mean(x, 1).unsqueeze(1)), dim=1)
  30. class AttentionGate(nn.Module):
  31.     def __init__(self):
  32.         super(AttentionGate, self).__init__()
  33.         kernel_size = 7
  34.         self.compress = ZPool()
  35.         self.conv = BasicConv(2, 1, kernel_size, stride=1, padding=(kernel_size - 1) // 2, relu=False)
  37.     def forward(self, x):
  38.         x_compress = self.compress(x)
  39.         x_out = self.conv(x_compress)
  40.         scale = torch.sigmoid_(x_out)
  41.         return x * scale
  44. class TripletAttention(nn.Module):
  45.     def __init__(self, no_spatial=False):
  46.         super(TripletAttention, self).__init__()
  47.         self.cw = AttentionGate()
  48.         self.hc = AttentionGate()
  49.         self.no_spatial = no_spatial
  50.         if not no_spatial:
  51.             self.hw = AttentionGate()
  53.     def forward(self, x):
  54.         x_perm1 = x.permute(0, 2, 1, 3).contiguous()
  55.         x_out1 = self.cw(x_perm1)
  56.         x_out11 = x_out1.permute(0, 2, 1, 3).contiguous()
  57.         x_perm2 = x.permute(0, 3, 2, 1).contiguous()
  58.         x_out2 = self.hc(x_perm2)
  59.         x_out21 = x_out2.permute(0, 3, 2, 1).contiguous()
  60.         if not self.no_spatial:
  61.             x_out = self.hw(x)
  62.             x_out = 1 / 3 * (x_out + x_out11 + x_out21)
  63.         else:
  64.             x_out = 1 / 2 * (x_out11 + x_out21)
  65.         return x_out
  67. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  68.     """Pad to 'same' shape outputs."""
  69.     if d > 1:
  70.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  71.     if p is None:
  72.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  73.     return p
  76. class Conv(nn.Module):
  77.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  78.     default_act = nn.SiLU()  # default activation
  80.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  81.         """Initialize Conv layer with given arguments including activation."""
  82.         super().__init__()
  83.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  84.         self.bn = nn.BatchNorm2d(c2)
  85.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  87.     def forward(self, x):
  88.         """Apply convolution, batch normalization and activation to input tensor."""
  89.         return self.act(self.bn(self.conv(x)))
  91.     def forward_fuse(self, x):
  92.         """Perform transposed convolution of 2D data."""
  93.         return self.act(self.conv(x))
  96. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  97.     """Pad to 'same' shape outputs."""
  98.     if d > 1:
  99.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  100.     if p is None:
  101.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  102.     return p
  105. class Conv(nn.Module):
  106.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  108.     default_act = nn.SiLU()  # default activation
  110.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  111.         """Initialize Conv layer with given arguments including activation."""
  112.         super().__init__()
  113.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  114.         self.bn = nn.BatchNorm2d(c2)
  115.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  117.     def forward(self, x):
  118.         """Apply convolution, batch normalization and activation to input tensor."""
  119.         return self.act(self.bn(self.conv(x)))
  121.     def forward_fuse(self, x):
  122.         """Perform transposed convolution of 2D data."""
  123.         return self.act(self.conv(x))
  125. class PSABlock(nn.Module):
  126.     """
  127.     PSABlock class implementing a Position-Sensitive Attention block for neural networks.
  129.     This class encapsulates the functionality for applying multi-head attention and feed-forward neural network layers
  130.     with optional shortcut connections.
  132.     Attributes:
  133.         attn (Attention): Multi-head attention module.
  134.         ffn (nn.Sequential): Feed-forward neural network module.
  135.         add (bool): Flag indicating whether to add shortcut connections.
  137.     Methods:
  138.         forward: Performs a forward pass through the PSABlock, applying attention and feed-forward layers.
  140.     Examples:
  141.         Create a PSABlock and perform a forward pass
  142.         >>> psablock = PSABlock(c=128, attn_ratio=0.5, num_heads=4, shortcut=True)
  143.         >>> input_tensor = torch.randn(1, 128, 32, 32)
  144.         >>> output_tensor = psablock(input_tensor)
  145.     """
  147.     def __init__(self, c, attn_ratio=0.5, num_heads=4, shortcut=True) -> None:
  148.         """Initializes the PSABlock with attention and feed-forward layers for enhanced feature extraction."""
  149.         super().__init__()
  151.         self.attn = TripletAttention()
  152.         self.ffn = nn.Sequential(Conv(c, c * 2, 1), Conv(c * 2, c, 1, act=False))
  153.         self.add = shortcut
  155.     def forward(self, x):
  156.         """Executes a forward pass through PSABlock, applying attention and feed-forward layers to the input tensor."""
  157.         x = x + self.attn(x) if self.add else self.attn(x)
  158.         x = x + self.ffn(x) if self.add else self.ffn(x)
  159.         return x
  162. class C2PSA_TripleAttention(nn.Module):
  163.     """
  164.     C2PSA module with attention mechanism for enhanced feature extraction and processing.
  166.     This module implements a convolutional block with attention mechanisms to enhance feature extraction and processing
  167.     capabilities. It includes a series of PSABlock modules for self-attention and feed-forward operations.
  169.     Attributes:
  170.         c (int): Number of hidden channels.
  171.         cv1 (Conv): 1x1 convolution layer to reduce the number of input channels to 2*c.
  172.         cv2 (Conv): 1x1 convolution layer to reduce the number of output channels to c.
  173.         m (nn.Sequential): Sequential container of PSABlock modules for attention and feed-forward operations.
  175.     Methods:
  176.         forward: Performs a forward pass through the C2PSA module, applying attention and feed-forward operations.
  178.     Notes:
  179.         This module essentially is the same as PSA module, but refactored to allow stacking more PSABlock modules.
  181.     Examples:
  182.         >>> c2psa = C2PSA(c1=256, c2=256, n=3, e=0.5)
  183.         >>> input_tensor = torch.randn(1, 256, 64, 64)
  184.         >>> output_tensor = c2psa(input_tensor)
  185.     """
  187.     def __init__(self, c1, c2, n=1, e=0.5):
  188.         """Initializes the C2PSA module with specified input/output channels, number of layers, and expansion ratio."""
  189.         super().__init__()
  190.         assert c1 == c2
  191.         self.c = int(c1 * e)
  192.         self.cv1 = Conv(c1, 2 * self.c, 1, 1)
  193.         self.cv2 = Conv(2 * self.c, c1, 1)
  195.         self.m = nn.Sequential(*(PSABlock(self.c, attn_ratio=0.5, num_heads=self.c // 64) for _ in range(n)))
  197.     def forward(self, x):
  198.         """Processes the input tensor 'x' through a series of PSA blocks and returns the transformed tensor."""
  199.         a, b = self.cv1(x).split((self.c, self.c), dim=1)
  200.         b = self.m(b)
  201.         return self.cv2(torch.cat((a, b), 1))
  203. if __name__ == "__main__":
  204.     # Generating Sample image
  205.     image_size = (1, 64, 224, 224)
  206.     image = torch.rand(*image_size)
  208.     # Model
  209.     model = C2PSA_TripleAttention(64, 64)
  211.     out = model(image)
  212.     print(out.size())

四、手把手教你添加 Triplet Attention

4.1 修改一

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

4.2 修改二

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

4.3 修改三

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

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

​

4.4 修改四

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

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

五、 Triplet Attention 的yaml文件和运行记录

5.1 Triplet Attention 的yaml文件1

此版本训练信息：YOLO11-C2PSA-TripleAtt summary: 323 layers, 2,543,687 parameters, 2,543,671 gradients, 6.4 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_TripleAttention, [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 Triplet Attention 的yaml文件2

此版本训练信息：YOLO11-TripleAtt summary: 352 layers, 2,595,315 parameters, 2,595,299 gradients, 6.6 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, TripletAttention, []] # 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, TripletAttention, []] # 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, TripletAttention, []] # 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 Triplet Attention 的训练过程截图

六、本文总结

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