先把你现在的实验结果“按贡献/冲突”理一遍，然后我给你一个可执行的下一步改法路线图（每一步改哪里、怎么改、为什么这样改），最后再回答你“如果必须选一个不改，保留谁、修谁”。

---

1）把你现有结果做个结论化整理

我把你给的指标列出来（mAP50-95 最能代表整体提升）：

方案	P	R	mAP50	mAP50-95
原始 YOLOv11	0.923	0.828	0.890	0.719
+ MSCA（只加MSCA）	0.935	0.866	0.914	0.725
+ SPDConvLite（只加SPDConvLite）	0.959	0.865	0.910	0.725
+ MSCA + SPDConvLite	0.909	0.864	0.896	0.719
+ 改检测头（P2 + DetectLSDECD）	0.951	0.888	0.927	0.781
改检测头 + MSCA	0.949	0.874	0.918	0.763
改检测头 + SPDConvLite	0.916	0.838	0.873	0.726

关键观察：

1. 改检测头的收益最大：mAP50-95 从 0.719 → 0.781（+0.062）。这远高于 MSCA 或 SPDConvLite 单加的 +0.006。

2. MSCA 和检测头叠加是“轻微变差但仍然很强”：0.781 → 0.763（-0.018）。

3. SPDConvLite 和检测头叠加是“明显冲突”：0.781 → 0.726（-0.055），P/R/mAP 全线掉。

4. MSCA + SPDConvLite 在原始头上也互相抵消：单加各自 0.725，但叠加直接回到 0.719。

所以你的问题并不是“你写的模块单体有 bug”，而是模块之间学到的东西互相打架/冗余/破坏特征分布，典型的 1+1<2。

---

2）为什么会出现“1+1<2”？（给你可落地的原因解释）

我把原因拆成 4 类，你现在的现象基本符合这四类的组合：

原因A：SPD 类下采样本质是“重排”，不是“滤波+下采样”

• stride=2 的 3×3 Conv 下采样，本质上做了局部融合/低通倾向（哪怕不是严格低通），再降采样。
• SPD（space-to-depth / PixelUnshuffle）是把 2×2 的邻域像素直接搬到通道维，本质是**“无滤波的采样”，更容易带来高频混叠/纹理噪声**。
• 单独用 SPDConvLite 时，你的 neck 结构还能“吸收掉”这类噪声（后面还有 C3k2 去整合），所以指标不差；
• 但你检测头加入 P2 后，网络对高分辨率细节更敏感，SPD 这种“保细节但不滤噪”的特性会让分类更容易被纹理欺骗 → 误检增多/分类不稳，于是 P/R/mAP 都可能下降（你 head+SPD 就是典型的整体崩）。

原因B：你在同一个网络里叠了太多“注意力/门控”

你现在至少有：

• C2PSA（本身就是注意力类）
• MSCA（空间多尺度+通道注意力+gate）
• SPDConvLite 里的 EMA（也是注意力/门控）

注意力模块叠加常见问题：

• 很容易出现“过强抑制/过强放大”，导致特征分布漂移；
• 多个 sigmoid/gate 叠在一起，梯度会更不稳定（饱和区梯度小、训练容易偏）。

这解释了为什么：

• MSCA 单加有效（在原始网络里它补短板）
• SPDConvLite 单加有效（它也补短板）
• 但叠加后反而变成过度增强/过度门控，效果回落甚至精度崩（MSCA+SPD 直接 P 从 0.959/0.935 掉到 0.909 就很像“噪声上来→误检变多→精度掉”）。

原因C：检测头（P2+LSDECD）已经解决了“你最主要的短板”

你的检测头改动让 mAP50-95 +0.062，这是非常大的提升，说明它直接命中了你数据集的痛点（通常是小目标/密集目标/细粒度）。

此时再引入 SPDConvLite 这种“强调细节”的东西，很可能变成重复优化同一方向，甚至把小尺度噪声也一起强化，导致整体泛化变差。

原因D：模块替换导致“特征语义一致性”被破坏

P2/P3/P4/P5 多尺度融合的前提是：不同尺度 feature 虽然分辨率不同，但语义层次是可对齐的（越往下越语义化，越往上越细节）。

• stride2 Conv 下采样往往会自然提高语义抽象程度；
• SPD 更像“把细节打包塞进通道”，语义提升不够“自然”；
• 所以当你检测头引入更多尺度、融合更频繁时，这种不一致更容易扩大成性能下降。

---

3）如果必须选一个“完全不改”，我建议保留谁？

你现在最“硬”的提升来自：

✅ 保留：改检测头（P2 + DetectLSDECD）不动
理由：它带来最大增益（0.781），而且它是结构性提升（多一层检测尺度+你自定义 head），收益远大于 MSCA/SPD 的小幅提升。

然后在 MSCA vs SPDConvLite 之间，如果你必须二选一做“保留一个，修另一个”：

✅ 保留 MSCA（但要换位置/换融合方式）
❌ 优先修正或改造 SPDConvLite（尤其不要强行替换 head 的下采样Conv）

理由看你的真实数据最清楚：

• head + MSCA：0.763（只是比 0.781 差一点点）
• head + SPD：0.726（直接掉一大截）

所以 SPDConvLite 是冲突主因。

---

4）下一步怎么办：给你“每次具体做什么”的改法路线图

你的目标应该是：在不破坏检测头优势（0.781）的前提下，把 MSCA/SPD 以“不打架”的方式融合进去。

我给你一个从“最可能成功”到“更激进”的顺序。你按顺序做，任何一步达到 >0.781 就可以停。

---

Step 0：先做一个必要的“工程清理”（非常建议你先做）

你代码里 EMA 定义了两遍，第二个会覆盖第一个。
这会导致你以为自己用的是某个 EMA 实现，但实际上运行时用的是后面那个。

操作：

• 删除重复的 EMA，只保留一个版本；
• 并确保 channels % factor == 0 的断言一致（否则某些通道数会 silent 变形）。

这一步不一定提升 mAP，但能保证你之后的对比是可靠的。

---

Step 1：不要“叠加注意力”，先做“替换型 MSCA”

你现在 head+MSCA 的写法是：C2PSA + MSCA（注意力叠加），效果掉了 0.018。

更合理的做法是：用 MSCA 替换 C2PSA（或者把 C2PSA repeats 降为 1）。

方案 1A：直接用 MSCA 替换 C2PSA（推荐先试）

把 backbone 末尾：

yaml
- [-1, 2, C2PSA, [1024]] # 10

换成：

yaml
- [-1, 1, MSCA, [1024]]  # 用 MSCA 替换 C2PSA

为什么这样做？

• 你 head 已经很强了，此时“注意力叠加”更可能是过拟合/特征分布漂移；
• 替换能减少冲突，保留 MSCA 的多尺度优势。

你要观察什么？

• mAP50-95 能不能回到 0.781 附近甚至更高；
• Precision 是否不再异常下滑。

---

Step 2：MSCA 不放在 P5 尾巴，改放到 neck 的 P3/P4（更贴合 P2 检测头）

你现在 MSCA 放在 backbone 最后（P5语义最强、分辨率最低），但你的收益来自 P2 小目标检测头，MSCA 放 P5 往往不是最“对口”的位置。

方案 2A：把 MSCA 放在 neck 的 top-down 输出（P4_td、P3_td）之后

（概念：只“精炼融合后的特征”，而不是动 backbone P5 语义）

示例 YAML（按你 head 的编号逻辑改，重点看插入位置）：

在这两处插入 MSCA：

