YOLO12-Mamba：融合MambaVision思想的目标检测创新实践

一、引言

YOLO12 是 Ultralytics 推出的最新目标检测模型，在精度和效率方面都有进一步提升。然而，传统 CNN 架构在捕获长距离空间依赖关系方面仍存在固有的局限性。

Mamba（State Space Model，状态空间模型） 的出现为解决这一问题提供了新的思路。本文将详细介绍如何将 MambaVision 的核心思想融入 YOLO12，构建一个混合 CNN-Mamba 架构------YOLO12-Mamba。

---

二、核心原理详解

2.1 Mamba 选择性扫描机制

Mamba 的核心创新在于**选择性扫描（Selective Scan）**操作：

x(t) = exp(Δ(t) * A) * x(t-1) + Δ(t) * B * u(t)
y(t) = C * x(t) + D * u(t)

关键改进：

1. 动态选择因子 Δ(t)：根据输入自适应调整状态更新的权重
2. 结构化矩阵 A：对角化或低秩分解，实现高效计算
3. 门控机制：类似 Transformer 的门控，增强模型表达能力

2.2 YOLO12 架构分析

YOLO12 具有以下特点：

组件	描述	作用
C2f	CSP Bottleneck 2.0	高效局部特征提取
C2PSA	C2f with PSA attention	注意力增强特征融合
SPPF	Spatial Pyramid Pooling - Fast	多尺度特征融合

---

三、YOLO12-Mamba 实现方案

3.1 项目结构

Mamba-Yolo12/
├── ultralytics/                    # Ultralytics YOLO12 核心代码
│   └── ultralytics/
│       ├── cfg/models/12/
│       │   └── yolo12-mamba.yaml  # YOLO12-Mamba 配置文件
│       ├── nn/
│       │   ├── modules/
│       │   │   ├── __init__.py     # 模块导出
│       │   │   └── mamba.py        # Mamba 核心模块
│       │   └── tasks.py            # 模型构建入口
│       └── __init__.py
├── test_mamba_yolo12.py            # 模块测试脚本
└── train_test.py                   # 训练测试脚本

3.2 核心模块实现

3.2.1 MambaVisionMixer

import math
import torch
import torch.nn as nn
import torch.nn.functional as F

def rearrange(x, pattern, **kwargs):
    if pattern == "b l d -> b d l":
        return x.permute(0, 2, 1)
    elif pattern == "b d l -> b l d":
        return x.permute(0, 2, 1)
    elif pattern == "b d l -> (b l) d":
        B, D, L = x.shape
        return x.contiguous().view(B * L, D)
    elif pattern == "(b l) d -> b d l":
        b_l, d = x.shape
        l = kwargs.get('l', 1)
        b = b_l // l
        return x.view(b, l, d).permute(0, 2, 1).contiguous()
    elif pattern == "d -> d 1":
        return x.unsqueeze(-1)
    else:
        raise NotImplementedError(f"Unsupported pattern: {pattern}")

def repeat(x, pattern, **kwargs):
    if pattern == "n -> d n":
        d = kwargs.get('d', 1)
        return x.unsqueeze(0).repeat(d, 1)
    else:
        raise NotImplementedError(f"Unsupported pattern: {pattern}")

def selective_scan_fn(u, delta, A, B, C, D=None, z=None, delta_bias=None, delta_softplus=False):
    dtype_in = u.dtype
    u = u.float()
    delta = delta.float()
    
    if delta_bias is not None:
        delta = delta + delta_bias[..., None].float()
    if delta_softplus:
        delta = F.softplus(delta)
    
    batch, dim, dstate = u.shape[0], A.shape[0], A.shape[1]
    
    deltaA = torch.exp(torch.einsum('bdl,dn->bdln', delta, A))
    deltaB_u = torch.einsum('bdl,bnl,bdl->bdln', delta, B, u)
    
    x = A.new_zeros((batch, dim, dstate))
    ys = []
    for i in range(u.shape[2]):
        x = deltaA[:, :, i] * x + deltaB_u[:, :, i]
        y = torch.einsum('bdn,bn->bd', x, C[:, :, i])
        ys.append(y)
    
    y = torch.stack(ys, dim=2)
    out = y if D is None else y + u * rearrange(D, "d -> d 1")
    
    if z is not None:
        out = out * F.silu(z)
    
    return out.to(dtype=dtype_in)

