基于YOLOv11的多模态融合目标检测：MM_LSK大核选择模块实战

1. 先聊清楚：YOLOv11 里做多模态融合，到底解决什么问题

我最早做多模态目标检测，是被一个很低效率的场景逼出来的：白天光线条件好的时候，普通可见光相机（RGB）拍什么都清楚；一到黄昏、大雾、夜间补光不足，同一套模型就立刻“瞎”掉一大半。于是很自然就想到了把红外、深度或者偏振光这些补充模态一起喂进去，让模型在 RGB 失效的时候还有别的信息可以依赖。YOLOv11 本身是一个比较成熟、迭代速度很快的单模态目标检测框架，要在它身上做多模态融合改进，刚上手时第一反应肯定是“把两个模态的输入在图像层面直接拼在一起，然后送进同一个 Backbone”。

这个做法简单，但实测下来效果往往不合格。早期融合最大的问题在于：RGB 和红外/深度图在特征分布、噪声水平、信息粒度上都不一样，你简单 concat 出来的多通道张量，等于强迫同一个卷积核同时去响应两种差异很大的分布。模型确实能学到一些东西，但学到的基本是“谁响应更强就听谁的”，并没有真正建立跨模态的互补关系。另一个常见做法是在 Neck 输出的高层特征图上做 late fusion，两个分支各自出特征再相加或拼接。这个能保住一部分单模态特征，但融合发生在感受野已经固定之后，两个分支的信息已经“各说各话”，没有在一个更灵活的尺度上进行交互。

所以我的核心目标就定为：在不推翻 YOLOv11 主体结构的前提下，设计一个可以插入 Backbone、Neck 和 Head 中间某个关键位置的融合模块，让两个模态的特征既能各自保留原始细节，又能在多个感受野尺度上动态挑选最合适的组合方式。这个模块就是后来定型的 MM_LSK，全称 Multi-Modal Large Kernel Select。有一点先说清楚，它不属于某篇论文的官方开源模块，算是我自己动手改结构改训练代码折腾出来的一个自定义组件，后来在几个内部业务数据集上做对比实验，确实把融合问题往“可控”的方向推了一大截。

1.1 一个典型的多模态检测场景

拿一个很常见的安防场景来举例：摄像头同时输出可见光画面和红外画面，两者在时间上已经由硬件做了同步，像素也做过对齐。白天的可见光里有丰富的颜色和纹理，红外噪点比较多；到了晚上，可见光基本报废，红外却能清楚地把行人、车辆这些发热目标框出来。如果只训练 RGB 分支，夜间场景直接崩；只用红外分支，白天又会丢失大量语义信息。这种场景就是多模态融合最典型的应用环境。

数据形态上通常有两种处理方式。一种是把红外图也转成单通道，然后和 RGB 三通道拼成 4 通道输入；另一种是让两个模态各自走一个分支，到中间层再融合。MM_LSK 采用的是第二种，但比普通的双分支加 concat 多了一个关键动作：它不是在固定尺度上硬拼，而是同时用不同大小的感受野去“观察”两个模态的特征，再学习出每个尺度上应该更相信哪个模态、应该把多少信息放进来。

1.2 三种常见融合方式，为什么都不够

我把最初试过的几种融合方式列一下，供后来者避坑：

• 早期融合：输入层直接把 RGB 3 通道 + 红外 1 通道拼成 4 通道，Backbone 第一层卷积的输入维度从 3 变成 4。优点是实现成本最低，几乎不用改结构；缺点是卷积核天然会把不同模态的权重混在一起，无法区分“这个位置的纹理主要来自 RGB，那个位置的热辐射主要来自红外”。

• 中期融合：两个模态分别过一个轻量 Backbone（或者共享 Backbone），在某个中间特征层 concat 后再进入后续层。优点是各模态的特征没有被过早混淆；缺点是 concat 之后依然是固定权重的卷积，感受野相同，无法自适应不同目标尺寸下的特征需求。

• 晚期融合：两个分支各自出完整特征图，最后在 Head 附近做加权求和或者“软注意力”。优点是灵活，可以做置信度级的决策；缺点是融合太晚，很多空间细节在 Backbone 中就已经丢失了，融合的收益有限。