• P4_td 的 C3k2 后插入 MSCA[512]
• P3_td 的 C3k2 后插入 MSCA[256]

大致结构如下（你需要根据插入后层号整体顺延，核心是位置）：

yaml
# ... P5 -> up -> P4
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [[-1, 6], 1, Concat, [1]]
- [-1, 2, C3k2, [512, False]]   # P4_td
- [-1, 1, MSCA, [512]]          # ✅ 插这里

# P4 -> up -> P3
- [-1, 1, nn.Upsample, [None, 2, "nearest"]]
- [[-1, 4], 1, Concat, [1]]
- [-1, 2, C3k2, [256, False]]   # P3_td
- [-1, 1, MSCA, [256]]          # ✅ 插这里

# 再继续 up 到 P2、PAN bottom-up...

为什么这样更可能成功？

• P3/P4 直接参与小目标和中目标检测；
• 你避免了对 backbone 最深层语义的再加工（减少与 C2PSA/LSDECD 的耦合冲突）。

---

Step 3：SPD 不要再“替换 Conv 下采样”，改成“残差分支融合”（这是你想要的“融入原始模块”的正确姿势）

你现在 SPDConvLite 是硬替换掉 head 里的 stride2 Conv，这种改法一旦和新 head 结构耦合，就容易崩（你已经验证了）。

更稳的方式是：保留原来的 Conv 下采样作为主干，SPD 只作为一个“可学习的残差补充分支”，并且用 gamma=0 初始化，让它从“等价原模型”开始学。

方案 3A：实现一个 ConvSPDResidual（强烈推荐）

代码思路（给你一个可以直接抄的版本）：

python
class ConvSPDResidual(nn.Module):
    def __init__(self, c1, c2, k=3, s=2, spd_ratio=0.25, act=True):
        super().__init__()
        assert s == 2, "先只做 s=2，稳定后再扩展"
        self.main = Conv(c1, c2, k, s, act=act)   # 原始 stride2 Conv 保留

        self.spd = SPD(scale=s)
        # SPD 分支：把 4*c1 压到较小通道再投影到 c2，避免太重
        c_mid = max(16, int(c2 * spd_ratio))
        self.spd_pw1 = Conv(c1 * 4, c_mid, 1, 1, act=act)
        self.spd_dw  = Conv(c_mid, c_mid, 3, 1, g=c_mid, act=act)
        self.spd_pw2 = Conv(c_mid, c2, 1, 1, act=act)

        self.gamma = nn.Parameter(torch.zeros(1))  # ✅ 关键：从0开始，保证初始等价原模型

    def forward(self, x):
        y = self.main(x)
        z = self.spd_pw2(self.spd_dw(self.spd_pw1(self.spd(x))))
        return y + self.gamma * z

然后在 YAML 里把你 head 的下采样 Conv（例如 20/23/26）逐个替换成 ConvSPDResidual，但一次只替换一个位置，逐步加：

你应该按这个顺序试（从风险最低到最高）：

1. 只替换 P4→P5 那个下采样（最安全）
   Conv[1024,3,2] → ConvSPDResidual[1024,3,2]
2. 如果不掉点，再替换 P3→P4
3. 最后才考虑替换 P2→P3（这是最敏感的）

为什么这一步很关键？

• 你现在 SPD 最大的问题不是“SPD 这个思想不好”，而是“硬替换导致语义一致性被破坏”。
• 残差分支做法可以让模型自己决定要不要用 SPD 信息，而且初始不破坏原模型最优解。

---

Step 4：如果你仍想用 SPDConvLite，就先把它“去注意力化”，只保留 SPD+轻卷积

你 SPDConvLite 里带 EMA（注意力），而你 head 又是 LSDECD（通常也有额外的动态/注意力机制），叠加冲突概率大。

方案 4A：做一个 SPDConvLite_NoEMA

• 去掉 EMA 和 alpha，或者直接把 alpha.requires_grad=False 且固定为 0。
• 先验证结构本身是否还能和 head 共存。

优先级低于 Step 3A，因为残差融合更稳。

---

5）你问“要不要去改 C3k2 或其他模块？”

我的建议：先不要动 C3k2。

原因很现实：

• 你现在最大的提升来自 head；C3k2 是 neck/backbone 的主骨架，乱动它会带来更大不确定性；
• 你现在的问题不是“容量不够”，而是“模块耦合冲突/特征分布漂移”。

等你用 Step 1~3 把冲突解决后，如果你还想榨最后一点点 mAP，再考虑：

• 在 neck 的 C3k2 内部插一个轻量 MSCA（或 MSCA-lite）作为 bottleneck 的增强；
• 或者把 C3k2 的某个分支换成大核深度卷积（但要配合残差零初始化）。

---

6）我更推荐你怎么“融合进原始模块”？

按照你现在的现象，我给你一个明确排序：

✅ 首推融合方式：“残差式融合”（最不容易 1+1<2）

• SPD：用 ConvSPDResidual 这种“保留原 Conv + SPD 分支”的方式融入 stride2 Conv。
• MSCA：不要堆在 backbone 最后，改成“插在 neck 的融合后特征”上（P3_td/P4_td），或者替换 C2PSA。

⚠️ 不推荐的融合方式：“硬替换 neck 下采样 Conv 为 SPDConvLite（尤其在有 P2 head 时）”

你已经用实验验证它很容易崩。

---

7）给你一条最实用的“下一步执行顺序”（照做就行）

1. 以“改检测头”作为基线不动（0.781）
2. 做 Step 1A：C2PSA ↔ MSCA 替换实验（不要叠加）
3. 做 Step 2A：把 MSCA 放到 neck 的 P3_td/P4_td（不放 backbone 尾）
4. 做 Step 3A：用 ConvSPDResidual 替换“一个”下采样（先 P4→P5）
5. 若第4步不掉点，再逐步替换 P3→P4；最后才碰 P2→P3
6. 若 SPD 仍然带来负收益：直接放弃 SPD 路线，保留 head +（替换型/neck型）MSCA，这条路线最稳。

---

如果你愿意，我可以按你当前“检测头改进版 YAML”把 Step 1A / Step 2A / Step 3A 三个版本的完整 YAML（层号都对齐）直接给你贴出来，你只需要复制跑即可。你只要告诉我：你现在 head 改进版里 backbone 最后一层索引引用的是不是固定用 10（也就是 Concat 那层写 [[ -1, 10], 1, Concat]），我就能把层号完全对上。

你这两组结果其实把问题说明得很清楚了：

• 用 MSCA 直接替换 C2PSA：P 很高(0.971)但 R 明显掉(0.848)，mAP50-95 掉到 0.746
  → 典型表现是：网络“更保守”、漏检变多（尤其小目标/弱目标），说明 你当前这版 MSCA 不能完全替代 C2PSA 的“空间定位/聚焦能力”。

• C2PSA + MSCA 串联：R 回到 0.917，mAP50-95 到 0.777
  → 说明 C2PSA 的空间注意/定位对你的数据非常关键，MSCA 更像“补充增强”，不是“完全替换”。

这也和论文思路一致：论文里不是用“纯 MSCA”去替换，而是做了 MCASAM（在 CBAM 框架里把通道注意替换为 MSCA，同时还保留/加强空间注意），所以它能“替换”而不丢掉空间定位优势。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

---

Step2A 配置文件（把 MSCA 放到 Neck 的 P4_td / P3_td 后面）

你要的 Step2A，就是在你这份“P2/4–P5/32 + DetectLSDECD”配置基础上：