class MambaVisionMixer(nn.Module):
    def __init__(
        self,
        d_model,
        d_state=16,
        d_conv=4,
        expand=2,
        dt_rank="auto",
        dt_min=0.001,
        dt_max=0.1,
        dt_init="random",
        dt_scale=1.0,
        dt_init_floor=1e-4,
        conv_bias=True,
        bias=False,
        **kwargs
    ):
        super().__init__()
        self.d_model = d_model
        self.d_state = d_state
        self.d_conv = d_conv
        self.expand = expand
        self.d_inner = int(self.expand * self.d_model)
        self.dt_rank = dt_rank if dt_rank != "auto" else int(math.ceil(self.d_model / 16))
        
        self.in_proj = nn.Linear(self.d_model, self.d_inner, bias=bias)
        
        self.conv1d_x = nn.Conv1d(
            in_channels=self.d_inner // 2,
            out_channels=self.d_inner // 2,
            kernel_size=d_conv,
            padding='same',
            groups=self.d_inner // 2,
            bias=conv_bias
        )
        self.conv1d_z = nn.Conv1d(
            in_channels=self.d_inner // 2,
            out_channels=self.d_inner // 2,
            kernel_size=d_conv,
            padding='same',
            groups=self.d_inner // 2,
            bias=conv_bias
        )
        
        self.x_proj = nn.Linear(self.d_inner // 2, self.dt_rank + 2 * self.d_state, bias=False)
        self.dt_proj = nn.Linear(self.dt_rank, self.d_inner // 2, bias=True)
        
        A = repeat(
            torch.arange(1, self.d_state + 1, dtype=torch.float32),
            "n -> d n",
            d=self.d_inner // 2
        ).contiguous()
        self.A_log = nn.Parameter(torch.log(A))
        self.A_log._no_weight_decay = True
        
        self.D = nn.Parameter(torch.ones(self.d_inner // 2))
        self.D._no_weight_decay = True
        
        self.out_proj = nn.Linear(self.d_inner, self.d_model, bias=bias)
        
        self.dt_scale = dt_scale
        self.dt_min = dt_min
        self.dt_max = dt_max
        self.dt_init = dt_init
        self.dt_init_floor = dt_init_floor
        
        self._init_weights()
    
    def _init_weights(self):
        dt = torch.exp(
            torch.rand(self.d_inner // 2) * (math.log(self.dt_max) - math.log(self.dt_min))
            + math.log(self.dt_min)
        ).clamp(min=self.dt_init_floor)
        inv_dt = dt + torch.log(-torch.expm1(-dt))
        self.dt_proj.bias.data.copy_(inv_dt)
    
    def forward(self, hidden_states):
        B, L, D = hidden_states.shape
        
        xz = self.in_proj(hidden_states)
        xz = rearrange(xz, "b l d -> b d l")
        x, z = xz.chunk(2, dim=1)
        
        x = F.silu(self.conv1d_x(x))
        z = F.silu(self.conv1d_z(z))
        
        x_flat = rearrange(x, "b d l -> (b l) d")
        x_dbl = self.x_proj(x_flat)
        
        dt, B_proj, C_proj = torch.split(
            x_dbl,
            [self.dt_rank, self.d_state, self.d_state],
            dim=-1
        )
        
        dt = self.dt_proj(dt)
        dt = rearrange(dt, "(b l) d -> b d l", l=L)
        
        B_proj = rearrange(B_proj, "(b l) dstate -> b dstate l", l=L)
        C_proj = rearrange(C_proj, "(b l) dstate -> b dstate l", l=L)
        
        A = -torch.exp(self.A_log.float())
        
        y = selective_scan_fn(
            u=x, delta=dt, A=A, B=B_proj, C=C_proj, D=self.D, z=z
        )
        
        y = torch.cat([y, z], dim=1)
        y = rearrange(y, "b d l -> b l d")
        
        output = self.out_proj(y)
        
        return output

3.2.2 MambaBlock

class MambaBlock(nn.Module):
    def __init__(self, dim):
        super().__init__()
        self.dim = dim
        self.mixer = MambaVisionMixer(d_model=dim)
    
    def forward(self, x):
        B, C, H, W = x.shape
        
        seq = x.flatten(2).transpose(1, 2)
        seq_out = self.mixer(seq)
        out = seq_out.transpose(1, 2).view(B, C, H, W)
        
        return out

3.2.3 C2fMamba

from .conv import Conv
from .block import Bottleneck

class C2fMamba(nn.Module):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__()
        self.c = int(c2 * e)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)
        self.m = nn.ModuleList()
        
        for i in range(n):
            if i % 2 == 0:
                self.m.append(MambaBlock(self.c))
            else:
                self.m.append(Bottleneck(self.c, self.c, shortcut, g))
    
    def forward(self, x):
        x = self.cv1(x)
        x = list(x.chunk(2, 1))
        
        for m in self.m:
            x.append(m(x[-1]))
        
        x = torch.cat(x, 1)
        out = self.cv2(x)
        
        return out

3.3 模型配置文件

创建 ultralytics/ultralytics/cfg/models/12/yolo12-mamba.yaml：

# YOLO12-Mamba: Hybrid Mamba-CNN Object Detection Model

nc: 80

backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  
  # Stage 1: CNN-based
  - [-1, 3, C2f, [128, True]]
  
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  
  # Stage 2: CNN-based
  - [-1, 6, C2f, [256, True]]
  
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  
  # Stage 3: Hybrid (Mamba blocks)
  - [-1, 6, C2fMamba, [512]]   # 融合 MambaBlock
  
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  
  # Stage 4: Hybrid (Mamba blocks)
  - [-1, 3, C2fMamba, [1024]]  # 融合 MambaBlock
  
  # SPPF
  - [-1, 1, SPPF, [1024, 5]]  # 9

head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]]
  - [-1, 3, C2f, [512, True]]
  
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]]
  - [-1, 3, C2f, [256, True]]
  
  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]]
  - [-1, 3, C2f, [512, True]]
  
  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 11], 1, Concat, [1]]
  - [-1, 3, C2f, [1024, True]]
  
  - [[16, 14, 10], 1, Detect, [nc]]