MM_LSK 的思路介于中期融合和晚期融合之间，核心做法是：两个模态分别经过独立的轻量 Backbone，在多个尺度上提取特征，然后在 Neck 的第一层把同尺度的特征送进同一个大核选择模块。模块内部会动态生成空间注意力权重和通道注意力权重，最终输出一张融合后的特征图，继续走 YOLOv11 原本的 Neck 和 Head 路径。这样既保留了双分支的独立性，又让融合点具备多尺度感知能力。

2. 为什么选“大核选择”这个思路做跨模态适配

大核选择（Large Kernel Selection，简称 LSK）并不是我原创的机制，它早就在一些语义分割和视觉 Transformer 的工作里出现过。核心直觉很朴素：卷积核感受野越大，能看到的上下文范围就越大，但计算量和参数也水涨船高。于是有人想了一个折中办法，不直接上一个很大的卷积核，而是同时放几个不同尺寸的卷积核，让网络根据输入内容动态地决定“当前这个位置用什么尺寸去感知”。这就是“核选择”的含义。

在单模态任务里，LSK 已经被验证能有效扩大感受野，让网络在“精细纹理”和“全局结构”之间做权衡。但换到多模态场景，我遇到了新的问题：RGB 图上的小目标可能只需要局部的颜色对比，红外图上的同一目标可能更依赖它跟背景的热辐射差异，这种差异只有在足够大的范围内才能被感知到。同一个目标，不同模态对感受野的需求很可能是不一致的。所以我们需要的不只是在一个输入上选择大核还是小核，而是在两个模态各自的特征上先选择，再综合考虑如何融合。

2.1 LSK 的本质，是对感受野做“动态路由”

你可以把一个大卷积核拆成几个并联的小、中、大卷积核分支，每个分支的输出经过归一化和激活函数之后，用一组空间注意力权重做加权求和。这个权重不是训练完就固定的，而是根据输入图片动态生成的。某个像素点周围有细密纹理，网络就把权重偏向小卷积核；某个像素点处于大目标内部、需要看整体轮廓，网络就把权重偏向大卷积核。这就像在每个位置上做了一次“感受野路由”，让不同尺度的信息流动到不同的空间位置。

我对 YOLOv11 里的特征层做过分析，发现高层特征图（如 P5 那一级）已经具备比较大的感受野，但中低层特征图（P3、P4）在原生结构里对小目标信息更敏感，对大目标的上下文感知偏弱。如果用固定 3x3 卷积做融合，融合后的特征仍然缺“全局视野”。引入 LSK 之后，相当于在融合点给网络开了一扇窗口，让它可以“想大就大、想小就小”。

2.2 MM_LSK 对比单模态 LSK 增加了什么

单模态 LSK 的输入是一张特征图，输出是一张特征图，内部做的只是感受野自适应。MM_LSK 我在前面加了一个跨模态交互的步骤，并且让 kernel selection 的权重同时参考两个模态的信息。我用两个独立的 1x1 卷积分别把 RGB 分支和红外分支投影到同一个低维空间，然后算它们的逐元素差异和逐元素乘积，把这个“差异-乘积”特征作为生成注意力路由的输入。为什么这么做？因为逐元素乘积能捕捉两个模态之间同时激活的共性部分，逐元素差异则能捕捉互补的部分，两者拼在一起，才能代表“融合应该关注哪里”。

这个设计直接导致了一个效果上的差异：在单模态 LSK 里，如果 RGB 特征很弱，网络只能根据 RGB 自己算出一个小核权重；在 MM_LSK 里，红外特征如果有强烈的热辐射响应，它会通过跨模态的差异和乘积分量去影响 kernel selection，从而让网络在这个位置改用更大的感受野去抓全局热辐射对比。这是我认为 MM_LSK 最有价值的地方。

3. MM_LSK 模块的详细设计与实现

设计时我定了三个硬指标：

• 必须能作为普通模块插入 YOLOv11 的 Neck 里，不改动原有的 Anchor-Free 检测头。
• 输入是两个模态的特征图（形状都是 C×H×W），输出是一张融合特征图（形状 C×H×W），这样后续网络结构完全不用动。
• 参数量和计算量不能比一个普通的 3x3 卷积模块高出太多，否则训练和推理延迟都扛不住。

