Mamba跨模态融合RGB-D SOD：MambaSOD（重庆大学）双流VMamba+CMM跨模态Mamba+精炼解码，六基准SOTA！！！

🔥 本文定位：CSDN 原创干货 | 重庆大学 & 香港大学 RGB-D 显著性检测 SOTA 方案

🎯 核心收益：一次性解决CNN局部感受野受限+Transformer二次计算爆炸+跨模态融合不足三大痛点！基于双流VMamba骨干打造CMM跨模态融合Mamba模块，搭配多级精炼解码器，STERE上F_max达0.920，超Swin-T baseline 2.2%，仅16.9G FLOPs线性复杂度，完美适配自动驾驶感知、移动端部署、视频监控、遥感分析等场景

📌 核心创新矩阵：

✅ 适配场景：自动驾驶深度感知 / 移动端显著性检测 / 视频监控前景分割 / 遥感图像目标提取 / 手机摄影虚化 / 工业缺陷检测

🔖 前言

  针对上述问题，重庆大学与香港大学团队提出MambaSOD——首个将Mamba State Space Model引入RGB-D SOD的工作。核心思路极简而优雅：用双流VMamba（Visual Mamba）骨干分别提取RGB和Depth的层次化特征，线性复杂度建模全局依赖；在每一级特征上插入CMM（Cross-Modal Fusion Mamba）模块，通过自模态Mamba增强+跨模态门控交互实现特征深度融合；最后用多级精炼解码器逐层聚合多尺度RGB-D特征，输出高精度显著性图。

  本文全程论文 1:1 对齐 + 可运行完整代码复现 + 实验全解读，CSDN 最细最干货版本，直接拿去发论文、改毕设、打比赛、做工程都能暴力涨点！

一、MambaSOD 整体架构

▲ 图1：MambaSOD 整体架构。包含三部分：Mamba-based Encoder（双流VMamba）、Cross-Modal Fusion Mamba（CMM）、Multi-level Refinement Decoder（MR）。来源：论文 Fig.2。

  MambaSOD 整体采用编码器-融合器-解码器三段式设计，数据流如下：

核心设计亮点：全部三个模块（编码器、融合器、解码器）均基于State Space Model范式，整个网络保持线性复杂度$O(N)$，无任何二次复杂度的自注意力操作——这是MambaSOD区别于所有Transformer-based RGB-D SOD方法的关键优势。

二、核心模块逐行拆解

2.1 Visual Mamba（VM）Block

▲ 图2：Visual Mamba Block 结构。包含LN→线性投影→深度可分离卷积→SiLU→SS2D四方向扫描→残差连接→FFN。来源：论文 Fig.2右侧。

• 解决线性复杂度全局建模：SS2D（2D-Selective-Scan）将2D图像按四个方向展开为1D序列，经SSM处理再合并，实现全局感受野的同时仅需$O(N)$计算
• 解决2D非序列数据适配：通过Patch Partition将图像打成patch序列，四方向扫描保留空间结构信息
• 解决梯度消失：每个VM Block内部两条残差路径（公式7的$z' + z$和公式8的$y + z'$），确保梯度顺畅传播
• 解决局部细节保留：深度可分离卷积（DWConv）在SS2D之前引入局部归纳偏置，弥补纯SSM的局部建模不足

  VM Block的计算分为两步。第一步，给定输入序列$z$：

$$z^{\prime }=\text{SiLU}(\text{DWConv}(\text{Linear}(\text{LN}(z))))$$

$$z^{\prime \prime }=\text{Linear}(\text{LN}(\text{SS2D}(z^{\prime })))\text{\hspace{1em}(7)}$$

$$z=z^{\prime \prime }+z$$

  第二步，经过FFN进一步变换：

$$z=\text{FFN}(\text{Linear}(\text{LN}(z)))\text{\hspace{1em}(8)}$$

$$y=z+z^{\prime }$$

  其中SS2D是核心创新——将2D图像按左上->右下、右上->左下、右下->左上、左下->右上四个方向分别展开，每个方向独立通过SSM处理，最后合并重建为2D特征图。这种多方向扫描确保每个位置都能感知全图上下文。

公式详解：SSM离散化

  连续SSM定义为线性ODE：

$$h^{\prime }(t)=Ah(t-1)+Bx(t),y(t)=Ch(t)\text{\hspace{1em}(1)}$$

  通过Zero-Order Hold（ZOH）离散化：