3.4 模块注册与导出

修改 ultralytics/ultralytics/nn/tasks.py 和 ultralytics/ultralytics/nn/modules/__init__.py，添加 Mamba 模块。

---

四、完整复现步骤

4.1 环境准备

git clone https://github.com/your-repo/Mamba-Yolo12.git
cd Mamba-Yolo12
conda create -n mamba-yolo python=3.9 -y
conda activate mamba-yolo
pip install torch==1.13.0 torchvision==0.14.0
pip install -e ./ultralytics

4.2 模块测试

创建 test_mamba_yolo12.py：

import torch
import sys
sys.path.append('./ultralytics')

from ultralytics.nn.modules.mamba import MambaVisionMixer, MambaBlock, C2fMamba

def test_mamba_vision_mixer():
    mixer = MambaVisionMixer(d_model=128)
    x = torch.randn(1, 256, 128)
    y = mixer(x)
    assert y.shape == x.shape
    print("✓ MambaVisionMixer 测试通过")

def test_mamba_block():
    block = MambaBlock(dim=256)
    x = torch.randn(1, 256, 16, 16)
    y = block(x)
    assert y.shape == x.shape
    print("✓ MambaBlock 测试通过")

def test_c2f_mamba():
    c2f_mamba = C2fMamba(256, 256, n=2)
    x = torch.randn(1, 256, 16, 16)
    y = c2f_mamba(x)
    assert y.shape == x.shape
    print("✓ C2fMamba 测试通过")

def test_model_load():
    from ultralytics import YOLO
    model = YOLO('ultralytics/ultralytics/cfg/models/12/yolo12-mamba.yaml')
    model.info()
    print("✓ 模型加载测试通过")

if __name__ == '__main__':
    print("=== Mamba-YOLO12 模块测试 ===")
    test_mamba_vision_mixer()
    test_mamba_block()
    test_c2f_mamba()
    test_model_load()
    print("\n=== 所有测试通过！ ===")

4.3 训练测试

创建 train_test.py：

import sys
sys.path.append('./ultralytics')
from ultralytics import YOLO

def train_mamba_yolo():
    model = YOLO('ultralytics/ultralytics/cfg/models/12/yolo12-mamba.yaml')
    print("\n=== 模型信息 ===")
    model.info()
    
    print("\n=== 开始训练 ===")
    results = model.train(
        data='coco128.yaml',
        epochs=1,
        batch=8,
        imgsz=640,
        device='cpu',
        workers=0,
        verbose=True,
        name='train-test',
        exist_ok=True
    )
    
    print("\n=== 训练完成 ===")