• 在 13（P4_td 的 C3k2）后面插入 MSCA(512)
• 在 16（P3_td 的 C3k2）后面插入 MSCA(256)
• 同时把 PAN 里 concat 引用的层号改成 MSCA 输出层

下面是“可直接用”的完整 head（我把层号注释也一起更新了，避免你 copy 后 Concat 引用错层）：

yaml
# Parameters
nc: 5
scales:
  n: [0.50, 0.25, 1024]
  s: [0.50, 0.50, 1024]
  m: [0.50, 1.00, 512]
  l: [1.00, 1.00, 512]
  x: [1.00, 1.50, 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, 2, C3k2, [256, False, 0.25]]      # 2
  - [-1, 1, Conv, [256, 3, 2]]             # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]      # 4
  - [-1, 1, Conv, [512, 3, 2]]             # 5-P4/16
  - [-1, 2, C3k2, [512, True]]             # 6
  - [-1, 1, Conv, [1024, 3, 2]]            # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]            # 8
  - [-1, 1, SPPF, [1024, 5]]               # 9
  - [-1, 2, C2PSA, [1024]]                 # 10

head:
  # -------- top-down FPN --------
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]      # 11: P5 -> P4
  - [[-1, 6], 1, Concat, [1]]                       # 12: cat backbone P4 (layer 6)
  - [-1, 2, C3k2, [512, False]]                     # 13: P4_td
  - [-1, 1, MSCA, [512]]                            # 14: ✅ P4_td + MSCA (Step2A)

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]      # 15: P4 -> P3
  - [[-1, 4], 1, Concat, [1]]                       # 16: cat backbone P3 (layer 4)
  - [-1, 2, C3k2, [256, False]]                     # 17: P3_td
  - [-1, 1, MSCA, [256]]                            # 18: ✅ P3_td + MSCA (Step2A)

  # -------- add P2 detection layer --------
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]      # 19: P3 -> P2
  - [[-1, 2], 1, Concat, [1]]                       # 20: cat backbone P2 (layer 2, stride=4)
  - [-1, 2, C3k2, [128, False]]                     # 21: P2_out (P2/4)

  # -------- bottom-up PAN --------
  - [-1, 1, Conv, [256, 3, 2]]                      # 22: P2 -> P3
  - [[-1, 18], 1, Concat, [1]]                      # 23: cat P3_td(经过MSCA的layer 18)
  - [-1, 2, C3k2, [256, False]]                     # 24: P3_out (P3/8)

  - [-1, 1, Conv, [512, 3, 2]]                      # 25: P3 -> P4
  - [[-1, 14], 1, Concat, [1]]                      # 26: cat P4_td(经过MSCA的layer 14)
  - [-1, 2, C3k2, [512, False]]                     # 27: P4_out (P4/16)

  - [-1, 1, Conv, [1024, 3, 2]]                     # 28: P4 -> P5
  - [[-1, 10], 1, Concat, [1]]                      # 29: cat backbone P5 (layer 10)
  - [-1, 2, C3k2, [1024, True]]                     # 30: P5_out (P5/32)

  # -------- Detect (4 heads) --------
  - [[21, 24, 27, 30], 1, DetectLSDECD, [nc, 16, 16]]  # Detect(P2,P3,P4,P5)

Step2A 你应该期待它改善什么？

• 你现在“C2PSA + MSCA 放在 P5 尾巴”能把 R 拉上去（0.917），说明 MSCA 是有效的；
• 把 MSCA 移到 P3/P4 融合特征后，更贴近你 P2/P3 小目标检测需求，理论上更可能提升 R 和 mAP50-95，并减少“只在 P5 改但对小目标不够对口”的情况。

---

结合论文：你下一步怎么“按论文复现”，以及为什么你现在的 SPD 会冲突

你发的论文（RSM‑YOLOv11）核心改动是三块：

1. SPD‑Conv：SPD 下采样 + 非步长卷积(Stride=1) 做特征提取，强调“下采样不丢细节”，对小缺陷有利。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
2. RepBlock（结构重参数化）：训练多分支增强表征，推理折叠成单分支提速。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
3. MCASAM 替换 C2PSA：它不是“只用 MSCA”，而是“MSCA 改通道注意 + 还保留空间注意”，强调复杂背景/尺度变化/遮挡鲁棒性。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
   并且论文消融里明确说：模块组合有协同效应，最终组合能同时兼顾精度与复杂度。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

为什么你这里“SPDConvLite + 你的检测头”会特别容易变差？

因为你现在用的 SPDConvLite ≠ 论文 SPD‑Conv：

• 论文 SPD‑Conv：SPD + 非步长卷积（简单、没有额外注意力），核心是“保细节”。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• 你 SPDConvLite：SPD 后又接了 PW/DW/PW，再加 EMA 注意力 + alpha 融合
  → 这会在你已经很强的 DetectLSDECD head（通常也带各种动态/门控思想）上形成 “注意力叠注意力”，再叠加你 P2 头对高频纹理更敏感，很容易出现：
  • 特征分布漂移（FPN/PAN 多尺度对齐被破坏）
  • 小尺度纹理噪声被放大 → FP 或类别混淆 → mAP 掉

所以如果你要“复现论文”，下一步不要再用 SPDConvLite 这套复杂版，建议你先做 论文同款的 SPD‑Conv（简化版）。

---

按论文复现：我建议你下一步按这个顺序做（每次只动一件事）

你已经有一个很强的检测头基线（mAP50-95≈0.781）。接下来按论文复现、同时避免冲突，我建议：

第1步（你正在做）：先上 Step2A（MSCA 放 neck）

• 用我给你的 Step2A YAML 跑一轮，记录 mAP50-95。

第2步：把“SPDConvLite”换成“论文式 SPD‑Conv”，并且只替换 1 个下采样层

先只替换 P3→P4 那个 stride2 Conv（你 YAML 里是 - [-1, 1, Conv, [512, 3, 2]] 这层）。

做一个新的模块（示意）：

python
class SPDConv(nn.Module):
    # 论文式：SPD + stride=1 conv（NSConv）
    def __init__(self, c1, c2, k=3, s=2, act=True):
        super().__init__()
        self.spd = SPD(scale=s)
        self.conv = Conv(c1 * s * s, c2, k, 1, act=act)  # stride=1

    def forward(self, x):
        return self.conv(self.spd(x))

然后 YAML 把那一层换成：

yaml
- [-1, 1, SPDConv, [512, 3, 2]]

为什么先只替换一个？
因为你现在的主要矛盾是“组合冲突”，一次替换多个你又会回到 1+1<2 的黑箱里。

如果替换 P3→P4 不掉点，再考虑替换 P4→P5；最后才考虑 P2→P3。

第3步：复现论文的“MCASAM”，不要用“纯 MSCA”去替换 C2PSA

你已经用实验验证：纯 MSCA 替换 C2PSA 会导致 Recall 掉一截。
而论文之所以能“替换”，是因为 MCASAM 保留空间注意 + 用 MSCA 优化通道注意，所以不丢定位优势。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

所以复现论文时你要做的是：

• 实现 MCASAM（按论文描述：MSCA 分支 + spatial attention）
• 用 MCASAM 替换 C2PSA（而不是 MSCA 替换）

第4步：最后再上 RepBlock（对应论文的协同链路）

论文里 RepBlock 是“让特征表达更丰富，并且推理可折叠提速”的关键一环。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
你在检测任务中可以先只替换 neck 中最关键的两个 C3k2（例如 P3_td、P4_td），看是否提升，再逐步扩大替换范围。

