YOLOv11改进-Neck篇-利用ASF-YOLO改进yolov11特征融合层助力yolov11有效涨点（适用于实例分割和目标检测）

一、本文介绍

本文给大家带来的最新改进机制是 ASF-YOLO ，其是特别设计用于细胞实例分割。这个模型通过结合空间和尺度特征，提高了在处理细胞图像时的准确性和速度。在实验中， ASF-YOLO在2018年数据科学竞赛 数据集上取得了卓越的分割准确性和速度，达到了 0.91 的box mAP（平均精度）， 0.887 的mask mAP，以及 47.3 FPS的推理速度，效果非常的好， 这个结构本来是用于分割的，我将其移植到了目标检测的模型上，所以其可以适用于分割和目标检测， 当然其它的领域也可以用但是对于分割的同学效果是最好的，目标检测领域也有一定涨点效果， 同时欢迎大家订阅本专栏，本专栏每周更新3-5篇最新机制，更有包含我所有改进的文件和交流群提供给大家。

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

二、ASF-YOLO的框架原理

官方论文地址： 官方论文地址

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

ASF-YOLO 是一个基于YOLO的新型模型，专为细胞实例分割设计。它将注意力尺度序列融合（ASF）集成到YOLO框架中，提高了对细胞图像的检测和分割性能。ASF-YOLO包括尺度序列特征融合（SSFF）模块、三重特征编码器（TFE）模块和通道及位置注意力机制（CPAM），这些特性共同提升了模型的准确性。在细胞数据集上的评估表明，ASF-YOLO在分割精度和速度方面表现出色。论文详细介绍了模型架构、方法论和在细胞图像数据集上的评估，证明了其相较于现有方法的有效性。

ASF-YOLO的主要创新点包括：

1. 尺度序列特征融合（SSFF）模块： 用于增强网络在多尺度信息提取上的能力。
2. 三重特征编码器（TFE）模块： 融合不同尺度的特征图以增加详细信息。
3. 通道和位置注意力机制（CPAM）： 集成SSFF和TFE模块，专注于信息通道和与空间位置相关的小对象，从而提高检测和分割性能。
4. 优异的细胞实例分割性能： 在细胞数据集上显示出高度的分割准确性和速度。

这个图片来源于论文，文章中这个图片就特别模糊，不知道为什么，怎么发出来的文章。

这张图展示了ASF-YOLO模型的概览。模型主要包括尺度序列特征融合（SSFF）模块、三重特征编码（TFE）模块，以及基于CSPDarkNet主干网络和YOLO头部的通道和位置注意力模型（CPAM）。CSP和Concat模块来自于 YOLOv5 。在这个框架中，输入图像通过主干网络的不同层（P1到P5）进行特征提取，然后通过SSFF和CPAM模块进行特征融合和注意力加权，最终实现分割掩模的生成和不同尺度的边界框（P3，P4，P5 Box）的预测。

2.1 尺度序列特征融合（SSFF）模块

尺度序列特征融合（SSFF）模块是设计用于处理多尺度信息的关键组件。它的主要功能是增强神经网络在提取不同尺度特征时的能力。通过聚合来自网络不同层的特征，SSFF模块能够提供更为丰富和细致的特征表示，有助于改善模型在处理不同大小对象时的表现。这种融合策略特别适用于那些需要精确定位和识别图像中多尺度对象的任务，如细胞分割或面部识别等。通过SSFF，模型可以更有效地识别和理解图像中的细节，从而提高整体的检测和识别性能。

2.2 三重特征编码器（TFE）模块

在ASF-YOLO中的三重特征编码器（TFE）模块是一个创新的特征融合机制，它设计来处理不同尺寸的输入特征图。这个模块通过特定的操作，如卷积、批量标准化和激活函数，对来自网络不同层的特征图进行处理。然后，它使用上采样和下采样技术来对特征图进行空间尺寸的调整，以确保特征图的尺寸一致。最后，通过一个融合操作（通常是拼接），将这些不同尺度的特征图结合在一起，形成一个综合特征表示，以捕获更多的上下文信息和细节。这样的设计使得网络能够更有效地处理多尺度信息，对于诸如细胞分割这样的细粒度任务尤为重要。

图4展示了三重特征编码器（TFE）模块的结构。C代表通道数，S代表特征图大小。每个三重特征编码器模块使用三种不同大小的特征图作为输入。该模块通过卷积、批归一化和SiLU激活函数对特征进行处理，并使用最大池化和平均池化进行下采样，以及最近邻上采样方法进行上采样，最后通过Concat操作合并特征，生成综合的特征表示。