if __name__ == '__main__':
    train_mamba_yolo()

---

七、完整代码清单

7.1 项目结构

Mamba-Yolo12/
├── ultralytics/                    # Ultralytics YOLO12 核心代码
│   └── ultralytics/
│       ├── cfg/models/12/
│       │   └── yolo12-mamba.yaml   # YOLO12-Mamba 配置文件
│       ├── nn/
│       │   ├── modules/
│       │   │   ├── __init__.py     # 模块导出
│       │   │   └── mamba.py        # Mamba 核心模块
│       │   └── tasks.py            # 模型构建入口（需修改）
│       └── __init__.py
├── test_mamba_yolo12.py            # 模块测试脚本
├── train_test.py                   # 训练测试脚本
└── README.md                       # 项目说明

7.2 ultralytics/ultralytics/nn/modules/__init__.py

# 在文件末尾添加 Mamba 模块导入
from .mamba import C2fMamba, MambaBlock, MambaVisionMixer

# 在 __all__ 列表中添加
__all__ = (
    # ... 其他模块 ...
    "C2fMamba",
    "MambaBlock", 
    "MambaVisionMixer",
    # ... 其他模块 ...
)

7.3 ultralytics/ultralytics/nn/modules/mamba.py

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

# 实现简化版的 einops 函数
def rearrange(x, pattern, **kwargs):
    if pattern == "b l d -> b d l":
        return x.permute(0, 2, 1)
    elif pattern == "b d l -> b l d":
        return x.permute(0, 2, 1)
    elif pattern == "b d l -> (b l) d":
        B, D, L = x.shape
        return x.contiguous().view(B * L, D)
    elif pattern == "(b l) d -> b d l":
        b_l, d = x.shape
        l = kwargs.get('l', 1)
        b = b_l // l
        return x.view(b, l, d).permute(0, 2, 1).contiguous()
    elif pattern == "(b l) dstate -> b dstate l":
        b_l, dstate = x.shape
        l = kwargs.get('l', 1)
        b = b_l // l
        return x.view(b, l, dstate).permute(0, 2, 1).contiguous()
    elif pattern == "d -> d 1":
        return x.unsqueeze(-1)
    else:
        raise NotImplementedError(f"Unsupported pattern: {pattern}")

def repeat(x, pattern, **kwargs):
    if pattern == "n -> d n":
        d = kwargs.get('d', 1)
        return x.unsqueeze(0).repeat(d, 1)
    else:
        raise NotImplementedError(f"Unsupported pattern: {pattern}")