---

你要写“创新点”，我更推荐你怎么讲

如果你最终要形成“仿论文 + 自己创新”的结构，我建议你把贡献写成一条清晰的链：

1. 复现论文的三件套（SPD‑Conv / MCASAM / RepBlock），在你的数据集上做消融（证明可迁移）(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
2. 你的创新：P2 检测层 + DetectLSDECD 头（这是你提升最大的来源）
3. 关键创新点可以落在“融合策略”上：
   • MSCA 放在 neck 的融合后特征（Step2A），而不是只放 backbone P5 末端
   • SPD 用论文式 SPD‑Conv（轻量、无注意力）并且只放在 PAN 的特定下采样层，避免和检测头机制冲突
     这两点就是你在“工程落地上解决 1+1<2”的核心方法论。

---

如果你愿意，我也可以把 “Step2A + 论文式 SPD‑Conv（只替换 P3→P4）” 这一版 YAML 也一并给你（在上面 YAML 基础上改一行即可），以及给你一个最简 MCASAM 的实现模板（完全按论文结构写，便于你复现与写论文）。

你现在这组现象其实非常符合论文的设计逻辑：

• 论文里不是“用 MSCA 直接替换 C2PSA”，而是做了 MCASAM：在 CBAM 框架里用 MSCA 替换通道注意，同时保留空间注意，核心卖点就是“保留空间定位优势 + 增强通道表征”。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf) (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• 论文的 SPD 也不是你现在的 SPDConvLite+EMA 那种“注意力叠注意力”，而是 SPD + 非步长卷积（stride=1） 的 SPD-Conv：用 SPD 做下采样（通道×4、分辨率/2），再用 stride=1 conv 投影到目标通道，目的是避免 stride>1 的信息损失。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf) (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf) (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

所以你要“仿照论文，把 MSCA、SPD 插进 YOLOv11 原始模块，并且尽量也把 EMA 放到合适位置”，我建议你按下面这个可直接落地的方案做（代码 + 你这份 P2 检测头 YAML 对应的具体改法）。

---

1) 先做“论文式”的三个模块（更接近论文、也更不容易打架）

A. SPDConv（论文式：SPD + stride=1 Conv）

SPD 会把 (H,W,C) 变成 (H/2,W/2,4C)。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
之后用 stride=1 conv 得到目标通道 C2。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