2.3 通道和位置注意力机制（CPAM）

通道和位置注意力机制（CPAM）旨在通过集成尺度序列特征融合（SSFF）和三重特征编码器（TFE）模块，提高对细节丰富的小对象的检测和分割能力。CPAM通过专注于信息丰富的通道以及与空间位置相关的小对象特征，能够为模型提供一种有效的注意力指导。这样的机制允许模型更加精准地识别和定位图像中的细小目标，从而提高检测和分割任务的性能

这张图展示了通道和位置注意力机制（CPAM）模块的结构。该模块包括通道注意力网络和位置注意力网络两部分。通道注意力部分通过平均池化和1D卷积来生成每个通道的权重，然后使用Sigmoid函数进行归一化。位置注意力网络分别对宽度和高度进行平均池化，再通过一个卷积层和Sigmoid函数生成空间权重。最后，这两个权重通过哈达玛积（元素间相乘）合并，以产生最终的加权输出，增强模型对特定通道和位置的聚焦能力。

三、ASF-YOLO的核心代码

使用方式看章节四。

import torch
import torch.nn as nn
import torch.nn.functional as F
import math
__all__ = ('Zoom_cat', 'ScalSeq', 'Add', 'attention_model')
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 Zoom_cat(nn.Module):
    def __init__(self):
        super().__init__()
        # self.conv_l_post_down = Conv(in_dim, 2*in_dim, 3, 1, 1)
    def forward(self, x):
        """l,m,s表示大中小三个尺度，最终会被整合到m这个尺度上"""
        l, m, s = x[0], x[1], x[2]
        tgt_size = m.shape[2:]
        l = F.adaptive_max_pool2d(l, tgt_size) + F.adaptive_avg_pool2d(l, tgt_size)
        # l = self.conv_l_post_down(l)
        # m = self.conv_m(m)
        # s = self.conv_s_pre_up(s)
        s = F.interpolate(s, m.shape[2:], mode='nearest')
        # s = self.conv_s_post_up(s)
        lms = torch.cat([l, m, s], dim=1)
        return lms
class ScalSeq(nn.Module):
    def __init__(self, inc, channel):
        super(ScalSeq, self).__init__()
        self.conv0 = Conv(inc[0], channel, 1)
        self.conv1 = Conv(inc[1], channel, 1)
        self.conv2 = Conv(inc[2], channel, 1)
        self.conv3d = nn.Conv3d(channel, channel, kernel_size=(1, 1, 1))
        self.bn = nn.BatchNorm3d(channel)
        self.act = nn.LeakyReLU(0.1)
        self.pool_3d = nn.MaxPool3d(kernel_size=(3,1,1))
    def forward(self, x):
        p3, p4, p5 = x[0], x[1], x[2]
        p3 = self.conv0(p3)
        p4_2 = self.conv1(p4)
        p4_2 = F.interpolate(p4_2, p3.size()[2:], mode='nearest')
        p5_2 = self.conv2(p5)
        p5_2 = F.interpolate(p5_2, p3.size()[2:], mode='nearest')
        p3_3d = torch.unsqueeze(p3, -3)
        p4_3d = torch.unsqueeze(p4_2, -3)
        p5_3d = torch.unsqueeze(p5_2, -3)
        combine = torch.cat([p3_3d, p4_3d, p5_3d],dim = 2)
        conv_3d = self.conv3d(combine)
        bn = self.bn(conv_3d)
        act = self.act(bn)
        x = self.pool_3d(act)
        x = torch.squeeze(x, 2)
        return x
class Add(nn.Module):
    # Concatenate a list of tensors along dimension
    def __init__(self, ch=256):
        super().__init__()
    def forward(self, x):
        input1, input2 = x[0], x[1]
        x = input1 + input2
        return x