# 选择性扫描实现
def selective_scan_fn(
    u, delta, A, B, C, D=None, z=None, delta_bias=None, delta_softplus=False
):
    dtype_in = u.dtype
    u = u.float()
    delta = delta.float()
    if delta_bias is not None:
        delta = delta + delta_bias[..., None].float()
    if delta_softplus:
        delta = F.softplus(delta)
    
    batch, dim, dstate = u.shape[0], A.shape[0], A.shape[1]
    is_variable_B = B.dim() >= 3
    is_variable_C = C.dim() >= 3
    
    if A.is_complex():
        if is_variable_B:
            B = torch.view_as_complex(rearrange(B.float(), "... (L two) -> ... L two", two=2))
        if is_variable_C:
            C = torch.view_as_complex(rearrange(C.float(), "... (L two) -> ... L two", two=2))
    else:
        B = B.float()
        C = C.float()
    
    x = A.new_zeros((batch, dim, dstate))
    ys = []
    
    deltaA = torch.exp(torch.einsum('bdl,dn->bdln', delta, A))
    if not is_variable_B:
        deltaB_u = torch.einsum('bdl,dn,bdl->bdln', delta, B, u)
    else:
        if B.dim() == 3:
            deltaB_u = torch.einsum('bdl,bnl,bdl->bdln', delta, B, u)
        else:
            B = repeat(B, "B G N L -> B (G H) N L", H=dim // B.shape[1])
            deltaB_u = torch.einsum('bdl,bdnl,bdl->bdln', delta, B, u)
    
    if is_variable_C and C.dim() == 4:
        C = repeat(C, "B G N L -> B (G H) N L", H=dim // C.shape[1])
    
    for i in range(u.shape[2]):
        x = deltaA[:, :, i] * x + deltaB_u[:, :, i]
        if not is_variable_C:
            y = torch.einsum('bdn,dn->bd', x, C)
        else:
            if C.dim() == 3:
                y = torch.einsum('bdn,bn->bd', x, C[:, :, i])
            else:
                y = torch.einsum('bdn,bdn->bd', x, C[:, :, :, i])
        if y.is_complex():
            y = y.real * 2
        ys.append(y)
    
    y = torch.stack(ys, dim=2)
    out = y if D is None else y + u * rearrange(D, "d -> d 1")
    if z is not None:
        out = out * F.silu(z)
    out = out.to(dtype=dtype_in)
    
    return out

from .conv import Conv
from .block import Bottleneck

class MambaVisionMixer(nn.Module):
    def __init__(
        self, d_model, d_state=16, d_conv=4, expand=2, dt_rank="auto",
        dt_min=0.001, dt_max=0.1, dt_init="random", dt_scale=1.0, dt_init_floor=1e-4
    ):
        super().__init__()
        self.d_model = d_model
        self.d_state = d_state
        self.d_conv = d_conv
        self.expand = expand
        self.d_inner = int(self.expand * self.d_model)
        self.dt_rank = dt_rank if dt_rank != "auto" else int(math.ceil(self.d_model / 16))
        
        self.in_proj = nn.Linear(self.d_model, self.d_inner)
        self.conv1d_x = nn.Conv1d(self.d_inner // 2, self.d_inner // 2, d_conv, padding='same', groups=self.d_inner // 2)
        self.conv1d_z = nn.Conv1d(self.d_inner // 2, self.d_inner // 2, d_conv, padding='same', groups=self.d_inner // 2)
        
        self.x_proj = nn.Linear(self.d_inner // 2, self.dt_rank + 2 * self.d_state, bias=False)
        self.dt_proj = nn.Linear(self.dt_rank, self.d_inner // 2, bias=True)
        
        A = repeat(torch.arange(1, self.d_state + 1, dtype=torch.float32), "n -> d n", d=self.d_inner // 2).contiguous()
        self.A_log = nn.Parameter(torch.log(A))
        self.A_log._no_weight_decay = True
        
        self.D = nn.Parameter(torch.ones(self.d_inner // 2))
        self.D._no_weight_decay = True
        
        self.out_proj = nn.Linear(self.d_inner, self.d_model)
        
        self.dt_scale = dt_scale
        self.dt_min = dt_min
        self.dt_max = dt_max
        self.dt_init = dt_init
        self.dt_init_floor = dt_init_floor
        self._init_weights()
    
    def _init_weights(self):
        dt_init_std = self.dt_rank ** -0.5 * self.dt_scale
        if self.dt_init == "constant":
            nn.init.constant_(self.dt_proj.weight, dt_init_std)
        elif self.dt_init == "random":
            nn.init.uniform_(self.dt_proj.weight, -dt_init_std, dt_init_std)
        
        dt = torch.exp(torch.rand(self.d_inner // 2) * (math.log(self.dt_max) - math.log(self.dt_min)) + math.log(self.dt_min)).clamp(min=self.dt_init_floor)
        inv_dt = dt + torch.log(-torch.expm1(-dt))
        with torch.no_grad():
            self.dt_proj.bias.copy_(inv_dt)
        self.dt_proj.bias._no_reinit = True
    
    def forward(self, hidden_states):
        _, seqlen, _ = hidden_states.shape
        
        xz = self.in_proj(hidden_states)
        xz = rearrange(xz, "b l d -> b d l")
        x, z = xz.chunk(2, dim=1)
        
        A = -torch.exp(self.A_log.float())
        
        x = F.silu(self.conv1d_x(x))
        z = F.silu(self.conv1d_z(z))
        
        x_dbl = self.x_proj(rearrange(x, "b d l -> (b l) d"))
        dt, B, C = torch.split(x_dbl, [self.dt_rank, self.d_state, self.d_state], dim=-1)
        
        dt = rearrange(self.dt_proj(dt), "(b l) d -> b d l", l=seqlen)
        B = rearrange(B, "(b l) dstate -> b dstate l", l=seqlen).contiguous()
        C = rearrange(C, "(b l) dstate -> b dstate l", l=seqlen).contiguous()
        
        y = selective_scan_fn(x, dt, A, B, C, self.D.float(), z=None, delta_bias=self.dt_proj.bias.float(), delta_softplus=True)
        
        y = torch.cat([y, z], dim=1)
        y = rearrange(y, "b d l -> b l d")
        out = self.out_proj(y)
        
        return out

class MambaBlock(nn.Module):
    def __init__(self, dim, mlp_ratio=4., drop=0., drop_path=0.):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.mamba = MambaVisionMixer(dim)
        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
        
        self.norm2 = nn.LayerNorm(dim)
        mlp_hidden_dim = int(dim * mlp_ratio)
        self.mlp = nn.Sequential(
            nn.Linear(dim, mlp_hidden_dim),
            nn.GELU(),
            nn.Dropout(drop),
            nn.Linear(mlp_hidden_dim, dim),
            nn.Dropout(drop)
        )
    
    def forward(self, x):
        x = x + self.drop_path(self.mamba(self.norm1(x)))
        x = x + self.drop_path(self.mlp(self.norm2(x)))
        return x

class C2fMamba(nn.Module):
    def __init__(self, c1, c2, n=1, shortcut=False, g=1, e=0.5):
        super().__init__()
        self.c = int(c2 * e)
        self.cv1 = Conv(c1, 2 * self.c, 1, 1)
        self.cv2 = Conv((2 + n) * self.c, c2, 1)
        self.m = nn.ModuleList()
        
        for i in range(n):
            if i % 2 == 0:
                self.m.append(MambaBlock(self.c, d_state=8, d_conv=3, expand=1))
            else:
                self.m.append(Bottleneck(self.c, self.c, shortcut, g, k=(3, 3), e=1.0))
    
    def forward(self, x):
        y = list(self.cv1(x).chunk(2, 1))
        
        for m in self.m:
            if isinstance(m, MambaBlock):
                B, C, H, W = y[-1].shape
                feat = y[-1].flatten(2).transpose(1, 2)
                feat = m(feat)
                feat = feat.transpose(1, 2).view(B, C, H, W)
                y.append(feat)
            else:
                y.append(m(y[-1]))
        
        return self.cv2(torch.cat(y, 1))

class DropPath(nn.Module):
    def __init__(self, drop_prob: float = 0.):
        super().__init__()
        self.drop_prob = drop_prob
    
    def forward(self, x):
        if self.drop_prob == 0. or not self.training:
            return x
        keep_prob = 1 - self.drop_prob
        shape = (x.shape[0],) + (1,) * (x.ndim - 1)
        random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
        random_tensor.floor_()
        return x.div(keep_prob) * random_tensor

7.4 ultralytics/ultralytics/cfg/models/12/yolo12-mamba.yaml

# YOLO12-Mamba: Hybrid Mamba-CNN Object Detection Model
# Inspired by MambaVision: https://github.com/NVlabs/MambaVision

nc: 80  # number of classes
scales:
  n: [0.50, 0.25, 1024]
  s: [0.50, 0.50, 1024]
  m: [0.75, 0.75, 768]
  l: [1.00, 1.00, 512]
  x: [1.25, 1.25, 512]

backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]]  # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]]  # 1-P2/4
  - [-1, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]]  # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]]  # 5-P4/16
  - [-1, 6, C2fMamba, [512]]   # 融合 MambaBlock
  - [-1, 1, Conv, [1024, 3, 2]]  # 7-P5/32
  - [-1, 3, C2fMamba, [1024]]  # 融合 MambaBlock
  - [-1, 1, SPPF, [1024, 5]]  # 9

head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]]
  - [-1, 3, C2f, [512, True]]
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]]
  - [-1, 3, C2f, [256, True]]
  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]]
  - [-1, 3, C2f, [512, True]]
  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 11], 1, Concat, [1]]
  - [-1, 3, C2f, [1024, True]]
  - [[16, 14, 10], 1, Detect, [nc]]

