学习资源站

YOLOv11改进-融合改进篇-利用尺度统一检测头DynamicHead融合P2增加小目标检测层（让小目标无所遁形）

一、本文介绍

本文给大家带来的最新改进机制是针对性的改进， 针对于小目标检测增加P2层 ， 针对于大目标检测增加P6层 利用DynamicHead(原版本一比一复现，全网独一份，不同于网上魔改版本)进行检测，其中我们增加P2层其拥有更高的 分辨率 ，这使得 模型 能够更好地捕捉到小尺寸目标的细节。我们增加P6层是一个较低分辨率但具有更大感受野的特征层。对于大尺寸目标，这意味着模型可以更有效地捕捉到整体的结构信息。在这些的基础上我们配合DynamicHead可以使模型根据不同尺寸的目标动态调整其检测策略，进一步提升模型的精度。 本文的内容是订阅专栏的读者提出来的，所以大家订阅专栏以后如果有感兴趣的机制均可指定。

欢迎大家订阅我的专栏一起学习YOLO！

二、增加P2和P6层的好处

我们增加P2和P6层是为了改进 目标检测模型 ，特别是在处理不同大小目标的能力上。

1. 增加P2层的好处：

  • 改善小目标检测： P2层通常有更高的分辨率，这使得模型能够更好地捕捉到小尺寸目标的细节。较高分辨率的特征图能够提供更多的空间信息，有助于检测小物体。
  • 更精细的特征： 由于P2层处于网络的较浅层，它能够捕捉到更多的细粒度特征，这对于理解小目标的形状和纹理非常重要。

2. 增加P6层的好处：

  • 提升大目标检测性能： P6层是一个较低分辨率但具有更大感受野的特征层。对于大尺寸目标，这意味着模型可以更有效地捕捉到整体的结构信息。
  • 降低计算复杂度： 对于大目标，使用较低分辨率的特征图可以减少计算量，因为处理每个大目标需要的像素数较少。

3. 适应性能力的提升：

  • 使用DynamicHead可以使模型根据不同尺寸的目标动态调整其检测策略，进一步提升模型的泛化能力和适应性，从而进一步提高精度。

总结： 增加P2和P6层是为了让模型在处理不同尺寸的目标时更加高效和准确。这种策略特别适用于那些需要同时处理多种尺寸目标的应用场景的数据集，如街景图像分析、无人机视觉监控等。

三、DynamicHead的核心代码