最终版模块的结构拆开来看，主要有四个阶段：双模态投影、跨模态交互、多分支大核选择、自适应融合输出。

3.1 总体结构

先画一个整体的数据流：

1. RGB 特征图 F_rgb（C×H×W）和红外特征图 F_ir（C×H×W）进入模块。

2. 各自经过一个 1x1 卷积降维到 C//k（实际我常用 k=2 或 k=4），这一步是为了压缩通道数、降低后续计算量，同时强迫两个模态在同一个低维空间里“对话”。

3. 对两个低维特征做逐元素相减 diff 和逐元素相乘 prod，拼接成一个 2×(C//k) 的交互特征。

4. 交互特征经过一个小型卷积编码器，输出两个大核分支的注意力图（分辨率与原特征图一致），注意力图包含空间维度上的 softmax 权重。

5. 在原始高维特征上分别用不同尺寸的卷积核（比如 3x3、7x7、15x7 可分离卷积）提取多尺度信息，用步骤 4 生成的权重做加权融合。

6. 融合后的多尺度特征与一开始的 RGB/红外特征做一个残差连接，稳定训练。

实际操作中我把“大核”设计成了一个 7x7 卷积和两个级联的 1x7 + 7x1 卷积的组合，这个组合能逼近真实大核的感受野，但参数量远小于一个满秩的大核卷积。

3.2 核心代码实现

下面给出一个可直接运行的 PyTorch 实现，我是基于常见开源代码风格整理的，这里的关键是理解逻辑而不是照抄结构。

python复制import torch
import torch.nn as nn
import torch.nn.functional as F

class MM_LSK(nn.Module):
    """
    Multi-Modal Large Kernel Select
    输入: x_rgb (B, C, H, W), x_ir (B, C, H, W)
    输出: out   (B, C, H, W)
    """
    def __init__(self, dim, reduction=2):
        super().__init__()
        inner_dim = max(dim // reduction, 8)

        # 双模态投影
        self.proj_rgb = nn.Conv2d(dim, inner_dim, 1)
        self.proj_ir  = nn.Conv2d(dim, inner_dim, 1)

        # 跨模态交互编码
        self.interact = nn.Sequential(
            nn.Conv2d(inner_dim * 2, inner_dim, 1),
            nn.BatchNorm2d(inner_dim),
            nn.ReLU(inplace=True)
        )

        # 生成注意力路由: 权重尺寸为 1x1 的卷积
        self.route = nn.Conv2d(inner_dim, 2, 1)

        # 多分支大核抽取
        self.branch_small = nn.Conv2d(dim, dim, 3, padding=1, groups=dim)
        self.branch_mid = nn.Conv2d(dim, dim, 7, padding=3, groups=dim)
        self.branch_large = nn.Sequential(
            nn.Conv2d(dim, dim, (1, 7), padding=(0, 3), groups=dim),
            nn.Conv2d(dim, dim, (7, 1), padding=(3, 0), groups=dim),
        )

        # 输出融合
        self.fuse_conv = nn.Sequential(
            nn.Conv2d(dim * 3, dim, 1),
            nn.BatchNorm2d(dim),
            nn.ReLU(inplace=True)
        )

    def forward(self, x_rgb, x_ir):
        B, C, H, W = x_rgb.shape

        # 1. 投影
        rgb_proj = self.proj_rgb(x_rgb)
        ir_proj = self.proj_ir(x_ir)

        # 2. 跨模态交互
        diff = rgb_proj - ir_proj
        prod = rgb_proj * ir_proj
        interact_feat = torch.cat([diff, prod], dim=1)
        interact_feat = self.interact(interact_feat)

        # 3. 路由权重
        route_map = self.route(interact_feat)  # (B, 2, H, W)
        route_map = route_map.softmax(dim=1)
        w0 = route_map[:, 0:1, :, :]  # 小核权重
        w1 = route_map[:, 1:2, :, :]  # 大核权重

        # 4. 多尺度抽取
        small = self.branch_small(x_rgb + x_ir)
        mid = self.branch_mid(x_rgb + x_ir)
        large = self.branch_large(x_rgb + x_ir)

        # 5. 动态加权融合
        multi_scale = w0 * small + w1 * large + (1 - w0 - w1) * mid
        out = torch.cat([multi_scale, x_rgb, x_ir], dim=1)
        out = self.fuse_conv(out)
        return out

这个版本我用的是 groups=dim 的深度卷积，主要是为了控制参数量。7x7 的深度卷积对大部分显卡都很友好，唯一要注意的是某些底层推理框架对非 3x3 深度卷积的优化不够好，在部署前要用目标平台的性能评测工具先跑一遍。

3.3 关键设计细节与参数选择

有几个参数是我反复试出来的，写了供参考：

• reduction：控制投影层是否要压得太狠。我用 2 的时候，融合效果和参数量比较均衡；用 4 时速度能快一点，但小目标精度有所下降，因为降维导致空间细节丢失。如果你接的是轻量级算力平台，可以尝试 4 并配合更强的数据增强补偿。

• 卷积核尺寸：我最后选了 3、7、1x7+7x1 三类。为什么不直接上 15x15？原因有两个，一是 15x15 满秩卷积的参数量在深层次特征图上太夸张；二是很多不同尺度的特征其实用 7x7 就能覆盖到，15x15 非但没有带来质变，反而让注意力路由更难收敛。

• 残差策略：我把 x_rgb 和 x_ir 一起 concat 到最终输入里，而不是只用 multi_scale。这样两个模态的原始信息还能有一条“直通通道”进入输出，避免注意力路由学坏了导致信息被过滤掉。

• 是否共享投影权重：我把 proj_rgb 和 proj_ir 设成两个独立卷积。从理论上讲 RGB 和红外的统计特性差异很大，共享权重会强行拉近两个模态的分布；从实验结果看，独立分支比共享权重高约 0.6~0.9 个点，所以不值得为了省那一点参数做共享。

4. 把 MM_LSK 集成到 YOLOv11 的训练链路

模块设计好之后，剩下的大头工作是怎么把它放进 YOLOv11 的训练代码里。我最初踩过一个坑：直接把 MM_LSK 塞在 Backbone 后面，结果训练速度很慢，而且因为融合位置太靠前，两个模态的低层特征还没有经过充分的语义抽象，直接交互反而把低层的噪声也放大了。后来我调整了集成方式，放在 Neck 的第一层输入之前，效果明显变好。

4.1 模型结构上的集成点

YOLOv11 的默认结构大致包含 Backbone、Neck（特征金字塔部分）和 Head 三个部分。我的方案是：两个模态各走一个完全相同的 Backbone（结构上就是 YOLOv11 默认 Backbone 复制两份），但两份 Backbone 不共享权重。为什么不共享？因为红外和 RGB 的低层特征差异太大，共享权重会导致 Backbone 要同时拟合两种分布，最后两边都学不到位。两份 Backbone 的参数量确实翻倍了，但换来的是各自模态的特征质量明显更高。

两个 Backbone 会在多个尺度上输出特征图，我只在 P3、P4、P5 这三个输出层级上各放一个 MM_LSK 进行融合。融合之后的特征图直接送入 YOLOv11 原本的 Neck 结构。这样 Neck 和 Head 完全不用改，只需要改一下 Backbone 和 Neck 之间的数据流。

在代码层面，我把 YOLOv11 的模型定义里 Backbone 返回值改成了同时输出 RGB 分支和 IR 分支的特征列表，然后在 Neck 里逐个调 MM_LSK。

4.2 训练配置与损失设计

我用的损失函数和 YOLOv11 默认的一样：分类损失用 BCE，回归损失用 CIOU 或者 DFL，整体是一个多任务损失之和。这里要特别注意的是，两个 Backbone 的梯度都会流经 MM_LSK，所以如果 MM_LSK 内部的设计有“梯度阻断”操作，两个分支的学习就会失衡。我在实践中发现，如果对融合后的特征做 detach() 再送进 Head，模型会快速退化成只学单模态，因为梯度无法传回另一个模态的 Backbone。所以在最终实现里，MM_LSK 到两个 Backbone 的梯度通道必须是完整连通的。

训练超参数方面，我建议不要把学习率直接沿用单模态 YOLOv11 的配置。因为多了跨模态交互分支，损失函数的梯度幅度会比单模态大不少，我用 SGD 时出现过 loss 震荡。后来换了 AdamW，初始学习率设 1e-3，端到端训练了 300 个 epoch，收敛相对稳定。

4.3 数据增强与预处理

多模态最怕的不是增强不够，而是两个模态的增强动作不一致。比如你对 RGB 做了随机裁剪和翻转，红外图必须做一模一样的空间变换，否则像素对不齐，模型学起来会非常痛苦。我当时在训练代码里把两个模态打包成一个 dict，所有空间增强都在同一个变换对象上执行，这保证了两者空间上的强对齐。

颜色类增强要区别对待。RGB 图可以做随机色偏、饱和度调整之类，但红外图不要随便加颜色抖动，否则会把热辐射信息给污染掉。我最后只在两个模态共享的空间变换之外，对 RGB 加了独立的颜色扰动，对红外只做了随机亮度和对比度调整。

时序上我还做了一件事：随机对其中一个模态做“整体丢块”操作。也就是以一定概率把一个区域的 RGB 像素置零，但保留红外不变。这么做是为了模拟现实里某个模态局部失效的情况，让训练得到的融合策略更鲁棒。实测下来，加了这种 Mask 增强之后，模型在夜间遮挡场景下的 mAP 提升了接近 1 个点。

5. 实测效果：AP、速度、显存一个都不能少

我是先在一个自建的模拟多模态数据集上做了 A/B 测试，后来又换到一个公开可下载的多模态红外数据集（规模不大，但包含夜间场景）上跑了一遍。因为具体数字和数据集我不方便写得过于详细，我只能给出相对变化幅度，这会比绝对值更有参考意义。

5.1 实验配置与结果对比

实验配置大致如下：

• 输入分辨率：640×640
• Backbone：YOLOv11 默认结构，双分支不共享权重
• 优化器：AdamW，初始学习率 1e-3
• Batch size：16
• 训练轮数：300 epoch
• 硬件：单张消费级显卡，显存约 12G

在模拟多模态数据集上（可见光 + 红外），对比基线是“RGB 单模态 YOLOv11”和“红外单模态 YOLOv11”，我统计了几个关键指标：

从结果看，MM_LSK 比简单的 concat 融合在 mAP50 上多了 4.4 个点，在更严格的 mAP50-95 上多了 3.4 个点。代价是推理耗时多了 1.3ms，显存多了 0.7G 左右。对我来说这个代价可以接受，毕竟多模态场景本来就需要更大的算力开销。

5.2 可视化与消融结论

我把融合前后的特征图做了可视化。最明显的差异出现在夜间行人这类目标上：RGB 分支的特征图基本是一团黑，红外分支的特征图有亮斑但很粗糙；经过 MM_LSK 之后，融合特征图既保留了红外的目标位置信息，又恢复了一部分 RGB 低层补全的边缘细节。这种互补现象在早期融合方式里很难看到，早期融合通常会让特征图变成“RGB 亮的地方有边缘，暗的地方一坨糊”。

消融实验方面，我分别去掉了跨模态交互分支、大核选择分支、残差直连通道，观察性能变化：

• 去掉跨模态交互，只保留大核选择，相当于把两个模态简单相加再选核，mAP50 掉了 2.1 个点。可见“差异和乘积”信息对路由权重的生成是有实打实帮助的。

• 去掉大核选择，只保留跨模态交互和固定 3x3 融合卷积，mAP50 掉了 1.8 个点。说明多尺度感受野选择在融合任务里确实不可替代。

• 去掉残差直连，训练 loss 波动变大，最终 mAP50 掉了 1.0 个点左右，而且收敛变慢。建议保留直连，不要为了省一点计算量去掉。

6. 实战中常见的坑与排查思路

再好的模块设计，落到实际训练里都会遇到一堆幺蛾子。我把训练和调参过程中遇到的几个典型问题整理一下，如果你也打算在 YOLOv11 上做类似的自定义融合模块，能少走不少弯路。

6.1 梯度不稳，loss 直接起飞

我第一次端到端训练时，前 10 个 epoch 的 loss 一直在跳，完全没有下降趋势。一开始我以为是学习率太大，把学习率从 1e-3 降到 1e-4，问题依旧。后来排查到根源是 MM_LSK 里的跨模态分支没有加 BatchNorm，而两个模态的特征尺度差异很大，有的批次里红外特征数值特别大，乘以 RGB 的响应之后直接放大了梯度。我在 interact 和 fuse_conv 内部补了 BatchNorm，并在第一个 epoch 用较小的学习率做 warmup，之后 loss 就稳稳往下降了。

这个问题的排查思路其实很简单：哪个分支先出 NaN 或者显著放大，就先用 BN 或者 LayerNorm 把它压住。千万不要小看低层特征之间尺度差异带来的间接影响。

6.2 融合后小目标反而变差

这是一个让我头疼很久的问题。融合前单模态模型在小目标上的表现虽然不是最好，但至少不差；加了 MM_LSK 之后整体精度上升，小目标却往下掉。后来我发现问题出在 P3 层。P3 是最高分辨率、主要管小目标的那一级，但我在 P3 上放的 MM_LSK 也用了比较大的大核分支，这会把小目标周围的上下文混进来，反而把小目标的独有特征给“稀释”了。

解决方法是给不同层级配置不同的大核尺寸：P3 层只用 3x3 和 5x5，P4 层用 3x3、5x5、7x7，P5 层才用完整的大核组合。这样既能保留小目标的局部细节，又能在高层做大范围上下文感知。调整之后小目标的 mAP 回升了 1.5 个点左右。

6.3 两个模态之间的时间或空间错位

多模态融合模型在实时推理时最怕的问题还不是网络性能，而是输入数据的对齐。如果红外相机和可见光相机安装位置有偏差、帧率不同步，训练时用完美对齐的数据，推理时遇到的却是错位数据，模型效果会大打折扣。我踩过的一个具体坑是：采集数据时 RGB 和红外帧时间戳没精确同步，导致高速运动的车辆在两个模态里位置差了十几个像素，训练出来的融合特征又“自信地”融合了两种错位信息，最终检测框精度下降严重。

后来我在数据预处理阶段加了一个校检流程：对两个模态先做图像配准，并在训练时随机对其中一个模态做 2~3 像素的平移和比例缩放，模拟轻微的错位。这个数据增强虽然看起来在“制造噪声”，但反而让模型对错位的鲁棒性提升了。

6.4 显存不足的取舍

双分支 Backbone 加额外模块，显存翻倍是必然的。我只有单张 12G 显存卡，训练 640×640 分辨率、Batch size 16 很勉强。我的解决办法是减少两个 Backbone 的通道数，比如把默认通道数 ×0.75，换来显存节省和速度提升。实测证明，在数据量不是特别大的情况下，通道数稍微缩窄不会对最终精度造成太大影响。

如果想在推理时进一步省显存，可以做一个“共享 Backbone 权重 + 模态特定适配层”的方案。训练阶段各自独立，推理时让两个模态共用前几层卷积，在中间插入小的模态适配模块。这个方案可以省差不多 30% 的显存，但精度会比完全独立的双分支低一点。

7. 关于后续改进的一些个人想法

MM_LSK 目前在我手里已经经历过好几个版本的迭代，从最早把两个模态简单相加，到后来做差异乘积交互，再到大核选择，每一步都踩了不少坑。现阶段我觉得最有价值的延伸方向有两个。一个是在注意力路由中加入通道维度的选择，目前我的路由只在空间维度上分配权重，但不同通道关注的语义特征差别很大，通道级路由理论上能带来更大的提升。另一个方向是和轻量注意力结构结合，把大核分支换成可变形卷积或者稀疏注意力，在保持感受野适应性的同时进一步压缩推理时间。

我自己在实际复现和调优过程中最大的体会是：多模态融合的难点不在于“有多先进的融合算子”，而在于你要非常清楚每个模态在什么时候是可信的、在什么时候反而是噪声。MM_LSK 本质上就是让网络自己学出这个“可信度地图”，并用大核选择来匹配不同空间位置所需的上下文范围。如果你也想基于 YOLOv11 做类似的多模态融合改进，不要一上来就追求复杂模块，先把两个模态的预处理、对齐、增强这些基本功做扎实，再考虑融合结构的设计，效果会稳得多。