7.5 test_mamba_yolo12.py

import sys
import os
sys.path.insert(0, 'c:\\Users\\SX\\Desktop\\Mamba-Yolo26\\ultralytics')

def test_mamba_integration():
    print("🔍 测试 YOLO12-Mamba 集成...")
    
    try:
        from ultralytics.nn.modules.mamba import MambaVisionMixer, MambaBlock, C2fMamba
        print("✅ 成功导入 Mamba 模块")
        
        import torch
        
        # 测试 MambaVisionMixer
        x_seq = torch.randn(1, 256, 128)
        mixer = MambaVisionMixer(d_model=128, d_state=8, d_conv=3, expand=1)
        y_seq = mixer(x_seq)
        print(f"✅ MambaVisionMixer 测试通过: {x_seq.shape} → {y_seq.shape}")
        
        # 测试 MambaBlock
        x_seq_2 = torch.randn(1, 256, 256)
        mamba_block = MambaBlock(256)
        y_seq_2 = mamba_block(x_seq_2)
        print(f"✅ MambaBlock 测试通过: {x_seq_2.shape} → {y_seq_2.shape}")
        
        # 测试 C2fMamba
        x_vision = torch.randn(1, 256, 16, 16)
        c2f_mamba = C2fMamba(256, 256, n=2)
        y = c2f_mamba(x_vision)
        print(f"✅ C2fMamba 测试通过: {x_vision.shape} → {y.shape}")
        
        # 测试模型加载
        from ultralytics import YOLO
        print("\n📥 加载 YOLO12-Mamba 模型...")
        model = YOLO('yolo12-mamba.yaml')
        print("✅ 成功加载 YOLO12-Mamba 配置")
        model.info()
        
        print("\n🎉 YOLO12-Mamba 集成测试成功！")
        return True
        
    except Exception as e:
        print(f"❌ 测试失败: {e}")
        import traceback
        traceback.print_exc()
        return False