代码的使用方式看章节四，看过前面本检测头的无需在重复添加！！！！！ 

  1. import copy
  2. import math
  3. from mmcv.ops import ModulatedDeformConv2d
  4. from ultralytics.utils.tal import dist2bbox, make_anchors
  5. import torch
  6. import torch.nn as nn
  7. import torch.nn.functional as F
  9. __all__ = ['DynamicHead']
  11. def _make_divisible(v, divisor, min_value=None):
  12.     if min_value is None:
  13.         min_value = divisor
  14.     new_v = max(min_value, int(v + divisor / 2) // divisor * divisor)
  15.     # Make sure that round down does not go down by more than 10%.
  16.     if new_v < 0.9 * v:
  17.         new_v += divisor
  18.     return new_v
  21. class h_swish(nn.Module):
  22.     def __init__(self, inplace=False):
  23.         super(h_swish, self).__init__()
  24.         self.inplace = inplace
  26.     def forward(self, x):
  27.         return x * F.relu6(x + 3.0, inplace=self.inplace) / 6.0
  30. class h_sigmoid(nn.Module):
  31.     def __init__(self, inplace=True, h_max=1):
  32.         super(h_sigmoid, self).__init__()
  33.         self.relu = nn.ReLU6(inplace=inplace)
  34.         self.h_max = h_max
  36.     def forward(self, x):
  37.         return self.relu(x + 3) * self.h_max / 6
  40. class DYReLU(nn.Module):
  41.     def __init__(self, inp, oup, reduction=4, lambda_a=1.0, K2=True, use_bias=True, use_spatial=False,
  42.                  init_a=[1.0, 0.0], init_b=[0.0, 0.0]):
  43.         super(DYReLU, self).__init__()
  44.         self.oup = oup
  45.         self.lambda_a = lambda_a * 2
  46.         self.K2 = K2
  47.         self.avg_pool = nn.AdaptiveAvgPool2d(1)
  49.         self.use_bias = use_bias
  50.         if K2:
  51.             self.exp = 4 if use_bias else 2
  52.         else:
  53.             self.exp = 2 if use_bias else 1
  54.         self.init_a = init_a
  55.         self.init_b = init_b
  57.         # determine squeeze
  58.         if reduction == 4:
  59.             squeeze = inp // reduction
  60.         else:
  61.             squeeze = _make_divisible(inp // reduction, 4)
  62.         # print('reduction: {}, squeeze: {}/{}'.format(reduction, inp, squeeze))
  63.         # print('init_a: {}, init_b: {}'.format(self.init_a, self.init_b))
  65.         self.fc = nn.Sequential(
  66.             nn.Linear(inp, squeeze),
  67.             nn.ReLU(inplace=True),
  68.             nn.Linear(squeeze, oup * self.exp),
  69.             h_sigmoid()
  70.         )
  71.         if use_spatial:
  72.             self.spa = nn.Sequential(
  73.                 nn.Conv2d(inp, 1, kernel_size=1),
  74.                 nn.BatchNorm2d(1),
  75.             )
  76.         else:
  77.             self.spa = None
  79.     def forward(self, x):
  80.         if isinstance(x, list):
  81.             x_in = x[0]
  82.             x_out = x[1]
  83.         else:
  84.             x_in = x
  85.             x_out = x
  86.         b, c, h, w = x_in.size()
  87.         y = self.avg_pool(x_in).view(b, c)
  88.         y = self.fc(y).view(b, self.oup * self.exp, 1, 1)
  89.         if self.exp == 4:
  90.             a1, b1, a2, b2 = torch.split(y, self.oup, dim=1)
  91.             a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0]  # 1.0
  92.             a2 = (a2 - 0.5) * self.lambda_a + self.init_a[1]
  94.             b1 = b1 - 0.5 + self.init_b[0]
  95.             b2 = b2 - 0.5 + self.init_b[1]
  96.             out = torch.max(x_out * a1 + b1, x_out * a2 + b2)
  97.         elif self.exp == 2:
  98.             if self.use_bias:  # bias but not PL
  99.                 a1, b1 = torch.split(y, self.oup, dim=1)
  100.                 a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0]  # 1.0
  101.                 b1 = b1 - 0.5 + self.init_b[0]
  102.                 out = x_out * a1 + b1
  104.             else:
  105.                 a1, a2 = torch.split(y, self.oup, dim=1)
  106.                 a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0]  # 1.0
  107.                 a2 = (a2 - 0.5) * self.lambda_a + self.init_a[1]
  108.                 out = torch.max(x_out * a1, x_out * a2)
  110.         elif self.exp == 1:
  111.             a1 = y
  112.             a1 = (a1 - 0.5) * self.lambda_a + self.init_a[0]  # 1.0
  113.             out = x_out * a1
  115.         if self.spa:
  116.             ys = self.spa(x_in).view(b, -1)
  117.             ys = F.softmax(ys, dim=1).view(b, 1, h, w) * h * w
  118.             ys = F.hardtanh(ys, 0, 3, inplace=True) / 3
  119.             out = out * ys
  121.         return out
  124. class Conv3x3Norm(torch.nn.Module):
  125.     def __init__(self, in_channels, out_channels, stride):
  126.         super(Conv3x3Norm, self).__init__()
  128.         self.conv = ModulatedDeformConv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1)
  129.         self.bn = nn.GroupNorm(num_groups=16, num_channels=out_channels)
  131.     def forward(self, input, **kwargs):
  132.         x = self.conv(input.contiguous(), **kwargs)
  133.         x = self.bn(x)
  134.         return x
  137. class DyConv(nn.Module):
  138.     def __init__(self, in_channels=256, out_channels=256, conv_func=Conv3x3Norm):
  139.         super(DyConv, self).__init__()
  141.         self.DyConv = nn.ModuleList()
  142.         self.DyConv.append(conv_func(in_channels, out_channels, 1))
  143.         self.DyConv.append(conv_func(in_channels, out_channels, 1))
  144.         self.DyConv.append(conv_func(in_channels, out_channels, 2))
  146.         self.AttnConv = nn.Sequential(
  147.             nn.AdaptiveAvgPool2d(1),
  148.             nn.Conv2d(in_channels, 1, kernel_size=1),
  149.             nn.ReLU(inplace=True))
  151.         self.h_sigmoid = h_sigmoid()
  152.         self.relu = DYReLU(in_channels, out_channels)
  153.         self.offset = nn.Conv2d(in_channels, 27, kernel_size=3, stride=1, padding=1)
  154.         self.init_weights()
  156.     def init_weights(self):
  157.         for m in self.DyConv.modules():
  158.             if isinstance(m, nn.Conv2d):
  159.                 nn.init.normal_(m.weight.data, 0, 0.01)
  160.                 if m.bias is not None:
  161.                     m.bias.data.zero_()
  162.         for m in self.AttnConv.modules():
  163.             if isinstance(m, nn.Conv2d):
  164.                 nn.init.normal_(m.weight.data, 0, 0.01)
  165.                 if m.bias is not None:
  166.                     m.bias.data.zero_()
  168.     def forward(self, x):
  169.         next_x = {}
  170.         feature_names = list(x.keys())
  171.         for level, name in enumerate(feature_names):
  173.             feature = x[name]
  175.             offset_mask = self.offset(feature)
  176.             offset = offset_mask[:, :18, :, :]
  177.             mask = offset_mask[:, 18:, :, :].sigmoid()
  178.             conv_args = dict(offset=offset, mask=mask)
  180.             temp_fea = [self.DyConv[1](feature, **conv_args)]
  181.             if level > 0:
  182.                 temp_fea.append(self.DyConv[2](x[feature_names[level - 1]], **conv_args))
  183.             if level < len(x) - 1:
  184.                 input = x[feature_names[level + 1]]
  185.                 temp_fea.append(F.interpolate(self.DyConv[0](input, **conv_args),
  186.                                               size=[feature.size(2), feature.size(3)]))
  187.             attn_fea = []
  188.             res_fea = []
  189.             for fea in temp_fea:
  190.                 res_fea.append(fea)
  191.                 attn_fea.append(self.AttnConv(fea))
  193.             res_fea = torch.stack(res_fea)
  194.             spa_pyr_attn = self.h_sigmoid(torch.stack(attn_fea))
  195.             mean_fea = torch.mean(res_fea * spa_pyr_attn, dim=0, keepdim=False)
  196.             next_x[name] = self.relu(mean_fea)
  198.         return next_x
  201. def autopad(k, p=None, d=1):  # kernel, padding, dilation
  202.     """Pad to 'same' shape outputs."""
  203.     if d > 1:
  204.         k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]  # actual kernel-size
  205.     if p is None:
  206.         p = k // 2 if isinstance(k, int) else [x // 2 for x in k]  # auto-pad
  207.     return p
  210. class Conv(nn.Module):
  211.     """Standard convolution with args(ch_in, ch_out, kernel, stride, padding, groups, dilation, activation)."""
  212.     default_act = nn.SiLU()  # default activation
  214.     def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
  215.         """Initialize Conv layer with given arguments including activation."""
  216.         super().__init__()
  217.         self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), groups=g, dilation=d, bias=False)
  218.         self.bn = nn.BatchNorm2d(c2)
  219.         self.act = self.default_act if act is True else act if isinstance(act, nn.Module) else nn.Identity()
  221.     def forward(self, x):
  222.         """Apply convolution, batch normalization and activation to input tensor."""
  223.         return self.act(self.bn(self.conv(x)))
  225.     def forward_fuse(self, x):
  226.         """Perform transposed convolution of 2D data."""
  227.         return self.act(self.conv(x))
  229. class DFL(nn.Module):
  230.     """
  231.     Integral module of Distribution Focal Loss (DFL).
  233.     Proposed in Generalized Focal Loss https://ieeexplore.ieee.org/document/9792391
  234.     """
  236.     def __init__(self, c1=16):
  237.         """Initialize a convolutional layer with a given number of input channels."""
  238.         super().__init__()
  239.         self.conv = nn.Conv2d(c1, 1, 1, bias=False).requires_grad_(False)
  240.         x = torch.arange(c1, dtype=torch.float)
  241.         self.conv.weight.data[:] = nn.Parameter(x.view(1, c1, 1, 1))
  242.         self.c1 = c1
  244.     def forward(self, x):
  245.         """Applies a transformer layer on input tensor 'x' and returns a tensor."""
  246.         b, c, a = x.shape  # batch, channels, anchors
  247.         return self.conv(x.view(b, 4, self.c1, a).transpose(2, 1).softmax(1)).view(b, 4, a)
  248.         # return self.conv(x.view(b, self.c1, 4, a).softmax(1)).view(b, 4, a)
  252. class DWConv(Conv):
  253.     """Depth-wise convolution."""
  255.     def __init__(self, c1, c2, k=1, s=1, d=1, act=True):  # ch_in, ch_out, kernel, stride, dilation, activation
  256.         """Initialize Depth-wise convolution with given parameters."""
  257.         super().__init__(c1, c2, k, s, g=math.gcd(c1, c2), d=d, act=act)
  261. class DynamicHead(nn.Module):
  262.     """YOLOv8 Detect head for detection models. CSDNSnu77"""
  264.     dynamic = False  # force grid reconstruction
  265.     export = False  # export mode
  266.     end2end = False  # end2end
  267.     max_det = 300  # max_det
  268.     shape = None
  269.     anchors = torch.empty(0)  # init
  270.     strides = torch.empty(0)  # init
  272.     def __init__(self, nc=80, ch=()):
  273.         """Initializes the YOLOv8 detection layer with specified number of classes and channels."""
  274.         super().__init__()
  275.         self.nc = nc  # number of classes
  276.         self.nl = len(ch)  # number of detection layers
  277.         self.reg_max = 16  # DFL channels (ch[0] // 16 to scale 4/8/12/16/20 for n/s/m/l/x)
  278.         self.no = nc + self.reg_max * 4  # number of outputs per anchor
  279.         self.stride = torch.zeros(self.nl)  # strides computed during build
  280.         c2, c3 = max((16, ch[0] // 4, self.reg_max * 4)), max(ch[0], min(self.nc, 100))  # channels
  281.         self.cv2 = nn.ModuleList(
  282.             nn.Sequential(Conv(x, c2, 3), Conv(c2, c2, 3), nn.Conv2d(c2, 4 * self.reg_max, 1)) for x in ch
  283.         )
  284.         self.cv3 = nn.ModuleList(
  285.             nn.Sequential(
  286.                 nn.Sequential(DWConv(x, x, 3), Conv(x, c3, 1)),
  287.                 nn.Sequential(DWConv(c3, c3, 3), Conv(c3, c3, 1)),
  288.                 nn.Conv2d(c3, self.nc, 1),
  289.             )
  290.             for x in ch
  291.         )
  292.         self.dfl = DFL(self.reg_max) if self.reg_max > 1 else nn.Identity()
  294.         dyhead_tower = []
  295.         for i in range(self.nl):
  296.             channel = ch[i]
  297.             dyhead_tower.append(
  298.                 DyConv(
  299.                     channel,
  300.                     channel,
  301.                     conv_func=Conv3x3Norm,
  302.                 )
  303.             )
  304.         self.add_module('dyhead_tower', nn.Sequential(*dyhead_tower))
  307.         if self.end2end:
  308.             self.one2one_cv2 = copy.deepcopy(self.cv2)
  309.             self.one2one_cv3 = copy.deepcopy(self.cv3)
  311.     def forward(self, x):
  312.         tensor_dict = {i: tensor for i, tensor in enumerate(x)}
  313.         x = self.dyhead_tower(tensor_dict)
  314.         x = list(x.values())
  315.         """Concatenates and returns predicted bounding boxes and class probabilities."""
  316.         if self.end2end:
  317.             return self.forward_end2end(x)
  318.         for i in range(self.nl):
  319.             x[i] = torch.cat((self.cv2[i](x[i]), self.cv3[i](x[i])), 1)
  320.         if self.training:  # Training path
  321.             return x
  322.         y = self._inference(x)
  323.         return y if self.export else (y, x)
  325.     def forward_end2end(self, x):
  326.         """
  327.         Performs forward pass of the v10Detect module.
  329.         Args:
  330.             x (tensor): Input tensor.
  332.         Returns:
  333.             (dict, tensor): If not in training mode, returns a dictionary containing the outputs of both one2many and one2one detections.
  334.                            If in training mode, returns a dictionary containing the outputs of one2many and one2one detections separately.
  335.         """
  336.         x_detach = [xi.detach() for xi in x]
  337.         one2one = [
  338.             torch.cat((self.one2one_cv2[i](x_detach[i]), self.one2one_cv3[i](x_detach[i])), 1) for i in range(self.nl)
  339.         ]
  340.         for i in range(self.nl):
  341.             x[i] = torch.cat((self.cv2[i](x[i]), self.cv3[i](x[i])), 1)
  342.         if self.training:  # Training path
  343.             return {"one2many": x, "one2one": one2one}
  345.         y = self._inference(one2one)
  346.         y = self.postprocess(y.permute(0, 2, 1), self.max_det, self.nc)
  347.         return y if self.export else (y, {"one2many": x, "one2one": one2one})
  349.     def _inference(self, x):
  350.         """Decode predicted bounding boxes and class probabilities based on multiple-level feature maps."""
  351.         # Inference path
  352.         shape = x[0].shape  # BCHW
  353.         x_cat = torch.cat([xi.view(shape[0], self.no, -1) for xi in x], 2)
  354.         if self.dynamic or self.shape != shape:
  355.             self.anchors, self.strides = (x.transpose(0, 1) for x in make_anchors(x, self.stride, 0.5))
  356.             self.shape = shape
  358.         if self.export and self.format in {"saved_model", "pb", "tflite", "edgetpu", "tfjs"}:  # avoid TF FlexSplitV ops
  359.             box = x_cat[:, : self.reg_max * 4]
  360.             cls = x_cat[:, self.reg_max * 4 :]
  361.         else:
  362.             box, cls = x_cat.split((self.reg_max * 4, self.nc), 1)
  364.         if self.export and self.format in {"tflite", "edgetpu"}:
  365.             # Precompute normalization factor to increase numerical stability
  366.             # See https://github.com/ultralytics/ultralytics/issues/7371
  367.             grid_h = shape[2]
  368.             grid_w = shape[3]
  369.             grid_size = torch.tensor([grid_w, grid_h, grid_w, grid_h], device=box.device).reshape(1, 4, 1)
  370.             norm = self.strides / (self.stride[0] * grid_size)
  371.             dbox = self.decode_bboxes(self.dfl(box) * norm, self.anchors.unsqueeze(0) * norm[:, :2])
  372.         else:
  373.             dbox = self.decode_bboxes(self.dfl(box), self.anchors.unsqueeze(0)) * self.strides
  375.         return torch.cat((dbox, cls.sigmoid()), 1)
  377.     def bias_init(self):
  378.         """Initialize Detect() biases, WARNING: requires stride availability."""
  379.         m = self  # self.model[-1]  # Detect() module
  380.         # cf = torch.bincount(torch.tensor(np.concatenate(dataset.labels, 0)[:, 0]).long(), minlength=nc) + 1
  381.         # ncf = math.log(0.6 / (m.nc - 0.999999)) if cf is None else torch.log(cf / cf.sum())  # nominal class frequency
  382.         for a, b, s in zip(m.cv2, m.cv3, m.stride):  # from
  383.             a[-1].bias.data[:] = 1.0  # box
  384.             b[-1].bias.data[: m.nc] = math.log(5 / m.nc / (640 / s) ** 2)  # cls (.01 objects, 80 classes, 640 img)
  385.         if self.end2end:
  386.             for a, b, s in zip(m.one2one_cv2, m.one2one_cv3, m.stride):  # from
  387.                 a[-1].bias.data[:] = 1.0  # box
  388.                 b[-1].bias.data[: m.nc] = math.log(5 / m.nc / (640 / s) ** 2)  # cls (.01 objects, 80 classes, 640 img)
  390.     def decode_bboxes(self, bboxes, anchors):
  391.         """Decode bounding boxes."""
  392.         return dist2bbox(bboxes, anchors, xywh=not self.end2end, dim=1)
  394.     @staticmethod
  395.     def postprocess(preds: torch.Tensor, max_det: int, nc: int = 80):
  396.         """
  397.         Post-processes YOLO model predictions.
  399.         Args:
  400.             preds (torch.Tensor): Raw predictions with shape (batch_size, num_anchors, 4 + nc) with last dimension
  401.                 format [x, y, w, h, class_probs].
  402.             max_det (int): Maximum detections per image.
  403.             nc (int, optional): Number of classes. Default: 80.
  405.         Returns:
  406.             (torch.Tensor): Processed predictions with shape (batch_size, min(max_det, num_anchors), 6) and last
  407.                 dimension format [x, y, w, h, max_class_prob, class_index].
  408.         """
  409.         batch_size, anchors, _ = preds.shape  # i.e. shape(16,8400,84)
  410.         boxes, scores = preds.split([4, nc], dim=-1)
  411.         index = scores.amax(dim=-1).topk(min(max_det, anchors))[1].unsqueeze(-1)
  412.         boxes = boxes.gather(dim=1, index=index.repeat(1, 1, 4))
  413.         scores = scores.gather(dim=1, index=index.repeat(1, 1, nc))
  414.         scores, index = scores.flatten(1).topk(min(max_det, anchors))
  415.         i = torch.arange(batch_size)[..., None]  # batch indices
  416.         return torch.cat([boxes[i, index // nc], scores[..., None], (index % nc)[..., None].float()], dim=-1)
  420. if __name__ == "__main__":
  421.     # Generating Sample image CSDN Snu77
  422.     image1 = (1, 64, 32, 32)
  423.     image2 = (1, 64, 16, 16)
  424.     image3 = (1, 64, 8, 8)
  426.     image1 = torch.rand(image1)
  427.     image2 = torch.rand(image2)
  428.     image3 = torch.rand(image3)
  429.     image = [image1, image2, image3]
  430.     channel = (64, 64, 64)
  431.     # Model
  432.     mobilenet_v1 = DynamicHead(nc=80, ch=channel)  # 尺度统一检测头.
  434.     out = mobilenet_v1(image)
  435.     print(out)

四、手把手教你添加DynamicHead检测头

4.1 修改一

首先我们将上面的代码复制粘贴到' ultralytics /nn' 目录下新建一个py文件复制粘贴进去，具体名字自己来定，我这里起名为DynamicHead.py。

​

​

4.2 修改二

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

​​

4.3 修改三

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

​​

4.4 修改四

第四步我门找到如下文件'ultralytics/nn/tasks.py，找到如下的代码进行将检测头添加进去，这里给大家推荐个快速搜索的方法用ctrl+f然后搜索Detect然后就能快速查找了。

​​​

4.5 修改五

同理

​​​

4.6 修改六

这里有一些不一样，我们需要加一行代码 

  1.         else:
  2.             return 'detect'

为啥呢不一样，因为这里的m在代码执行过程中会将你的代码自动转换为小写，所以直接else方便一点，以后出现一些其它分割或者其它的教程的时候在提供其它的修改教程。

​​​

4.7 修改七

同理.

​​​

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

五、DynamicHead检测头的yaml文件

5.1 DynamicHead和P2融合yaml文件

此版本训练信息：YOLO11-P2-DynamicHead summary: 485 layers, 2,515,396 parameters, 2,515,380 gradients, 16.0 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. # YOLOv11.0-p2 head
  30. head:
  31.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  32.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  33.   - [-1, 2, C3k2, [256, 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, nn.Upsample, [None, 2, "nearest"]]
  40.   - [[-1, 2], 1, Concat, [1]] # cat backbone P2
  41.   - [-1, 2, C3k2, [256, False]] # 19 (P2/4-xsmall)  # 小目标可以尝试将这里的False设置为True.
  43.   - [-1, 1, Conv, [128, 3, 2]]
  44.   - [[-1, 16], 1, Concat, [1]] # cat head P3
  45.   - [-1, 2, C3k2, [256, False]] # 22 (P3/8-small)
  47.   - [-1, 1, Conv, [256, 3, 2]]
  48.   - [[-1, 13], 1, Concat, [1]] # cat head P4
  49.   - [-1, 2, C3k2, [256, False]] # 25 (P4/16-medium)
  51.   - [-1, 1, Conv, [256, 3, 2]]
  52.   - [[-1, 10], 1, Concat, [1]] # cat head P5
  53.   - [-1, 2, C3k2, [256, True]] # 28 (P5/32-large)
  55.   - [[19, 22, 25, 28], 1, DynamicHead, [nc]] # Detect(P2, P3, P4, P5)

5.2 DynamicHead和P6融合yaml文件

此版本训练信息：YOLO11-P6-DynamicHead summary: 491 layers, 2,725,596 parameters, 2,725,580 gradients, 5.0 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, [128, False, 0.25]]
  20.   - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  21.   - [-1, 2, C3k2, [256, False, 0.25]]
  22.   - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  23.   - [-1, 2, C3k2, [512, False, 0.25]]
  24.   - [-1, 1, Conv, [768, 3, 2]] # 7-P5/32
  25.   - [-1, 2, C3k2, [768, True]]
  26.   - [-1, 1, Conv, [1024, 3, 2]] # 9-P6/64
  27.   - [-1, 2, C3k2, [1024, True]]
  28.   - [-1, 1, SPPF, [1024, 5]] # 11
  30. # YOLOv11.0x6 head
  31. head:
  32.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  33.   - [[-1, 8], 1, Concat, [1]] # cat backbone P5
  34.   - [-1, 2, C3k2, [256, False]] # 14
  36.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  37.   - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  38.   - [-1, 2, C3k2, [256, False]] # 17
  40.   - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  41.   - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  42.   - [-1, 2, C3k2, [256, False]] # 20 (P3/8-small)
  44.   - [-1, 1, Conv, [256, 3, 2]]
  45.   - [[-1, 17], 1, Concat, [1]] # cat head P4
  46.   - [-1, 2, C3k2, [256, False]] # 23 (P4/16-medium)
  48.   - [-1, 1, Conv, [512, 3, 2]]
  49.   - [[-1, 14], 1, Concat, [1]] # cat head P5
  50.   - [-1, 2, C3k2, [256, True]] # 26 (P5/32-large)
  52.   - [-1, 1, Conv, [256, 3, 2]]
  53.   - [[-1, 11], 1, Concat, [1]] # cat head P6
  54.   - [-1, 2, C3k2, [256, True]] # 29 (P6/64-xlarge)  # True也可设置False尝试.
  56.   - [[20, 23, 26, 29], 1, DynamicHead, [nc]] # Detect(P3, P4, P5, P6)

六、完美运行记录

最后提供一下完美运行的图片。

​

​​

七、本文总结

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

​