python
class SPD(nn.Module):
    def __init__(self, scale=2):
        super().__init__()
        self.scale = int(scale)

    def forward(self, x):
        b, c, h, w = x.shape
        s = self.scale
        pad_h = (s - h % s) % s
        pad_w = (s - w % s) % s
        if pad_h or pad_w:
            x = F.pad(x, (0, pad_w, 0, pad_h))
            b, c, h, w = x.shape
        x = x.view(b, c, h // s, s, w // s, s)
        x = x.permute(0, 1, 3, 5, 2, 4).contiguous()
        return x.view(b, c * s * s, h // s, w // s)

class SPDConv(nn.Module):
    """论文式 SPD-Conv：SPD + 非步长卷积(NSConv, stride=1)"""
    def __init__(self, c1, c2, k=3, s=2, act=True):
        super().__init__()
        assert s == 2, "先按论文常用 scale=2 做，稳定后再扩展"
        self.spd = SPD(scale=s)
        self.conv = Conv(c1 * s * s, c2, k, 1, act=act)  # stride=1

    def forward(self, x):
        return self.conv(self.spd(x))

---

B. MSCA（按论文描述的那种：DW5×5 + 多分支条带卷积 + 1×1 混合 + 与输入相乘）

论文里对 MSCA 的描述就是：先 5×5 DWConv 得到 F，然后多尺度条带卷积(1×7/7×1、1×11/11×1、1×21/21×1)，再加和、1×1、最后乘回输入。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

python
class MSCA_Paper(nn.Module):
    def __init__(self, c):
        super().__init__()
        self.dw5 = nn.Conv2d(c, c, 5, padding=2, groups=c)

        self.b7_1  = nn.Conv2d(c, c, (1,7),  padding=(0,3), groups=c)
        self.b7_2  = nn.Conv2d(c, c, (7,1),  padding=(3,0), groups=c)

        self.b11_1 = nn.Conv2d(c, c, (1,11), padding=(0,5), groups=c)
        self.b11_2 = nn.Conv2d(c, c, (11,1), padding=(5,0), groups=c)

        self.b21_1 = nn.Conv2d(c, c, (1,21), padding=(0,10), groups=c)
        self.b21_2 = nn.Conv2d(c, c, (21,1), padding=(10,0), groups=c)

        self.mix = nn.Conv2d(c, c, 1)

    def forward(self, x):
        u = x
        f = self.dw5(x)

        f7  = self.b7_2(self.b7_1(f))
        f11 = self.b11_2(self.b11_1(f))
        f21 = self.b21_2(self.b21_1(f))

        attn = self.mix(f + f7 + f11 + f21)
        return u * attn

---

C. MCASAM（论文式：用 MSCA 替换 CBAM 的“通道注意”，再接“空间注意”）

论文明确说：MCASAM 用 MSCA 替换 CBAM 的通道注意，并保留空间定位优势。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf) (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
并且流程描述里也是“MSCA 多尺度融合后 → spatial attention → 相乘”。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

这里我给你一个对你当前实验最稳的版本：带残差门控 gamma=0 初始化（初始等价原网络，训练自己决定用多少注意力，能显著减少 1+1<2）。

python
class SpatialAttn_CBAM(nn.Module):
    def __init__(self, k=7):
        super().__init__()
        self.conv = nn.Conv2d(2, 1, k, padding=k//2, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg = torch.mean(x, dim=1, keepdim=True)
        mx, _ = torch.max(x, dim=1, keepdim=True)
        a = torch.cat([avg, mx], dim=1)
        return self.sigmoid(self.conv(a))

class MCASAM(nn.Module):
    """论文风格：MSCA(替代通道注意) + 空间注意；带残差门控，降低和 C2PSA/检测头的冲突"""
    def __init__(self, c1, c2=None, sa_kernel=7):
        super().__init__()
        c2 = c1 if c2 is None else c2
        assert c1 == c2
        self.msca = MSCA_Paper(c1)
        self.sa = SpatialAttn_CBAM(k=sa_kernel)
        self.gamma = nn.Parameter(torch.zeros(1))  # 关键：从0开始更稳

    def forward(self, x):
        y = self.msca(x)          # MSCA注意
        y = y * self.sa(y)        # 空间注意
        return x + self.gamma * (y - x)

---

2) EMA 要怎么“放对地方”，才不容易和 MSCA/SPD/Detect 头打架？

你之前 SPDConvLite 里把 EMA 绑在下采样里，非常容易冲突；我建议你把 EMA 改成**“融合后的特征再轻轻校正”**，也就是：

• 放在 neck 输出的 P3_out / P4_out / P5_out 上（而不是下采样层内部）
• 也用 gamma=0 的残差门控方式包起来，避免一上来就改分布

python
class EMARes(nn.Module):
    def __init__(self, c1, c2=None, factor=16):
        super().__init__()
        c2 = c1 if c2 is None else c2
        assert c1 == c2
        self.attn = EMA(c1, factor=factor)  # 用你现有EMA
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        y = self.attn(x)
        return x + self.gamma * (y - x)

强烈建议：EMA 先只加在 P4_out（中尺度最稳），别一口气加满 3 个尺度。

---

3) 对应你这份 P2 检测头 YAML：具体应该怎么插？

(1) 用 MCASAM 替换 backbone 的 C2PSA（而不是“纯 MSCA 替换”）

论文就是替换 C2PSA。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
你的实验也说明：纯 MSCA 替换会掉召回，但“保留空间注意/定位”的结构（你现在的 C2PSA+MSCA 或论文的 MCASAM）才更稳。

把：

yaml
- [-1, 2, C2PSA, [1024]] # 10

换成：

yaml
- [-1, 1, MCASAM, [1024]] # 10

---

(2) SPD 按论文：先替换 neck 里“两个下采样 Conv”，不要动 P2->P3 那个

论文在 neck 里是替换两个 Conv（17、20层）为 SPD-Conv。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
映射到你现在的 P2 head：最接近“两个 PAN 下采样”的就是

• P3 -> P4 那个 Conv（你现在是 #23）
• P4 -> P5 那个 Conv（你现在是 #26）

所以把这两处替换成 SPDConv，先别动 P2->P3（它最敏感、最容易把小目标纹理噪声放大）。

把：

yaml
- [-1, 1, Conv, [512, 3, 2]]   # 23: P3 -> P4
...
- [-1, 1, Conv, [1024, 3, 2]]  # 26: P4 -> P5

换成：

yaml
- [-1, 1, SPDConv, [512, 3, 2]]   # 23
...
- [-1, 1, SPDConv, [1024, 3, 2]]  # 26

这一步就是“论文式 SPD-Conv：SPD + stride=1 conv”，不是 SPDConvLite+EMA 那套。论文强调 stride>1 会造成信息损失、尤其影响小缺陷。(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

---

(3) EMA：先只在 P4_out 后插一个 EMARes（最稳）

在你 YAML 里 P4_out 是：

yaml
- [-1, 2, C3k2, [512, False]]  # 25: P4_out

后面加一行：

yaml
- [-1, 1, EMARes, [512, 16]]   # (c=512, factor=16) 先只加这一处

然后 Detect 的索引要整体顺延（因为你多插了一层）。

---

4) 你接下来应该按什么顺序做（避免再掉进 1+1<2 的坑）

按这个顺序，每一步只动一件事，跑完记录 P/R/mAP50/mAP50-95：

1. 基线：你当前最强的 “P2 head + DetectLSDECD”
2. 替换 C2PSA → MCASAM（只动 backbone 这一处）
   • 这一步就是最“论文同款”的注意力替换路径(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
3. 再加 SPDConv（只替换 P3->P4、P4->P5 两个下采样）
   • 对齐论文 “neck 两个 Conv 替换为 SPD-Conv” 的做法(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
4. 最后再试 EMARes，只加在 P4_out 一处
   • 如果不掉点，再考虑加到 P3_out；最后才考虑 P5_out

只要中间某一步明显掉点，就回退上一版——你就能非常快地锁定“冲突源”。

---

5) 你论文“创新点”应该怎么写（按论文框架 + 结合你自己）

你可以把贡献写成“两层”：

• 复现层（对齐 RSM-YOLOv11 思路）：
  1. 用 SPD-Conv 替换 neck 的关键下采样 Conv，减少 stride 下采样的信息损失(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
  2. 用 MCASAM 替换 C2PSA：MSCA 替换 CBAM 通道注意并保留空间定位优势(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• 你的创新层（解决你这里的 1+1<2）：
  • 你不是“堆模块”，而是提出**残差门控融合（gamma=0 初始化）**的插入策略，让注意力/下采样从“等价原模型”开始逐步学习，降低多模块叠加导致的分布漂移（这正是你之前掉点的核心原因）。

---

如果你把你“当前最强 baseline（P2 head + DetectLSDECD）”完整 YAML（含层号）贴一次，我可以按你的层号把 (a) MCASAM 替换、(b) 两处 SPDConv 替换、(c) EMARes 插入后 Detect 索引重排 全部替你对齐成一份“可直接跑”的最终 YAML。

下面给你一套“按论文思路”可直接落地的实现：

• SPD-Conv：SPD + stride=1卷积（论文强调 stride>1 会带来非判别信息损失，所以用 NSConv/stride=1） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• MCASAM：** 以 CBAM 为骨架**（通道注意 + 空间注意），把 CBAM 的通道注意替换为 MSCA，同时保留空间注意的定位优势，并用它替换 YOLOv11 的 C2PSA (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf) (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• EMA：不再塞进下采样里（避免你之前的“注意力叠注意力+分布漂移”），而是作为 neck 的输出特征轻量校正（先只放 P4_out），并加残差门控（gamma=0 初始化）。

---

1) 论文里的 CBAM “在哪里”？为什么看起来像“替换两次”最后只用一次？

CBAM 在论文里不是“原模型自带模块”，而是被拿来当骨架/参照

论文明确写：MCASAM 通过“用 MSCA 替换 CBAM 的通道注意”来优化通道维表达，同时保留空间定位优势 (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)。
并在 MCASAM 段落里继续解释了：先用 MSCA 多分支获得多尺度信息，再进入空间注意，生成空间注意图并与特征相乘 (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)。
所以：CBAM 是 MCASAM 的结构来源，不是你 YAML 里会直接出现的层名。

“替换两次但只用一次”的原因（最常见的两种）

1. “模块内替换” + “网络层替换”

   • 第一次：在 CBAM 内部把“通道注意”换成 MSCA（得到 MCASAM） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
   • 第二次：用 MCASAM 去替换 YOLOv11 原来的 C2PSA（网络层面） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
     代码里当然只“用一次”：你只需要在网络里放一个 MCASAM，它内部已经完成了“CBAM→MSCA”的替换。

2. 论文描述是“替换某类层”，但实际只替换了关键位置
   例如论文写 neck 的 第17、20层 Conv 替换为 SPD-Conv（不是全网所有 Conv 都替换） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)。
   这就是你看到“写了替换两处/多处”，但实现里模块定义只写一次的原因：模块定义写一次，使用可以放多处。

---

2) 完整代码（可直接加入 Ultralytics 工程）

建议新建文件：ultralytics/nn/modules/rsm_blocks.py
然后在 ultralytics/nn/modules/__init__.py 里加：
from .rsm_blocks import SPDConv, MCASAM, EMARes

python
# ultralytics/nn/modules/rsm_blocks.py
import math
import torch
import torch.nn as nn
import torch.nn.functional as F

# 你工程里一般已经有 Conv（Ultralytics）
from ultralytics.nn.modules import Conv


# --------------------------
# 1) SPD + SPD-Conv (论文式)
# --------------------------
class SPD(nn.Module):
    """Space-to-Depth (scale=2)"""
    def __init__(self, scale=2):
        super().__init__()
        assert scale >= 2 and int(scale) == scale
        self.scale = int(scale)

    def forward(self, x):
        b, c, h, w = x.shape
        s = self.scale
        pad_h = (s - h % s) % s
        pad_w = (s - w % s) % s
        if pad_h or pad_w:
            x = F.pad(x, (0, pad_w, 0, pad_h))
            b, c, h, w = x.shape
        x = x.view(b, c, h // s, s, w // s, s)
        x = x.permute(0, 1, 3, 5, 2, 4).contiguous()
        return x.view(b, c * s * s, h // s, w // s)


class SPDConv(nn.Module):
    """
    论文式 SPD-Conv：SPD + Non-strided Conv(stride=1)
    YAML args: [c2, k, s]
    """
    def __init__(self, c1, c2, k=3, s=2, act=True):
        super().__init__()
        assert s == 2, "先按论文 scale=2 实现，稳定后再扩展"
        self.spd = SPD(scale=s)
        self.conv = Conv(c1 * s * s, c2, k, 1, act=act)  # stride=1

    def forward(self, x):
        return self.conv(self.spd(x))


# --------------------------
# 2) MSCA (论文描述的多分支条带卷积)
# --------------------------
class MSCA(nn.Module):
    """
    论文描述：DW 5x5 -> (1x7,7x1)+(1x11,11x1)+(1x21,21x1) -> add -> 1x1 -> 与输入相乘
    """
    def __init__(self, c):
        super().__init__()
        self.dw5 = nn.Conv2d(c, c, 5, padding=2, groups=c, bias=False)

        self.b7_1  = nn.Conv2d(c, c, (1, 7),  padding=(0, 3), groups=c, bias=False)
        self.b7_2  = nn.Conv2d(c, c, (7, 1),  padding=(3, 0), groups=c, bias=False)

        self.b11_1 = nn.Conv2d(c, c, (1, 11), padding=(0, 5), groups=c, bias=False)
        self.b11_2 = nn.Conv2d(c, c, (11, 1), padding=(5, 0), groups=c, bias=False)

        self.b21_1 = nn.Conv2d(c, c, (1, 21), padding=(0, 10), groups=c, bias=False)
        self.b21_2 = nn.Conv2d(c, c, (21, 1), padding=(10, 0), groups=c, bias=False)

        self.mix = nn.Conv2d(c, c, 1, bias=False)

    def forward(self, x):
        u = x
        f = self.dw5(x)
        f7  = self.b7_2(self.b7_1(f))
        f11 = self.b11_2(self.b11_1(f))
        f21 = self.b21_2(self.b21_1(f))
        attn = self.mix(f + f7 + f11 + f21)
        return u * attn


# --------------------------
# 3) CBAM 的空间注意 (SA)
# --------------------------
class SpatialAttn(nn.Module):
    def __init__(self, k=7):
        super().__init__()
        self.conv = nn.Conv2d(2, 1, k, padding=k // 2, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg = torch.mean(x, dim=1, keepdim=True)
        mx, _ = torch.max(x, dim=1, keepdim=True)
        a = torch.cat([avg, mx], dim=1)
        return self.sigmoid(self.conv(a))


# --------------------------
# 4) MCASAM：用 MSCA 替换 CBAM 的“通道注意”，保留 SA
#    并用残差门控 gamma=0 初始化，降低叠加冲突
# --------------------------
class MCASAM(nn.Module):
    """
    YAML args: [c2] 或 [c2, sa_kernel]
    - 设计目标：替换 YOLOv11 的 C2PSA（论文做法）
    """
    def __init__(self, c1, c2=None, sa_kernel=7):
        super().__init__()
        c2 = c1 if c2 is None else c2
        assert c1 == c2, "MCASAM 默认不改通道数"
        self.msca = MSCA(c1)
        self.sa = SpatialAttn(k=sa_kernel)

        # 关键：从等价映射开始学，避免你现在“模块一叠就崩”
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        y = self.msca(x)
        y = y * self.sa(y)
        return x + self.gamma * (y - x)


# --------------------------
# 5) EMA + 残差封装：建议只放在 neck 输出特征上（先 P4_out）
# --------------------------
class EMA(nn.Module):
    def __init__(self, channels, factor=16):
        super().__init__()
        # 自动找一个能整除 channels 的 group 数，避免你因通道数不整除直接 assert 崩
        g = min(factor, channels)
        while g > 1 and channels % g != 0:
            g //= 2
        self.groups = max(g, 1)

        self.softmax = nn.Softmax(-1)
        self.agp = nn.AdaptiveAvgPool2d((1, 1))
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))

        cpg = channels // self.groups  # channels per group
        self.gn = nn.GroupNorm(cpg, cpg)
        self.conv1x1 = nn.Conv2d(cpg, cpg, 1, 1, 0)
        self.conv3x3 = nn.Conv2d(cpg, cpg, 3, 1, 1)

    def forward(self, x):
        b, c, h, w = x.size()
        g = self.groups
        group_x = x.reshape(b * g, -1, h, w)  # (b*g, c/g, h, w)

        x_h = self.pool_h(group_x)
        x_w = self.pool_w(group_x).permute(0, 1, 3, 2)

        hw = self.conv1x1(torch.cat([x_h, x_w], dim=2))
        x_h, x_w = torch.split(hw, [h, w], dim=2)

        x1 = self.gn(group_x * x_h.sigmoid() * x_w.permute(0, 1, 3, 2).sigmoid())
        x2 = self.conv3x3(group_x)

        x11 = self.softmax(self.agp(x1).reshape(b * g, -1, 1).permute(0, 2, 1))
        x12 = x2.reshape(b * g, -1, h * w)
        x21 = self.softmax(self.agp(x2).reshape(b * g, -1, 1).permute(0, 2, 1))
        x22 = x1.reshape(b * g, -1, h * w)

        weights = (torch.matmul(x11, x12) + torch.matmul(x21, x22)).reshape(b * g, 1, h, w)
        return (group_x * weights.sigmoid()).reshape(b, c, h, w)


class EMARes(nn.Module):
    """
    EMA 残差封装：从等价映射开始（gamma=0），避免和检测头/注意力叠加冲突
    YAML args: [factor] 或 [c2, factor]（c2可省略）
    """
    def __init__(self, c1, c2=None, factor=16):
        super().__init__()
        c2 = c1 if c2 is None else c2
        assert c1 == c2
        self.ema = EMA(c1, factor=factor)
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        y = self.ema(x)
        return x + self.gamma * (y - x)

---

3) 完整配置文件（在你给的 P2 头基础上：MCASAM + SPDConv + EMARes）

这个 YAML 做的事很“论文风”：

• 用 MCASAM 替换 C2PSA（论文说替换第10层） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• 用 SPDConv 替换 PAN 的两个下采样 Conv（对齐论文“替换第17、20层 Conv 为 SPD-Conv”的做法，只不过你网络层号不同） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• EMA 先只放 P4_out 做轻量校正（最稳）

yaml
# Parameters
nc: 5
scales:
  n: [0.50, 0.25, 1024]
  s: [0.50, 0.50, 1024]
  m: [0.50, 1.00, 512]
  l: [1.00, 1.00, 512]
  x: [1.00, 1.50, 512]

# YOLO11n 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]]      # 2
  - [-1, 1, Conv,   [256, 3, 2]]             # 3-P3/8
  - [-1, 2, C3k2,   [512, False, 0.25]]      # 4
  - [-1, 1, Conv,   [512, 3, 2]]             # 5-P4/16
  - [-1, 2, C3k2,   [512, True]]             # 6
  - [-1, 1, Conv,   [1024, 3, 2]]            # 7-P5/32
  - [-1, 2, C3k2,   [1024, True]]            # 8
  - [-1, 1, SPPF,   [1024, 5]]               # 9
  - [-1, 1, MCASAM, [1024]]                  # 10  ✅ 用 MCASAM 替换 C2PSA

# YOLO11n head (P2/4 - P5/32)
head:
  # -------- top-down FPN --------
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]      # 11: P5 -> P4
  - [[-1, 6], 1, Concat, [1]]                       # 12: cat backbone P4 (layer 6)
  - [-1, 2, C3k2, [512, False]]                     # 13: P4_td

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]      # 14: P4 -> P3
  - [[-1, 4], 1, Concat, [1]]                       # 15: cat backbone P3 (layer 4)
  - [-1, 2, C3k2, [256, False]]                     # 16: P3_td

  # -------- add P2 detection layer --------
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]      # 17: P3 -> P2
  - [[-1, 2], 1, Concat, [1]]                       # 18: cat backbone P2 (layer 2)
  - [-1, 2, C3k2, [128, False]]                     # 19: P2_out (P2/4)

  # -------- bottom-up PAN --------
  - [-1, 1, Conv, [256, 3, 2]]                      # 20: P2 -> P3（先不动，最敏感）
  - [[-1, 16], 1, Concat, [1]]                      # 21: cat P3_td
  - [-1, 2, C3k2, [256, False]]                     # 22: P3_out (P3/8)

  - [-1, 1, SPDConv, [512, 3, 2]]                   # 23: ✅ 用 SPDConv 替换 P3->P4 下采样Conv
  - [[-1, 13], 1, Concat, [1]]                      # 24: cat P4_td
  - [-1, 2, C3k2, [512, False]]                     # 25: P4_out (P4/16)
  - [-1, 1, EMARes, [16]]                           # 26: ✅ EMA 残差校正（factor=16），先只放这一处

  - [-1, 1, SPDConv, [1024, 3, 2]]                  # 27: ✅ 用 SPDConv 替换 P4->P5 下采样Conv
  - [[-1, 10], 1, Concat, [1]]                      # 28: cat backbone P5 (layer 10)
  - [-1, 2, C3k2, [1024, True]]                     # 29: P5_out (P5/32)

  # -------- Detect (4 heads) --------
  - [[19, 22, 26, 29], 1, DetectLSDECD, [nc, 16, 16]]  # 30: Detect(P2,P3,P4,P5)