if __name__ == '__main__':
    test_mamba_integration()

7.6 train_test.py

import sys
sys.path.insert(0, 'c:\\Users\\SX\\Desktop\\Mamba-Yolo26\\ultralytics')

from ultralytics import YOLO

def train_yolo12():
    print("📥 加载 YOLO12-Mamba 模型配置...")
    model = YOLO('yolo12-mamba.yaml')
    
    print("\n📊 模型信息:")
    model.info()
    
    print("\n🚀 开始小批量训练测试...")
    results = model.train(
        data='coco128.yaml',
        epochs=1,
        batch=8,
        imgsz=640,
        workers=1,
        verbose=True,
        device='cpu'
    )
    
    print("\n📈 训练完成！")
    print(f"训练结果保存到: {results.save_dir}")
    
    if hasattr(results, 'results_dict'):
        metrics = results.results_dict
        print("\n📊 训练指标:")
        print(f"  - mAP@0.5: {metrics.get('metrics/mAP50', 'N/A')}")
        print(f"  - mAP@0.5:0.95: {metrics.get('metrics/mAP50-95', 'N/A')}")
    
    return results

if __name__ == '__main__':
    try:
        train_yolo12()
        print("\n🎉 小批量训练测试成功完成！")
    except Exception as e:
        print(f"\n❌ 训练过程中出现错误: {e}")
        import traceback
        traceback.print_exc()

7.7 ultralytics/ultralytics/nn/tasks.py 修改

# 在文件开头添加导入
from ultralytics.nn.modules.mamba import C2fMamba

# 在 base_modules 集合中添加
base_modules = frozenset(
    {
        # ... 其他模块 ...
        C2f,
        C2fAttn,
        C2fPSA,
        C2fMamba,    # 添加
        # ... 其他模块 ...
    }
)

7.8 使用步骤

# 1. 创建项目目录
mkdir -p Mamba-Yolo12/ultralytics/ultralytics/nn/modules
mkdir -p Mamba-Yolo12/ultralytics/ultralytics/cfg/models/12

# 2. 创建 mamba.py
# 将 7.3 节的代码保存到对应路径

# 3. 创建 yolo12-mamba.yaml
# 将 7.4 节的代码保存到对应路径

# 4. 修改 __init__.py 和 tasks.py

# 5. 创建测试脚本
# 将 7.5 和 7.6 节的代码保存

# 6. 安装依赖
cd Mamba-Yolo12
pip install torch==1.13.0 torchvision==0.14.0
pip install -e ./ultralytics

# 7. 运行测试
python test_mamba_yolo12.py
python train_test.py

---

五、关键技术总结

5.1 混合架构设计原则

1. 早期阶段：使用 C2f 进行高效局部特征提取
2. 后期阶段：使用 C2fMamba 捕获长距离依赖

5.2 性能优化建议

1. 窗口化处理：将大特征图分块处理
2. 混合精度训练：使用 FP16/FP8 加速

---

参考文献：

• Mamba: Linear-Time Sequence Modeling with Selective State Spaces (2023)
• YOLO12: Advanced Object Detection (2024)