$$\bar{A}=\exp (\Delta A),\bar{B}=(\Delta A{)}^{-1}(\exp (\Delta A)-I)\cdot \Delta B\text{\hspace{1em}(2)}$$

  离散后递归形式：

$$h_t=\bar{A}{h}_{t-1}+\bar{B}{x}_t,y_t=C{h}_t\text{\hspace{1em}(3)}$$

  进一步转化为卷积形式实现并行训练：

$$\bar{K}=(C\bar{B},C\bar{A}\bar{B},\dots ,C{\bar{A}}^{L-1}\bar{B}),y=x\ast \bar{K}\text{\hspace{1em}(4)}$$

2.2 Cross-Modal Fusion Mamba（CMM）

▲ 图3：CMM跨模态融合Mamba模块。包含Self-modal Enhancement和Inter-modal Correlation Modeling两条路径。来源：论文 Fig.4。

• 解决自模态特征增强不足：RGB和Depth分别通过独立Mamba Block提取长程依赖，使各自特征更鲁棒
• 解决跨模态交互缺失：将RGB和Depth特征Cat后通过共享Mamba建模模态间相关性，用门控机制选择性融合
• 解决互补信息利用不充分：用相关性特征$g$对增强后的自模态特征做逐元素门控（公式12），抑制冗余、增强互补
• 解决2D特征重建：融合后经reshape+dwConv+残差操作恢复2D空间结构（公式13）

  CMM模块是MambaSOD的核心创新，结构上分为两条并行路径：

路径1：自模态增强（Self-modal Enhancement）

  对RGB特征$F_i^{rgb}$和Depth特征$F_i^d$分别做LN→MLP→Conv1d→SSM处理：

$$y_r=\text{SSM}(\text{Conv1}(\text{MLP}(\text{LN}(F_i^{rgb}))))\text{\hspace{1em}(9)}$$

$$y_d=\text{SSM}(\text{Conv1}(\text{MLP}(\text{LN}(F_i^d))))\text{\hspace{1em}(10)}$$

路径2：跨模态相关性建模（Inter-modal Correlation）

  将RGB和Depth特征拼接后通过Mamba Block，学习通道间的交互模式：

$$g=\text{SSM}(\text{Conv1}(\text{MLP}(\text{LN}(\text{Cat}(F_i^{rgb},F_i^d)))))\text{\hspace{1em}(11)}$$

门控融合

  用跨模态相关性$g$对增强后的特征做门控：

$$y_r^{\prime }=y_r\odot g,y_d^{\prime }=y_d\odot g\text{\hspace{1em}(12)}$$

  最终融合重建为2D RGB-D特征：

$$F_i=\text{dwConv}(\text{Reshape}(\text{MLP}(y_r^{\prime }+y_d^{\prime })+F_i^{rgb}+F_i^d))\text{\hspace{1em}(13)}$$

2.3 Multi-level Refinement（MR）Decoder

• 解决多尺度特征聚合：深层的全局语义和浅层的边缘细节需要差异化融合策略
• 解决上采样中的信息损失：上采样后的特征先经$3\\times3$卷积降维+BN+GELU，减少混叠效应
• 解决特征不对齐：乘加混合（逐元素乘+加）提供两种互补的融合视角
• 解决梯度退化：每次融合保留shortcut残差连接，确保深层监督信号顺畅回传

  MR Decoder从最深层的$F_5$（$768\times 11\times 11$）开始，逐层向上精炼：

Step 1：上采样+卷积降维：
$$F_5^{\prime }=\text{Upsample}(F_5),F_5^{\prime }={\text{Conv}}_{3\times 3}(F_5^{\prime })+\text{BN}+\text{GELU}$$

Step 2：多模态融合（Cat + Mul + 残差）：
$$F_{cat}={\text{Conv}}_{3\times 3}(\text{Cat}(F_4,F_5^{\prime })),F_{mul}=F_4\odot F_5^{\prime }$$

Step 3：聚合输出：
$$F_{agg}=F_{cat}+F_{mul}+F_5^{\prime }$$

Step 4：1×1卷积预测显著性图：
$$P_i={\text{Conv}}_{1\times 1}(\text{GELU}(\text{BN}({\text{Conv}}_{3\times 3}(F_{agg}))))$$

三、论文 1:1 对齐完整可运行 PyTorch 复现代码

3.1 环境依赖

pip install torch torchvision einops timm opencv-python tensorboard
pip install mamba-ssm # 选择性扫描SSM核心
# 或从源码安装: pip install causal-conv1d>=1.2.0
git clone https://github.com/YueZhan721/MambaSOD
cd MambaSOD