class channel_att(nn.Module):
    def __init__(self, channel, b=1, gamma=2):
        super(channel_att, self).__init__()
        kernel_size = int(abs((math.log(channel, 2) + b) / gamma))
        kernel_size = kernel_size if kernel_size % 2 else kernel_size + 1
        self.avg_pool = nn.AdaptiveAvgPool2d(1)
        self.conv = nn.Conv1d(1, 1, kernel_size=kernel_size, padding=(kernel_size - 1) // 2, bias=False)
        self.sigmoid = nn.Sigmoid()
    def forward(self, x):
        y = self.avg_pool(x)
        y = y.squeeze(-1)
        y = y.transpose(-1, -2)
        y = self.conv(y).transpose(-1, -2).unsqueeze(-1)
        y = self.sigmoid(y)
        return x * y.expand_as(x)
class local_att(nn.Module):
    def __init__(self, channel, reduction=16):
        super(local_att, self).__init__()
        self.conv_1x1 = nn.Conv2d(in_channels=channel, out_channels=channel // reduction, kernel_size=1, stride=1,
                                  bias=False)
        self.relu = nn.ReLU()
        self.bn = nn.BatchNorm2d(channel // reduction)
        self.F_h = nn.Conv2d(in_channels=channel // reduction, out_channels=channel, kernel_size=1, stride=1,
                             bias=False)
        self.F_w = nn.Conv2d(in_channels=channel // reduction, out_channels=channel, kernel_size=1, stride=1,
                             bias=False)
        self.sigmoid_h = nn.Sigmoid()
        self.sigmoid_w = nn.Sigmoid()
    def forward(self, x):
        _, _, h, w = x.size()
        x_h = torch.mean(x, dim=3, keepdim=True).permute(0, 1, 3, 2)
        x_w = torch.mean(x, dim=2, keepdim=True)
        x_cat_conv_relu = self.relu(self.bn(self.conv_1x1(torch.cat((x_h, x_w), 3))))
        x_cat_conv_split_h, x_cat_conv_split_w = x_cat_conv_relu.split([h, w], 3)
        s_h = self.sigmoid_h(self.F_h(x_cat_conv_split_h.permute(0, 1, 3, 2)))
        s_w = self.sigmoid_w(self.F_w(x_cat_conv_split_w))
        out = x * s_h.expand_as(x) * s_w.expand_as(x)
        return out
class attention_model(nn.Module):
    # Concatenate a list of tensors along dimension
    def __init__(self, ch=256):
        super().__init__()
        self.channel_att = channel_att(ch)
        self.local_att = local_att(ch)
    def forward(self, x):
        input1, input2 = x[0], x[1]
        input1 = self.channel_att(input1)
        x = input1 + input2
        x = self.local_att(x)
        return x

四、手把手教你添加ASF-YOLO

4.1 修改一

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

4.2 修改二

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

4.3 修改三

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

4.4 修改四

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

# ------------------------------ASF-YOLO--------------------------------
        elif m is Zoom_cat:
            c2 = sum(ch[x] for x in f)
        elif m is Add:
            c2 = ch[f[-1]]
        elif m is ScalSeq:
            c1 = [ch[x] for x in f]
            c2 = make_divisible(args[0] * width, 8)
            args = [c1, c2]
        elif m is attention_model:
            args = [ch[f[-1]]]
# ------------------------------ASF-YOLO--------------------------------

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

五、正式训练

5.1 yaml文件1

训练信息：YOLO11n-ASFYOLO-1 summary: 391 layers, 2,964,595 parameters, 2,964,579 gradients, 7.8 GFLOPs

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

5.2 yaml文件2

训练信息：YOLO11n-ASFYOLO-2 summary: 403 layers, 2,965,374 parameters, 2,965,358 gradients, 7.8 GFLOPs

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

5.3 训练代码

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

import warnings
warnings.filterwarnings('ignore')
from ultralytics import YOLO
if __name__ == '__main__':
    model = YOLO('模型配置文件')
    # 如何切换模型版本, 上面的ymal文件可以改为 yolov8s.yaml就是使用的v8s,
    # 类似某个改进的yaml文件名称为yolov8-XXX.yaml那么如果想使用其它版本就把上面的名称改为yolov8l-XXX.yaml即可（改的是上面YOLO中间的名字不是配置文件的）！
    # model.load('yolov8n.pt') # 是否加载预训练权重,科研不建议大家加载否则很难提升精度
    model.train(data=r"C:\Users\Administrator\PycharmProjects\yolov5-master\yolov5-master\Construction Site Safety.v30-raw-images_latestversion.yolov8\data.yaml",
                # 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
                cache=False,
                imgsz=640,
                epochs=150,
                single_cls=False,  # 是否是单类别检测
                batch=16,
                close_mosaic=0,
                workers=0,
                device='0',
                optimizer='SGD', # using SGD
                # resume='runs/train/exp21/weights/last.pt', # 如过想续训就设置last.pt的地址
                amp=True,  # 如果出现训练损失为Nan可以关闭amp
                project='runs/train',
                name='exp',
                )

5.4 训练过程截图

五、本文总结

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