---

4) 你问的“为什么原文有时写替换两次，最后只用一次？”——一句话总结

• 写“两次”是两层含义： （1）MCASAM 内部把 CBAM 的通道注意换成 MSCA；（2）网络层面用 MCASAM 替换 C2PSA。实现时你只要在网络里放一次 MCASAM，就同时完成两件事 (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)。
• 写“替换很多层”，实现却只替换几层： 论文也明确只替换关键位置（例如 neck 的两层 Conv 用 SPD-Conv 替换） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)，这是为了平衡计算量与精度。

---

如果你接下来要更严格“1:1 复现论文”，我建议你再补一版：把 C3k2 的某几处替换为 RepBlock（论文在 backbone+neck 都替换了多个 C3k2） (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)。你把论文里“替换了哪些层（对应你 YAML 的哪些层）”告诉我，我可以继续把 RepBlock 的插入位置也给你对齐成一份最终可跑 YAML。

你这个报错的根因很明确：Ultralytics 的 parse_model() 会自动把上一层通道 c1 作为第一个参数传进模块，然后把 YAML 里的 args 依次当作后续参数。
所以你在 YAML 里写：

yaml
- [-1, 1, EMARes, [16]]

实际构造会变成：

python
EMARes(c1=512, c2=16, factor=16)   # 16 被当成了 c2，而不是 factor