3.2 完整 PyTorch 实现

MambaSOD 主模型

import torch
import torch.nn as nn
import torch.nn.functional as F
from einops import rearrange
import math

# ====== SS2D: 2D选择性扫描核心 ======
class SS2D(nn.Module):
"""2D-Selective-Scan: 四方向扫描→SSM→合并"""
def __init__(self, dim):
super().__init__()
self.dim = dim
# 🚀 bimamba_type="v3": 双向Mamba，两个方向分别编码
from mamba_ssm import Mamba
self.mamba = Mamba(dim, bimamba_type="v3")
self.norm = nn.LayerNorm(dim)

def forward(self, x):
# x: (B, H, W, C)
B, H, W, C = x.shape
# 四方向扫描展开
seqs = []
# 方向1: 左上→右下 (行优先)
seqs.append(x.view(B, H*W, C))
# 方向2: 右上→左下
x_flip_lr = torch.flip(x, dims=[2])
seqs.append(x_flip_lr.view(B, H*W, C))
# 方向3: 右下→左上
x_flip_ud = torch.flip(x, dims=[1])
seqs.append(x_flip_ud.view(B, H*W, C))
# 方向4: 左下→右上
x_flip_both = torch.flip(x, dims=[1, 2])
seqs.append(x_flip_both.view(B, H*W, C))

# 各方向独立过SSM 🚀 线性复杂度O(N)
out_seqs = []
for seq in seqs:
out = self.mamba(self.norm(seq))
out_seqs.append(out)

# 合并回2D
out = sum(out_seqs) / 4 # 平均合并
out = out.view(B, H, W, C)
return out

# ====== Visual Mamba Block ======
class VisualMambaBlock(nn.Module):
"""VM Block: LN→Linear→DWConv→SiLU→SS2D→残差→FFN"""
def __init__(self, dim):
super().__init__()
self.norm1 = nn.LayerNorm(dim)
self.linear1 = nn.Linear(dim, dim)
self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, groups=dim)
self.silu = nn.SiLU()
self.ss2d = SS2D(dim)
self.norm2 = nn.LayerNorm(dim)
self.ffn = nn.Sequential(
nn.Linear(dim, dim * 4),
nn.GELU(),
nn.Linear(dim * 4, dim),
)

def forward(self, x):
# x: (B, C, H, W)
B, C, H, W = x.shape
# Part 1: SS2D路径
shortcut = x
x = x.permute(0, 2, 3, 1) # → (B, H, W, C)
x = self.norm1(x)
x = self.linear1(x)
x = x.permute(0, 3, 1, 2) # → (B, C, H, W)
x = self.dwconv(x)
x = self.silu(x)
x = x.permute(0, 2, 3, 1) # → (B, H, W, C)
x = self.ss2d(x) # SS2D全局扫描
x = x.permute(0, 3, 1, 2) # → (B, C, H, W)
x = x + shortcut # 残差1

# Part 2: FFN路径
shortcut2 = x
x = x.permute(0, 2, 3, 1)
x = self.norm2(x)
x = self.ffn(x)
x = x.permute(0, 3, 1, 2)
x = x + shortcut2 # 残差2
return x

# ====== Cross-Modal Fusion Mamba ======
class CrossMamba(nn.Module):
"""CMM: 自模态Mamba增强 + 跨模态门控融合"""
def __init__(self, dim):
super().__init__()
# 🚀 自模态增强使用独立Mamba
from mamba_ssm import Mamba
self.mamba_rgb = Mamba(dim, bimamba_type="v3")
self.mamba_depth = Mamba(dim, bimamba_type="v3")
# 🚀 跨模态相关性使用共享Mamba处理Cat特征
self.mamba_cross = Mamba(dim * 2, bimamba_type="v3")

self.norm1 = nn.LayerNorm(dim)
self.norm2 = nn.LayerNorm(dim)
self.norm_cat = nn.LayerNorm(dim * 2)
self.mlp = nn.Linear(dim, dim)
self.conv1d = nn.Conv1d(dim, dim, 1)
self.reduce = nn.Conv2d(dim * 2, dim, 1)
self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, groups=dim)

def forward(self, rgb_feat, depth_feat):
# rgb_feat, depth_feat: (B, C, H, W)
B, C, H, W = rgb_feat.shape

# 展平为序列
rgb_seq = rgb_feat.flatten(2).permute(0, 2, 1) # (B, HW, C)
depth_seq = depth_feat.flatten(2).permute(0, 2, 1)

