前言

本文介绍了将LS（Large - Small）卷积与YOLO26相结合的方法。LS卷积受人类视觉系统动态异尺度感知能力启发，由大核感知（LKP）和小核聚合（SKA）两部分组成，能实现“广域上下文捕获”和“局部关键特征融合”，解决传统卷积和自注意力在轻量级模型中的局限。我们将集成LS卷积的C3k2_LSConv模块引入YOLO26，对相关代码进行修改和注册，并配置了YOLO26 - C3k2_LSConv.yaml文件。实验脚本表明，该结合方式可应用于目标检测任务。

文章目录： YOLO26改进大全：卷积层、轻量化、注意力机制、损失函数、Backbone、SPPF、Neck、检测头全方位优化汇总

专栏链接: YOLO26改进专栏

介绍

摘要

视觉网络设计（包括卷积神经网络（CNNs）和视觉Transformer（ViTs））极大推动了计算机视觉领域的发展。然而，其复杂的计算过程给实际部署带来了挑战，在实时应用场景中尤为突出。为解决这一问题，研究者们探索了多种轻量级高效网络设计方案。但现有轻量级模型主要依赖自注意力机制和卷积进行令牌混合（token mixing），这种依赖导致轻量级网络的感知与聚合过程在有效性和效率上存在局限，难以在有限计算预算下平衡性能与效率。本文受高效人类视觉系统中固有的动态异尺度视觉能力启发，提出一种适用于轻量级视觉网络设计的“广域感知、精准聚焦（See Large, Focus Small）”策略。我们引入LS（大-小）卷积，该卷积结合了大核感知与小核聚合的特性，能够高效捕获广泛的感知信息，并针对动态复杂的视觉表征实现精准的特征聚合，从而实现对视觉信息的高效处理。基于LS卷积，我们提出了一个全新的轻量级模型家族LSNet。大量实验表明，在各类视觉任务中，LSNet相较于现有轻量级网络均具有更优的性能和效率。相关代码与模型可通过链接获取：https://github.com/jameslahm/lsnet。

文章链接

论文地址：论文地址

代码地址：代码地址

基本原理

LS（Large-Small）卷积是LSNet模型的核心创新组件，其设计灵感源于人类视觉系统的动态异尺度感知能力（外周视觉“看大视野”+ 中央视觉“聚焦细节”），旨在解决传统卷积/自注意力在轻量级模型中“感知范围有限”“聚合冗余”“效率低下”的问题，实现“高效广域感知”与“精准细粒度聚合”的协同，为轻量级视觉网络提供高性能、低计算成本的令牌混合（Token Mixing）方案。

一、设计背景与核心目标

在轻量级视觉模型中，传统令牌混合方式存在显著局限：

• 自注意力：感知与聚合共享同一尺度，扩展上下文需牺牲计算效率，且易对无意义背景区域产生冗余聚合；
• 传统卷积：依赖固定小核，感受野有限，权重静态不变，无法适应动态变化的视觉上下文。

LS卷积的核心目标是：在低计算预算下，同时实现“广域上下文捕获”（See Large）和“局部关键特征融合”（Focus Small），打破“感知-聚合尺度绑定”的限制，平衡模型性能与效率。

二、LS卷积的核心结构：两大模块协同工作

LS卷积由大核感知（Large-Kernel Perception, LKP） 和小核聚合（Small-Kernel Aggregation, SKA） 两部分组成，二者分工明确且深度协同——LKP负责“看大”（捕获全局上下文），SKA负责“聚焦小”（自适应融合局部关键特征），而非简单叠加大核与小核卷积。

1. 大核感知（LKP）：实现“See Large”，捕获广域上下文

LKP的核心作用是以低计算成本扩展感受野，建模令牌间的全局空间关系，类似人类外周视觉通过视杆细胞感知场景全貌的过程。其具体流程与设计细节如下：

（1）流程步骤

给定输入特征图 ( X \in \mathbb{R}^{H \times W \times C} )（( H,W ) 为空间分辨率，( C ) 为通道数），LKP通过三步生成“上下文自适应权重”，为后续SKA提供指导：