于是触发 assert c1 == c2（或后续通道推断变成 16 导致 conv.py 断言报错）。

---

✅ 最推荐的修复方式（不改 Ultralytics 核心解析器）

1) EMARes 保持 “(c1, c2, …)” 这种 YOLO 风格签名

（这样 parse_model 才能正确推断输出通道数）

把你的 EMARes 改成下面这样（允许 c2 省略但YAML 仍建议显式写 c2）：

python
class EMARes(nn.Module):
    """
    YOLO parse_model 友好版：
    - args 写法推荐：[c2, factor]
    - 例如：EMARes, [512, 16]
    """
    def __init__(self, c1, c2=None, factor=16):
        super().__init__()
        c2 = c1 if c2 is None else c2
        assert c1 == c2, f"EMARes expects same in/out channels, got c1={c1}, c2={c2}"
        self.attn = EMA(c1, factor=factor)
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        y = self.attn(x)
        return x + self.gamma * (y - x)

2) YAML 里把 EMARes 的 args 改成 [通道数, factor]

你 P4_out 是 512 通道，所以改成：

yaml
- [-1, 1, EMARes, [512, 16]]

---

✅ 你要的“完整可跑代码 + 完整配置文件”（按论文思路：MCASAM替换C2PSA + SPDConv替换两处下采样 + EMARes放P4_out）

论文这段逻辑非常清楚：