# 路径1: 自模态增强
yr = self.mamba_rgb(self.norm1(rgb_seq))
yd = self.mamba_depth(self.norm2(depth_seq))

# 路径2: 跨模态相关性
cat_seq = torch.cat([rgb_seq, depth_seq], dim=–1) # (B, HW, 2C)
g = self.mamba_cross(self.norm_cat(cat_seq)) # (B, HW, 2C)
g = g[:, :, :C] # 取前C维作为门控

# 门控融合
yr_gated = yr * torch.sigmoid(g) # 🚀 sigmoid门控
yd_gated = yd * torch.sigmoid(g)

# 重建2D特征
fused = yr_gated + yd_gated
fused = fused.permute(0, 2, 1).view(B, C, H, W)
fused = self.dwconv(fused) + rgb_feat + depth_feat # 残差

return fused

# ====== 多级精炼解码器 ======
class MultiLevelRefinement(nn.Module):
"""MR Decoder: 上采样→Cat+Mul→残差→预测"""
def __init__(self, in_ch, out_ch):
super().__init__()
self.upsample = nn.Upsample(scale_factor=2, mode="bilinear")
self.conv_reduce = nn.Sequential(
nn.Conv2d(in_ch, out_ch, 3, 1, 1),
nn.BatchNorm2d(out_ch),
nn.GELU(),
)
self.conv_fuse = nn.Sequential(
nn.Conv2d(out_ch * 2, out_ch, 3, 1, 1),
nn.BatchNorm2d(out_ch),
nn.GELU(),
)
self.pred_head = nn.Sequential(
nn.Conv2d(out_ch, out_ch, 3, 1, 1),
nn.BatchNorm2d(out_ch),
nn.GELU(),
nn.Conv2d(out_ch, 1, 1),
)

def forward(self, curr_feat, next_feat):
# 上采样深层特征
next_up = self.upsample(next_feat)
next_rc = self.conv_reduce(next_up)
shortcut = next_rc

# Cat融合 + Mul融合
cat_fuse = torch.cat([curr_feat, next_rc], dim=1)
cat_fuse = self.conv_fuse(cat_fuse)
mul_fuse = curr_feat * next_rc

# 聚合
out = cat_fuse + mul_fuse + shortcut
pred = F.interpolate(self.pred_head(out),
size=352, mode="bilinear")
return pred, out

# ====== MambaSOD完整模型 ======
class MambaSOD(nn.Module):
"""双流VMamba + CMM + MR解码器"""
def __init__(self, channels=[96, 192, 384, 768]):
super().__init__()
# Encoder: 4级VMamba特征提取
self.enc_rgb = nn.ModuleList([
nn.Sequential(*[VisualMambaBlock(c) for _ in range(2)])
for c in channels
])
self.enc_depth = nn.ModuleList([
nn.Sequential(*[VisualMambaBlock(c) for _ in range(2)])
for c in channels
])

# Patch Embedding (下采样)
self.downsamples = nn.ModuleList([
nn.Conv2d(channels[i], channels[i+1], 3, 2, 1)
for i in range(len(channels)–1)
])
self.patch_embed = nn.Conv2d(3, channels[0], 3, 1, 1)

# CMM跨模态融合 (4级)
self.cmm = nn.ModuleList([
CrossMamba(c) for c in channels
])

# MR解码器 (4级)
self.mr = nn.ModuleList([
MultiLevelRefinement(channels[i], channels[i–1] if i > 0 else channels[0])
for i in range(len(channels)–1, 0, –1)
])
self.mr_first = nn.Sequential(
nn.Conv2d(channels[–1], 1, 1),
)
self.train_size = 352

def forward(self, rgb, depth):
# Depth重复3通道
depth = depth.repeat(1, 3, 1, 1)

# 多级特征提取
rgb_feats, depth_feats = [], []
x_rgb, x_d = self.patch_embed(rgb), self.patch_embed(depth)
for i in range(len(self.enc_rgb)):
x_rgb = self.enc_rgb[i](x_rgb)
x_d = self.enc_depth[i](x_d)
rgb_feats.append(x_rgb)
depth_feats.append(x_d)
if i < len(self.enc_rgb) – 1:
x_rgb = self.downsamples[i](x_rgb)
x_d = self.downsamples[i](x_d)

# CMM融合
fused_feats = []
for i, cmm in enumerate(self.cmm):
fused_feats.append(cmm(rgb_feats[i], depth_feats[i]))