1. 逐点卷积（PW）降维：首先用1×1逐点卷积将通道数从 ( C ) 降至 ( \frac{C}{2} )（默认设置），目的是减少后续大核卷积的计算量，确保轻量级特性；
2. 大核深度卷积（DW）捕获广域信息：采用 kernel 尺寸为 ( K_L \times K_L )（默认 ( K_L=7 )）的深度卷积，对每个通道独立卷积，高效扩展感受野——深度卷积的计算量仅为标准卷积的 ( \frac{1}{C} )，可在“大核”与“低计算”间取得平衡；
3. 逐点卷积（PW）生成聚合权重：再次通过1×1逐点卷积，将大核深度卷积输出的“上下文特征”转换为上下文自适应权重 ( W \in \mathbb{R}^{H \times W \times D} )（( D ) 为权重维度，与后续SKA的分组数匹配），该权重编码了令牌间的全局空间关系，用于指导SKA的动态聚合。

（2）数学公式

对于单个令牌 ( x_i \in \mathbb{R}^C )，其对应的LKP权重生成过程可表示为： [ \begin{aligned} wi &= \mathcal{P}{ls}\left(xi, \mathcal{N}{K_L}(xi)\right) \ &= PW\left(DW{K_L \times KL}\left(PW\left(\mathcal{N}{K_L}(x_i)\right)\right)\right) \end{aligned} ] 其中：

• ( \mathcal{N}_{K_L}(x_i) ) 是令牌 ( x_i ) 周围 ( K_L \times K_L ) 大小的广域邻域；
• ( PW(\cdot) ) 表示逐点卷积，( DW_{K_L \times K_L}(\cdot) ) 表示 ( K_L \times K_L ) 大核深度卷积；
• ( w_i \in \mathbb{R}^D ) 是为 ( x_i ) 生成的上下文自适应权重，将用于SKA的动态聚合。

（3）关键设计优势

• 高效扩感受野：大核深度卷积（如7×7）比小核卷积（如3×3）的感受野扩大4倍以上，但计算量仅增加 ( \frac{K_L^2}{C} )（因深度卷积通道独立），适合轻量级模型；
• 全局关系建模：通过广域邻域 ( \mathcal{N}_{K_L}(x_i) ) 的特征交互，生成的权重 ( w_i ) 编码了令牌与全局上下文的关联，避免传统卷积“局部视野局限”。

2. 小核聚合（SKA）：实现“Focus Small”，自适应融合局部特征

SKA的核心作用是基于LKP生成的全局上下文权重，在局部小范围（( K_S \times K_S )）内精准融合关键特征，类似人类中央视觉通过视锥细胞聚焦细节的过程。其设计重点是“动态性”与“分组优化”，确保效率与精度的平衡。

（1）流程步骤

SKA以LKP生成的权重 ( W ) 为指导，对输入特征图 ( X ) 进行局部动态聚合，具体步骤如下：

1. 通道分组（Group）：将输入特征图的 ( C ) 个通道划分为 ( G ) 组（默认 ( G = \frac{C}{8} )），每组包含 ( \frac{C}{G} ) 个通道——同一组通道共享聚合权重，目的是减少内存开销和计算量（避免为每个通道单独生成权重）；
2. 权重重塑：将LKP生成的单个令牌权重 ( w_i \in \mathbb{R}^D ) 重塑为 ( w_i^* \in \mathbb{R}^{G \times K_S \times K_S} )，其中 ( K_S \times K_S ) 是小核尺寸（默认 ( K_S=3 )）——每个通道组对应一个 ( K_S \times K_S ) 的动态卷积核；
3. 动态小核卷积聚合：对于令牌 ( xi ) 的第 ( c ) 个通道 ( x{ic} )（属于第 ( g ) 组），用其对应组的动态核 ( w_{ig}^* \in \mathbb{R}^{K_S \times KS} )，对其局部邻域 ( \mathcal{N}{KS}(x{ic}) )（( K_S \times KS ) 大小）进行卷积，得到聚合后的特征 ( y{ic} )。

（2）核心设计优势

• 动态自适应：聚合权重 ( w_i^* ) 由LKP的全局上下文指导生成，不同令牌、不同通道组的权重不同，可自适应匹配动态视觉场景（如“天空区域”与“人物区域”的聚合权重差异），解决传统卷积“权重固定”的局限；
• 局部精准聚合：聚合范围限制在 ( K_S \times K_S )（默认3×3）小邻域，避免自注意力对无意义区域的冗余聚合，同时小核尺寸确保计算效率；
• 分组降开销：通道分组减少了权重参数数量（从 ( C \times K_S^2 ) 降至 ( G \times K_S^2 )），内存占用降低 ( \frac{C}{G} ) 倍（默认8倍），适配轻量级模型需求。

三、LS卷积的协同机制与核心创新

LS卷积的关键优势并非“大核+小核”的简单组合，而是LKP与SKA的深度协同：

