yolov26改进 | Neck/颈部改进篇 | 利用ASF-YOLO改进yolov26特征融合层助力yolov26有效涨点（适用于实例分割和目标检测）
开始讲解之前推荐一下我的专栏，本专栏的内容支持(分类、检测、分割、追踪、关键点检测),专栏目前为限时折扣，欢迎大家订阅本专栏，本专栏每周更新3-5篇最新机制，更有包含我所有改进的文件和交流群提供给大家。
一、本文介绍
本文给大家带来的最新改进机制是ASF-YOLO，其是特别设计用于细胞实例分割。这个模型通过结合空间和尺度特征，提高了在处理细胞图像时的准确性和速度。在实验中，ASF-YOLO在数据科学竞赛数据集上取得了卓越的分割准确性和速度，达到了0.91的box mAP（平均精度），0.887的mask mAP，以及47.3 FPS的推理速度，效果非常的好，这个结构本来是用于分割的，我将其移植到了目标检测的模型上，所以其可以适用于分割和目标检测，当然其它的领域也可以用但是对于分割的同学效果是最好的，目标检测领域也有一定涨点效果，同时欢迎大家订阅本专栏，本专栏每周更新3-5篇最新机制，更有包含我所有改进的文件和交流群提供给大家。
欢迎大家订阅我的专栏一起学习YOLO！
专栏链接：YOLOv26有效涨点专栏包含：Conv、注意力机制、主干/Backbone、损失函数、优化器、后处理等改进机制
目录
二、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'文件夹！
4.2 修改二
然后在Addmodules文件夹内建立一个新的py文件，将本文章节三中的“核心代码"复制粘贴进去。
4.3 修改三
第二步我们在该目录下创建一个新的py文件名字为'__init__.py'，然后在其内部导入我们的文件，如下图所示。
4.4 修改四
第四步我门中到如下文件'ultralytics/nn/tasks.py'进行导入和注册我们的模块。
按照我的添加在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--------------------------------
五、正式训练
5.1 yaml文件
5.1.1 yaml文件1
训练信息：YOLO26-Neck-ASFYOLO-1 summary: 338 layers, 2,984,156 parameters, 2,984,156 gradients, 7.3 GFLOPs
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
# Ultralytics YOLO26 object detection model with P3/8 - P5/32 outputs
# Model docs: https://docs.ultralytics.com/models/yolo26
# Task docs: https://docs.ultralytics.com/tasks/detect
# Parameters
nc: 80 # number of classes
end2end: True # whether to use end-to-end mode
reg_max: 1 # DFL bins
scales: # model compound scaling constants, i.e. 'model=yolo26n.yaml' will call yolo26.yaml with scale 'n'
# [depth, width, max_channels]
n: [0.50, 0.25, 1024] # summary: 260 layers, 2,572,280 parameters, 2,572,280 gradients, 6.1 GFLOPs
s: [0.50, 0.50, 1024] # summary: 260 layers, 10,009,784 parameters, 10,009,784 gradients, 22.8 GFLOPs
m: [0.50, 1.00, 512] # summary: 280 layers, 21,896,248 parameters, 21,896,248 gradients, 75.4 GFLOPs
l: [1.00, 1.00, 512] # summary: 392 layers, 26,299,704 parameters, 26,299,704 gradients, 93.8 GFLOPs
x: [1.00, 1.50, 512] # summary: 392 layers, 58,993,368 parameters, 58,993,368 gradients, 209.5 GFLOPs
# YOLO26n 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, 3, True]] # 9
- [-1, 2, C2PSA, [1024]] # 10
# YOLO26n 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, True]] # 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, True]] # 18 (P3/8-small)
- [-1, 1, Conv, [256, 3, 2]] # 19
- [[-1, 15], 1, Concat, [1]] # 20 cat head P4
- [-1, 3, C3k2, [512, True]] # 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, 0.5, 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.1.2 yaml文件2
训练信息：YOLO26-Neck-ASFYOLO-2 summary: 347 layers, 2,984,935 parameters, 2,984,935 gradients, 7.3 GFLOPs
# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license
# Ultralytics YOLO26 object detection model with P3/8 - P5/32 outputs
# Model docs: https://docs.ultralytics.com/models/yolo26
# Task docs: https://docs.ultralytics.com/tasks/detect
# Parameters
nc: 80 # number of classes
end2end: True # whether to use end-to-end mode
reg_max: 1 # DFL bins
scales: # model compound scaling constants, i.e. 'model=yolo26n.yaml' will call yolo26.yaml with scale 'n'
# [depth, width, max_channels]
n: [0.50, 0.25, 1024] # summary: 260 layers, 2,572,280 parameters, 2,572,280 gradients, 6.1 GFLOPs
s: [0.50, 0.50, 1024] # summary: 260 layers, 10,009,784 parameters, 10,009,784 gradients, 22.8 GFLOPs
m: [0.50, 1.00, 512] # summary: 280 layers, 21,896,248 parameters, 21,896,248 gradients, 75.4 GFLOPs
l: [1.00, 1.00, 512] # summary: 392 layers, 26,299,704 parameters, 26,299,704 gradients, 93.8 GFLOPs
x: [1.00, 1.50, 512] # summary: 392 layers, 58,993,368 parameters, 58,993,368 gradients, 209.5 GFLOPs
# YOLO26n 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, 3, True]] # 9
- [-1, 2, C2PSA, [1024]] # 10
# YOLO26n 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, True]] # 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, True]] # 18 (P3/8-small)
- [-1, 1, Conv, [256, 3, 2]] # 19
- [[-1, 15], 1, Concat, [1]] # 20 cat head P4
- [-1, 3, C3k2, [512, True]] # 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, 0.5, 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.2 训练代码
大家可以创建一个py文件将我给的代码复制粘贴进去，配置好自己的文件路径即可运行。
import warnings
warnings.filterwarnings('ignore')
from ultralytics import YOLO
if __name__ == '__main__':
model = YOLO('模型配置文件地址,也就是5.1你保存到本地文件的地址')
# 如何切换模型版本, 上面的ymal文件可以改为 yolo26s.yaml就是使用的26s,
# 类似某个改进的yaml文件名称为yolo26-XXX.yaml那么如果想使用其它版本就把上面的名称改为yolo26l-XXX.yaml即可（改的是上面YOLO中间的名字不是配置文件的）！
# model.load('yolo26n.pt') # 是否加载预训练权重,科研不建议大家加载否则很难提升精度
model.train(
data=r"数据集文件地址",
# 如果大家任务是其它的'ultralytics/cfg/default.yaml'找到这里修改task可以改成detect, segment, classify, pose
cache=False,
imgsz=640,
epochs=20,
single_cls=False, # 是否是单类别检测
batch=16,
close_mosaic=0,
workers=0,
device='0',
optimizer='MuSGD', # using SGD/MuSGD
# resume=, # 这里是填写last.pt地址
amp=True, # 如果出现训练损失为Nan可以关闭amp
project='runs/train',
name='exp',
)
5.3 训练过程截图
五、本文总结
到此本文的正式分享内容就结束了，在这里给大家推荐我的YOLOv26改进有效涨点专栏，本专栏目前为新开的平均质量分98分，后期我会根据各种最新的前沿顶会进行论文复现，也会对一些老的改进机制进行补充，如果大家觉得本文帮助到你了，订阅本专栏，关注后续更多的更新~
专栏链接：