# MR解码
preds = []
x = fused_feats[–1]
pred_deep = F.interpolate(
self.mr_first(x), self.train_size, mode="bilinear")
preds.append(pred_deep)

cur_feat = x
for i, mr in enumerate(self.mr):
idx = len(fused_feats) – 2 – i # 从倒数第二级开始
pred, cur_feat = mr(fused_feats[idx], cur_feat)
preds.append(F.interpolate(pred, self.train_size, mode="bilinear"))

return preds # 5级多尺度预测

# ====== 测试模型 ======
if __name__ == "__main__":
model = MambaSOD()
rgb = torch.randn(2, 3, 352, 352)
depth = torch.randn(2, 1, 352, 352)
preds = model(rgb, depth)
for i, p in enumerate(preds):
print(f"Pred_{i}: {p.shape}")
total_params = sum(p.numel() for p in model.parameters())
print(f"Total params: {total_params / 1e6:.2f}M")

四、YOLO 一键迁移适配教程（即插即用，直接训练）

Step 1：放入模块

将 CrossMamba 类复制到 ultralytics/nn/modules/ 目录下，新建 CMMamba.py：

# ultralytics/nn/modules/CMMamba.py
import torch
import torch.nn as nn
from mamba_ssm import Mamba

class CrossMamba(nn.Module):
"""MambaSOD跨模态融合模块 — 即插即用YOLO版"""
def __init__(self, dim=128):
super().__init__()
self.mamba = Mamba(dim, bimamba_type="v3")
self.norm1 = nn.LayerNorm(dim)
self.norm2 = nn.LayerNorm(dim)
self.reduce = nn.Conv2d(dim*2, dim, 1)
self.dwconv = nn.Conv2d(dim, dim, 3, 1, 1, groups=dim)

def forward(self, rgb_feat, depth_feat):
B, C, H, W = rgb_feat.shape
# 序列化
rgb_s = rgb_feat.flatten(2).permute(0,2,1)
depth_s = depth_feat.flatten(2).permute(0,2,1)
cat_s = torch.cat([rgb_s, depth_s], dim=–1)
cat_s = self.reduce(cat_s.permute(0,2,1).view(B, C*2, H, W)).flatten(2).permute(0,2,1)

yr = self.mamba(self.norm1(rgb_s))
yd = self.mamba(self.norm2(depth_s))
g = torch.sigmoid(cat_s[:, :, :C])

fused = yr * g + yd * g
fused = fused.permute(0,2,1).view(B, C, H, W)
fused = self.dwconv(fused) + rgb_feat + depth_feat
return fused

Step 2：注册 __init__.py

# ultralytics/nn/modules/__init__.py
from .CMMamba import CrossMamba # 🚀 添加这一行

Step 3：注册 parse_model

# ultralytics/nn/tasks.py — parse_model函数内
# 在 elif m in (nn.BatchNorm2d, …) 附近添加:
elif m is CrossMamba:
# 🚀 CMM跨模态Mamba融合模块
# args: [c1, c2, dim] — c1实际不使用，c2=dim
c2 = args[0] # dim
args = [c2]

五、实验结果全解析

5.1 SOTA 对比实验

✅ 核心亮点：

• 在 STERE 上 $F_{\beta }$ 高达 0.920，超最强竞品PICR-Net（0.910）达1%，MAE低至0.031
• 在 NLPR 上 $F_{\beta }$ 达 0.934，MAE仅0.017，显著优于所有方法
• 在 NJU2K 上 $F_{\beta }$ 0.937，超第二名PICR-Net（0.923）达1.4%
• 五个数据集排名第一，仅DES数据集排名第四（差前三0.2-0.3%）

5.2 骨干网络消融实验

✅ 核心亮点：

• VMamba骨干在所有指标上碾压ResNet50和Swin-t，$F_{\beta }$ 超ResNet50达2.2%
• 在质量较低的SIP和STERE数据集上优势更明显，证明Mamba对噪声depth的鲁棒性更强

5.3 CMM融合模块消融实验

✅ 核心亮点：

• 仅添加CMM（去掉跨模态分支）就使$F_{\beta }$从0.939提升到0.943，验证自模态Mamba增强的有效性
• 完整的CMM+跨模态门控进一步将$F_{\beta }$推至0.947，说明跨模态交互是性能提升的关键

六、总结

  学术研究和工程落地都能直接用。

🔖 收藏本文，RGB-D SOD 直接起飞！
📌 标签：#RGB-D SOD #Mamba #跨模态融合 #VMamba #显著性检测