1. LKP指导SKA：LKP生成的全局上下文权重 ( W ) 为SKA提供“注意力导向”，使SKA的聚合权重优先匹配语义相关区域（如物体边缘、纹理），避免盲目融合；
2. 异尺度分工：LKP负责“大视野感知”（全局关系建模），SKA负责“小范围聚合”（局部特征融合），二者尺度解耦——既扩大了感知范围，又保证了聚合精度，同时避免单一尺度的效率损失；
3. 低计算复杂度：通过“深度卷积（LKP）+ 通道分组（SKA）”的设计，LS卷积的总计算复杂度为： [ O\left( \frac{HWC}{4} \left( 3C + 2K_L^2 + (2G+4)K_S^2 \right) \right) ] 该复杂度与输入分辨率 ( HWC ) 呈线性关系，远低于自注意力的二次复杂度，且优于传统大核卷积（如7×7标准卷积的复杂度为 ( O(HWC K_L^2) )）。

核心代码

class SkaFn(Function):
    @staticmethod
    @custom_fwd
    def forward(ctx, x: torch.Tensor, w: torch.Tensor) -> torch.Tensor:
        # 解析参数
        ks = int(math.sqrt(w.shape[2]))  # 核大小 (K×K)
        pad = (ks - 1) // 2              # 填充大小
        n, ic, h, wd = x.shape           # x形状: (N, C_in, H, W)
        _, wc, _, _, _ = w.shape         # w形状: (N, C_w, K², H, W)
        G = ic // wc                     # 分组数 (G = C_in / C_w)

        # 保存反向传播所需参数
        ctx.ks = ks
        ctx.pad = pad
        ctx.G = G
        ctx.save_for_backward(x, w)

        # 输入填充与滑动窗口提取
        x_padded = torch.nn.functional.pad(x, (pad, pad, pad, pad), mode='constant', value=0.0)
        x_windows = x_padded.unfold(2, ks, 1).unfold(3, ks, 1)  # (N, C_in, H, W, K, K)
        x_windows = x_windows.permute(0, 1, 4, 5, 2, 3).contiguous()  # (N, C_in, K, K, H, W)
        x_windows = x_windows.view(n, ic, ks*ks, h, wd)  # (N, C_in, K², H, W)

        # 分组处理与加权聚合
        x_grouped = x_windows.view(n, G, wc, ks*ks, h, wd)  # (N, G, C_w, K², H, W)
        w_grouped = w.view(n, 1, wc, ks*ks, h, wd)          # (N, 1, C_w, K², H, W)
        out_grouped = torch.sum(x_grouped * w_grouped, dim=3)  # 沿K²维度求和
        out = out_grouped.view(n, ic, h, wd)  # 合并分组: (N, C_in, H, W)

        return out

    @staticmethod
    @custom_bwd
    def backward(ctx, go: torch.Tensor) -> tuple:
        ks = ctx.ks
        pad = ctx.pad
        G = ctx.G
        x, w = ctx.saved_tensors
        n, ic, h, wd = x.shape
        _, wc, k_sq, w_h, w_w = w.shape  # 解析w的维度: (N, C_w, K², H, W)

        # 计算x的梯度 (gx)
        gx = None
        if ctx.needs_input_grad[0]:
            # 填充梯度并提取窗口
            go_padded = torch.nn.functional.pad(go, (pad, pad, pad, pad), mode='constant', value=0.0)
            go_windows = go_padded.unfold(2, ks, 1).unfold(3, ks, 1)  # (N, C_in, H, W, K, K)
            go_windows = go_windows.permute(0, 1, 4, 5, 2, 3).contiguous()  # (N, C_in, K, K, H, W)
            go_windows = go_windows.view(n, ic, ks*ks, h, wd)  # (N, C_in, K², H, W)

            # 分组处理并求和
            go_grouped = go_windows.view(n, G, wc, ks*ks, h, wd)  # (N, G, C_w, K², H, W)
            w_grouped = w.view(n, 1, wc, ks*ks, h, wd)            # (N, 1, C_w, K², H, W)
            gx_grouped = torch.sum(go_grouped * w_grouped, dim=3)  # 沿K²维度求和
            gx = gx_grouped.view(n, ic, h, wd)  # 合并分组: (N, C_in, H, W)

        # 计算w的梯度 (gw) - 核心修正
        gw = None
        if ctx.needs_input_grad[1]:
            # 填充输入x并提取窗口
            x_padded = torch.nn.functional.pad(x, (pad, pad, pad, pad), mode='constant', value=0.0)
            x_windows = x_padded.unfold(2, ks, 1).unfold(3, ks, 1)  # (N, C_in, H, W, K, K)
            x_windows = x_windows.permute(0, 1, 4, 5, 2, 3).contiguous()  # (N, C_in, K, K, H, W)
            x_windows = x_windows.view(n, ic, ks*ks, h, wd)  # (N, C_in, K², H, W)

            # 分组处理（严格基于w的维度）
            x_grouped = x_windows.view(n, G, wc, ks*ks, h, wd)  # (N, G, C_w, K², H, W)
            go_grouped = go.view(n, G, wc, 1, h, wd)  # (N, G, C_w, 1, H, W) - 扩展K²维度

            # 计算分组梯度并聚合（关键：对G维度求和）
            gw_grouped = x_grouped * go_grouped  # (N, G, C_w, K², H, W)
            gw = gw_grouped.sum(dim=1)  # 聚合分组维度G: (N, C_w, K², H, W)

            # 强制形状匹配（应对极端情况）
            if gw.shape != w.shape:
                gw = gw[:, :wc, :k_sq, :w_h, :w_w].contiguous()

        return gx, gw