• SPD-Conv = SPD + stride=1 的非步长卷积 NSConv，强调避免 stride>1 的非判别信息损失 (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• MCASAM 用于替换 C2PSA，并且在 CBAM 框架中用 MSCA 替换通道注意，同时保留空间注意定位优势 (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf) (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• 论文也明确“neck 两处 Conv 用 SPD-Conv 替换，backbone 第10层 C2PSA 用 MCASAM 替换” (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)

---

A) 完整代码（建议保存为 ultralytics/nn/modules/rsm_blocks.py）

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

from ultralytics.nn.modules import Conv


# --------------------------
# SPD + SPDConv (论文式：SPD + stride=1 conv)
# --------------------------
class SPD(nn.Module):
    def __init__(self, scale=2):
        super().__init__()
        assert scale >= 2 and int(scale) == scale
        self.scale = int(scale)

    def forward(self, x):
        b, c, h, w = x.shape
        s = self.scale
        pad_h = (s - h % s) % s
        pad_w = (s - w % s) % s
        if pad_h or pad_w:
            x = F.pad(x, (0, pad_w, 0, pad_h))
            b, c, h, w = x.shape

        x = x.view(b, c, h // s, s, w // s, s)
        x = x.permute(0, 1, 3, 5, 2, 4).contiguous()
        return x.view(b, c * s * s, h // s, w // s)


class SPDConv(nn.Module):
    """
    YAML args: [c2, k, s]
    实际调用：SPDConv(c1, c2, k, s)
    """
    def __init__(self, c1, c2, k=3, s=2, act=True):
        super().__init__()
        assert s == 2, "先按论文常用 scale=2，稳定后再扩展"
        self.spd = SPD(scale=s)
        self.conv = Conv(c1 * s * s, c2, k, 1, act=act)  # stride=1

    def forward(self, x):
        return self.conv(self.spd(x))


# --------------------------
# MSCA (论文描述的多分支条带卷积)
# --------------------------
class MSCA(nn.Module):
    def __init__(self, c):
        super().__init__()
        self.dw5 = nn.Conv2d(c, c, 5, padding=2, groups=c, bias=False)

        self.b7_1  = nn.Conv2d(c, c, (1, 7),  padding=(0, 3), groups=c, bias=False)
        self.b7_2  = nn.Conv2d(c, c, (7, 1),  padding=(3, 0), groups=c, bias=False)

        self.b11_1 = nn.Conv2d(c, c, (1, 11), padding=(0, 5), groups=c, bias=False)
        self.b11_2 = nn.Conv2d(c, c, (11, 1), padding=(5, 0), groups=c, bias=False)

        self.b21_1 = nn.Conv2d(c, c, (1, 21), padding=(0, 10), groups=c, bias=False)
        self.b21_2 = nn.Conv2d(c, c, (21, 1), padding=(10, 0), groups=c, bias=False)

        self.mix = nn.Conv2d(c, c, 1, bias=False)

    def forward(self, x):
        u = x
        f = self.dw5(x)
        f7  = self.b7_2(self.b7_1(f))
        f11 = self.b11_2(self.b11_1(f))
        f21 = self.b21_2(self.b21_1(f))
        attn = self.mix(f + f7 + f11 + f21)
        return u * attn


# --------------------------
# CBAM Spatial Attention (SA)
# --------------------------
class SpatialAttn(nn.Module):
    def __init__(self, k=7):
        super().__init__()
        self.conv = nn.Conv2d(2, 1, k, padding=k // 2, bias=False)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        avg = torch.mean(x, dim=1, keepdim=True)
        mx, _ = torch.max(x, dim=1, keepdim=True)
        a = torch.cat([avg, mx], dim=1)
        return self.sigmoid(self.conv(a))


# --------------------------
# MCASAM：CBAM骨架下，用MSCA替换通道注意 + 保留空间注意
# --------------------------
class MCASAM(nn.Module):
    """
    YAML args: [c2] 或 [c2, sa_kernel]
    建议用于替换 C2PSA（论文做法）
    """
    def __init__(self, c1, c2=None, sa_kernel=7):
        super().__init__()
        c2 = c1 if c2 is None else c2
        assert c1 == c2
        self.msca = MSCA(c1)
        self.sa = SpatialAttn(k=sa_kernel)
        self.gamma = nn.Parameter(torch.zeros(1))  # 从0开始，减少模块叠加冲突

    def forward(self, x):
        y = self.msca(x)
        y = y * self.sa(y)
        return x + self.gamma * (y - x)


# --------------------------
# EMA + Residual Gate
# --------------------------
class EMA(nn.Module):
    def __init__(self, channels, factor=16):
        super().__init__()
        g = min(factor, channels)
        while g > 1 and channels % g != 0:
            g //= 2
        self.groups = max(g, 1)

        self.softmax = nn.Softmax(-1)
        self.agp = nn.AdaptiveAvgPool2d((1, 1))
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))

        cpg = channels // self.groups
        self.gn = nn.GroupNorm(cpg, cpg)
        self.conv1x1 = nn.Conv2d(cpg, cpg, 1, 1, 0)
        self.conv3x3 = nn.Conv2d(cpg, cpg, 3, 1, 1)

    def forward(self, x):
        b, c, h, w = x.size()
        g = self.groups
        group_x = x.reshape(b * g, -1, h, w)

        x_h = self.pool_h(group_x)
        x_w = self.pool_w(group_x).permute(0, 1, 3, 2)

        hw = self.conv1x1(torch.cat([x_h, x_w], dim=2))
        x_h, x_w = torch.split(hw, [h, w], dim=2)

        x1 = self.gn(group_x * x_h.sigmoid() * x_w.permute(0, 1, 3, 2).sigmoid())
        x2 = self.conv3x3(group_x)

        x11 = self.softmax(self.agp(x1).reshape(b * g, -1, 1).permute(0, 2, 1))
        x12 = x2.reshape(b * g, -1, h * w)
        x21 = self.softmax(self.agp(x2).reshape(b * g, -1, 1).permute(0, 2, 1))
        x22 = x1.reshape(b * g, -1, h * w)

        weights = (torch.matmul(x11, x12) + torch.matmul(x21, x22)).reshape(b * g, 1, h, w)
        return (group_x * weights.sigmoid()).reshape(b, c, h, w)


class EMARes(nn.Module):
    """
    ✅ parse_model 友好版：args 推荐写 [c2, factor]
    """
    def __init__(self, c1, c2=None, factor=16):
        super().__init__()
        c2 = c1 if c2 is None else c2
        assert c1 == c2, f"EMARes expects same in/out channels, got c1={c1}, c2={c2}"
        self.attn = EMA(c1, factor=factor)
        self.gamma = nn.Parameter(torch.zeros(1))

    def forward(self, x):
        y = self.attn(x)
        return x + self.gamma * (y - x)

---

B) 注册模块（必须做，否则 YAML 找不到类）

任选一种方式（看你工程结构）：

方式1：在 ultralytics/nn/modules/__init__.py 加：

python
from .rsm_blocks import SPDConv, MCASAM, EMARes

方式2：在 ultralytics/nn/tasks.py（parse_model 所在文件）顶部确保导入：

python
from ultralytics.nn.modules.rsm_blocks import SPDConv, MCASAM, EMARes

---

C) 完整 YAML（修正 EMARes 参数传递，避免报错）

注意：EMARes 那行改为 [512, 16]，这就是你报错的关键修复点。

yaml
# Parameters
nc: 5
scales:
  n: [0.50, 0.25, 1024]
  s: [0.50, 0.50, 1024]
  m: [0.50, 1.00, 512]
  l: [1.00, 1.00, 512]
  x: [1.00, 1.50, 512]

backbone:
  - [-1, 1, Conv,   [64, 3, 2]]
  - [-1, 1, Conv,   [128, 3, 2]]
  - [-1, 2, C3k2,   [256, False, 0.25]]
  - [-1, 1, Conv,   [256, 3, 2]]
  - [-1, 2, C3k2,   [512, False, 0.25]]
  - [-1, 1, Conv,   [512, 3, 2]]
  - [-1, 2, C3k2,   [512, True]]
  - [-1, 1, Conv,   [1024, 3, 2]]
  - [-1, 2, C3k2,   [1024, True]]
  - [-1, 1, SPPF,   [1024, 5]]
  - [-1, 1, MCASAM, [1024]]     # ✅ 替换 C2PSA（论文做法）

head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]]
  - [-1, 2, C3k2, [512, False]]

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]]
  - [-1, 2, C3k2, [256, False]]

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 2], 1, Concat, [1]]
  - [-1, 2, C3k2, [128, False]]   # P2_out

  - [-1, 1, Conv, [256, 3, 2]]    # P2->P3（先不动）
  - [[-1, 16], 1, Concat, [1]]
  - [-1, 2, C3k2, [256, False]]   # P3_out

  - [-1, 1, SPDConv, [512, 3, 2]] # ✅ P3->P4 用 SPDConv
  - [[-1, 13], 1, Concat, [1]]
  - [-1, 2, C3k2, [512, False]]   # P4_out
  - [-1, 1, EMARes, [512, 16]]    # ✅ 关键修复：显式写 c2=512, factor=16

  - [-1, 1, SPDConv, [1024, 3, 2]]# ✅ P4->P5 用 SPDConv
  - [[-1, 10], 1, Concat, [1]]
  - [-1, 2, C3k2, [1024, True]]   # P5_out

  - [[19, 22, 26, 29], 1, DetectLSDECD, [nc, 16, 16]]

---

你问的两个概念问题（再总结一遍）

1）论文里的 CBAM 在哪？

在 MCASAM 模块章节里，论文先介绍 CBAM 是“通道注意 + 空间注意”的双注意结构 (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)，然后说明 MCASAM 用 MSCA 替换 CBAM 的通道注意并保留空间定位优势 (RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)。

2）为什么“原文写替换两次，最后只用一次”？

典型就是这种“两层替换”：

• 模块内部替换：CBAM 的通道注意 → MSCA（得到 MCASAM）(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
• 网络层替换：用 MCASAM 替换 YOLOv11 的 C2PSA（第10层）(RSM-YOLOv11_Lightweight_Steel_Surface_Defect_Segmentation_Algorithm_Research_Based_on_YOLOv11_Improvement.pdf)
  实现时你只在网络里“放一次 MCASAM”，它内部已经完成了第一层替换。

---

如果你按上面改完还有报错，把你 最新的 test.yaml 和 Ultralytics 版本号 / tasks.py 里 parse_model 的那段 channel 推断逻辑贴一小段出来（不用全贴），我可以把“为什么 parse_model 推断到了错误通道”也给你一并彻底对齐。