class SKA(torch.nn.Module):
    def forward(self, x: torch.Tensor, w: torch.Tensor) -> torch.Tensor:
        return SkaFn.apply(x, w)

class Conv2d_BN(torch.nn.Sequential):
    def __init__(self, a, b, ks=1, stride=1, pad=0, dilation=1,
                 groups=1, bn_weight_init=1):
        super().__init__()
        self.add_module('c', torch.nn.Conv2d(
            a, b, ks, stride, pad, dilation, groups, bias=False))
        self.add_module('bn', torch.nn.BatchNorm2d(b))
        torch.nn.init.constant_(self.bn.weight, bn_weight_init)
        torch.nn.init.constant_(self.bn.bias, 0)

    @torch.no_grad()
    def fuse(self):
        c, bn = self._modules.values()
        w = bn.weight / (bn.running_var + bn.eps)**0.5
        w = c.weight * w[:, None, None, None]
        b = bn.bias - bn.running_mean * bn.weight / \
            (bn.running_var + bn.eps)**0.5
        m = torch.nn.Conv2d(w.size(1) * self.c.groups, w.size(
            0), w.shape[2:], stride=self.c.stride, padding=self.c.padding, dilation=self.c.dilation, groups=self.c.groups,
            device=c.weight.device)
        m.weight.data.copy_(w)
        m.bias.data.copy_(b)
        return m

class LKP(nn.Module):
    def __init__(self, dim, lks, sks, groups):
        super().__init__()
        self.cv1 = Conv2d_BN(dim, dim // 2)
        self.act = nn.ReLU()
        self.cv2 = Conv2d_BN(dim // 2, dim // 2, ks=lks, pad=(lks - 1) // 2, groups=dim // 2)
        self.cv3 = Conv2d_BN(dim // 2, dim // 2)
        self.cv4 = nn.Conv2d(dim // 2, sks ** 2 * dim // groups, kernel_size=1)
        self.norm = nn.GroupNorm(num_groups=dim // groups, num_channels=sks ** 2 * dim // groups)

        self.sks = sks
        self.groups = groups
        self.dim = dim

    def forward(self, x):
        x = self.act(self.cv3(self.cv2(self.act(self.cv1(x)))))
        w = self.norm(self.cv4(x))
        b, _, h, width = w.size()
        # 确保w的形状正确：(batch, C_w, K², H, W)
        w = w.view(b, self.dim // self.groups, self.sks ** 2, h, width)
        return w

class LSConv(nn.Module):
    def __init__(self, dim):
        super(LSConv, self).__init__()
        self.lkp = LKP(dim, lks=7, sks=3, groups=8)
        self.ska = SKA()
        self.bn = nn.BatchNorm2d(dim)

实验

脚本

import warnings
warnings.filterwarnings('ignore')
from ultralytics import YOLO

if __name__ == '__main__':
#     修改为自己的配置文件地址
    model = YOLO('./ultralytics/cfg/models/26/yolo26-C3k2_LSConv.yaml')
#     修改为自己的数据集地址
    model.train(data='./ultralytics/cfg/datasets/coco8.yaml',
                cache=False,
                imgsz=640,
                epochs=10,
                single_cls=False,  # 是否是单类别检测
                batch=8,
                close_mosaic=10,
                workers=0,
                optimizer='MuSGD',  
                # optimizer='SGD',
                amp=False,
                project='runs/train',
                name='yolo26-C3k2_LSConv',
                )

结果