我现在想做基于激光点云的目标检测算法，目前算法检测结果如下，我的场景是悬挂式单轨交通，主要是小目标检...

Question

我现在想做基于激光点云的目标检测算法，目前算法检测结果如下，我的场景是悬挂式单轨交通，主要是小目标检测和不规则结果，请根据我的场景特点和算法检测结果，选择一个可行的算法检测方案，要确保检测精度和结果以及FPS的综合最优，我目前的方案是想基于体素取进行检测，请选择一个比较好改的算法，考虑主流改进的基础模型去进行改进，我的雷达是揽沃tele-15，，点云范围在算法里X轴[0，160]m，Y轴（横向）[-20，+20]m，Z轴（垂向）[-2，6]m，本文将体素网格尺寸设定为[0.1，0.1，0.2]m，实时性要求在不要很差劲即可，我现在的是OpenPCDet，我是用是3090的24G的GPU，同时要确保可以参考的改进的的中英文文章很多，要不我从哪里知道怎么改，改哪些内容呢，我有个其他类似模型或者模块的更改依据也更快实现，比如基于体素的改进或者基于PILLAR，以及其他，比如基于点的检测方法有哪些可以拿来用的开源算法或者论文呢，类似这样，理解吗

Answer 1

先把结论说前面：
我建议你在 OpenPCDet 里以 Voxel R‑CNN 做主干，做一个“长距 + 小目标 + 不规则目标”定制版本。
理由是：它本身就是纯体素（符合你“基于体素”的想法）、两阶段结构对小目标友好、在 2080Ti 上能做到 ~25FPS 级别 (arXiv)，3090 再加上你横向范围只有 ±20m，速度基本不会拉跨，而且最近还有很多基于 Voxel R‑CNN 的改进论文（含中文解读），可抄/可改的东西很多 (MDPI)。

下面我分三块说：

为什么是 Voxel R‑CNN（而不是 PV‑RCNN++/CenterPoint 等）
结合你 Tele‑15 单轨场景的具体检测方案与改法
按“体素 / PILLAR / 点”给你列一个可参考的开源算法 & 论文清单

1. 为什么推荐 Voxel R‑CNN 做你的主干

1.1 性能 & FPS 综合比较适合你

Voxel R‑CNN：
- 结构：Sparse 3D CNN（体素主干） + BEV RPN + RoI 3D 细化头。
- 原文在 KITTI/Waymo 上，RTX 2080Ti 上约 25 FPS，仍保持接近 SOTA 精度 (arXiv)。
- 你的 GPU 是 3090，检测范围 X:0–160, Y:-20~20，比 Waymo 常用 150×75 矩形还窄一半左右，计算量不会比论文里更糟。
PV‑RCNN++：
- 混合点 + 体素，更准，但结构复杂，对工程改动和调参成本更高。
- Waymo 上 150m×150m 范围，2080Ti 上约 10 FPS 左右 (arXiv)。
- 若你后面追求极致精度，可以作为“第二阶段升级目标”，但初版不建议从它起步。
CenterPoint（voxel 版）：
- 单阶段 anchor‑free，工程化很舒服，文献很多 (Tianwei Yin)。
- 对“车、人、自行车”这类规则目标特别好，但你说“不规则目标+小目标”较多，用两阶段的 Voxel R‑CNN 会更稳一点（RoI 细化对小物体几何更友好）。

综合考虑：

你要的是“体素 + 精度要好 + FPS 不要太惨 + 容易在 OpenPCDet 改”
这几个维度 Voxel R‑CNN 是一个非常均衡的选择，而且就是 OpenPCDet 的官方实现之一 (GitHub)。

1.2 文献 & 改进资源非常多（中英文都有）

原始 Voxel R‑CNN 论文 + 官方代码 (arXiv)
2025 年有直接以 Voxel‑RCNN 为基线，融合残差 + 级联注意力的改进工作（RCAVoxel‑RCNN），专门就是解决：
- RPN 提案质量不高
- 小目标在深层卷积里特征被抹掉
  提出 3D 残差网络 + 级联注意力网络（CAN/RAN）提升小物体检测 (MDPI)。

这类 MDPI/Sensors、国内硕博论文对结构拆得很细，对你“照着改”的需求很友好。

2. 结合你 Tele‑15 单轨场景的 Voxel R‑CNN 方案

下面我按工程实现的顺序来讲：数据表示 → 主干网络 → 小目标/不规则目标增强 → 训练技巧。

2.1 点云 & 体素化设计（结合 Tele‑15）

你给的参数：

LiDAR：Livox Tele‑15（长距、高精度、非重复扫描） (Livox)
有效范围：
- X: [0, 160] m
- Y: [-20, 20] m
- Z: [-2, 6] m
体素大小： $0.1, 0.1, 0.2$ m（xyz）

先算一下栅格规模（理论）：

Nx = 160 / 0.1 = 1600
Ny = 40 / 0.1 = 400
Nz = 8 / 0.2 = 40
→ 理论体素数 = 1600 × 400 × 40 ≈ 25.6M（但你用的是稀疏体素，真正在 GPU 上的是“非空体素数”，会小得多）

建议的体素配置（OpenPCDet 式）

x/y 方向保持 0.1
- 你场景是悬挂单轨，轨道位置是强先验，车体、挂架、障碍物等尺寸不算特别大，小目标（比如掉落物、悬吊物）用 0.1 m 的分辨率是合理的。
z 可以稍微粗一点（0.2–0.25）
- 把 z 分辨率略放粗（0.25 m）可以减一点体素数，对 Tele‑15 的 15°×15°窄 FoV 来说问题不大 (Survey Equipments USA)。
设置合理的 max_num_voxels / max_points_per_voxel：
- 例如：
  - max_num_voxels：训练 200k / 测试 160k（参考 Waymo 配置微调）
  - max_points_per_voxel：10–20
- 防止 Tele‑15 在近距离高密度区域撑爆显存。
可选：分区体素化（近区密、远区粗）
- 0–60 m：0.08 × 0.08 × 0.2
- 60–160 m：0.16 × 0.16 × 0.3
- 在 OpenPCDet 里可以通过写一个“多尺度 voxel generator”（不同 x 范围分开 voxel layer）拼接 BEV 特征。
- 这样能兼顾近场高精度和远处小目标的 FPS。
考虑 Tele‑15 的非重复扫描特性
- Tele‑15 0.1s 内的点云密度已接近 128 线机械雷达 (Livox Wiki)。
- 若你需要稳定小目标，可以适当 时间融合 2–3 帧（0.2–0.3s 滑动窗口）再丢给检测器，但这会多一倍输入点数，要看 FPS 预算。

2.2 主网络结构：基于 Voxel R‑CNN 的整体架构

在 OpenPCDet 里，你可以：

直接复制 Voxel R‑CNN 的 Waymo/KITTI 配置 当模板（voxel_rcnn_xxx.yaml 之类，实际名字看你本地 repo）(GitHub)
将 dataset 部分替换成你自己的 Livox/单轨数据集，保持 model 部分基本不变，先训起来。

结构大致是：

Voxel Feature Encoder（VFE，体素编码）
- 输入：体素内的 (x, y, z, intensity, timestamp/echo 等)
- 先做 per‑point MLP，再池化成每个 voxel 一个特征向量。
3D Sparse CNN Backbone
- 通常是 SparseConv UNet：下采样 3–4 层、再上采样，得到体素特征。
- 你可以把最深层的通道数稍微增大一点，用来弥补小目标信息不足。
BEV 投影 + 2D RPN
- 把 3D 体素特征投影到 BEV，形成 H×W×C 的 pseudo image。
- 2D CNN 做 RPN，输出 3D proposals（包含 x,y,z,w,l,h,θ）。
3D RoI 特征池化 + RoI Head
- 根据 proposals 在 3D voxel feature 上做 RoI pooling，再用几层卷积/FC 做分类+回归细化。

2.3 专门针对“小目标 + 不规则目标”的改法

2.3.1 BEV 多尺度 FPN，加密近轨道区域

问题：小目标在 BEV 上往往只占几个像素，很容易被 stride=8/4 的 backbone 抹掉。

改法：

在 BEV backbone 上加一个简单的 FPN：
- 例如保留 stride=2,4 的两个尺度，做 top‑down 融合（C3 + up(C4) → P3；C4 → P4），再将 P3/P4 拼接或相加给 RPN。
- 可以直接参考 2D 检测里 FPN 的写法照搬。
对 靠近轨道中心的区域（Y≈0 附近）在 BEV 上拉高分辨率：
- 做一层“带权采样”：对 |Y|<5m 这条“走廊”切片，使用 stride=2 的高分辨率特征，其余区域可用 stride=4 的特征。
参考文献：
- RCAVoxel‑RCNN 里就有通过改 backbone 深度 + 注意力机制提升小目标表现的思路，可以抄它的残差/注意力 block 到你的 FPN/3D backbone 中 (MDPI)。

2.3.2 针对不规则目标：增强 RoI 内部几何建模

很多悬挂构件、异形障碍物的外形与常规 cuboid 差异大，单纯 box 回归不好拟合。

可以这样做：

RoI 内点云再次采样 + 小型 PointNet/Transformer：
- 在每个 RoI 内取 N 点（比如 256），做一个轻量级 PointNet (MLP + max pool) 或者 2–3 层 self‑attention，把结果拼到 RoI 特征上。
- 这相当于借鉴了 PV‑RCNN 的“Voxel→Keypoint→RoI”思想，但规模小很多 (CVF Open Access)。
使用更灵活的回归参数
- 如果你的不规则目标在 Z 方向高度变化大，可以考虑：
  - 预测 bottom‑center + h 之外，再加个 “上表面 offset”；
  - 或者只在 Yaw 上用旋转框，对高度/长度给更宽的容忍度（损失里降低高度误差权重）。
可参考：
- PV‑RCNN 系列对 RoI 内点建模的做法（Voxel‑to‑Keypoint, Keypoint‑to‑Grid） (CVF Open Access)。

2.3.3 小目标 / 远距离目标的正负样本与 loss

Tele‑15 最大可测到 500m；你当前只用到 160m，其实还是属于“中远距场景” (Livox)，远处的小目标特别容易训练不起来。

建议：

距离分段的采样策略
- 按距离将 GT 和 proposals 分层，如：0–40m / 40–80m / 80–160m。
- 在 RPN 和 RoI Head 的采样中，对远距离段适当提高正样本/难样本比例。
IoU‑balanced / Focal Loss
- RPN 分类可以改为 focal loss，减轻易分类大目标的主导作用。
- 回归损失可加入 IoU‑based term（如 GIoU/CIoU 变体），提升远距框的几何稳定性。
数据增强：scale jitter + 随机插点 (copy‑paste/GT sampling)
- 可借鉴 Waymo/nuScenes 上的 GT sampling 策略，把小目标在 BEV 上 copy‑paste 到不同距离/轨道位置，提高小目标样本量 (arXiv)。

2.4 训练上的工程建议

先减范围训一个“小实验版”
- 例如先训 X:[0,80]，排查标注/坐标系/类别定义没问题，再扩到 160m。
针对 Tele‑15 做专门的归一化与过滤
- 过滤极近距离（<2m）或极稀疏的点，防止把噪声当小目标。
- intensity 通道稳定性较好，可以加一维“回波序号/时间戳”进去。
3090 显存 24G
- 完全可以跑 batch_size=4~8 的大 batch，对于 BN/SyncBN 很友好。
- 用混合精度（FP16），OpenPCDet 已经支持，可以大幅提升 FPS。

3. 你可以参考的主流基线 & 改进论文（按表示方式划分）

你说“想知道体素 / PILLAR / 点基线有哪些可以拿来改”，我给你按类别列个清单（都是有开源或易找 pdf 的）。

3.1 体素（Voxel‑based）

强烈推荐你重点看的：

Voxel R‑CNN（推荐基线）
- Voxel R‑CNN: Towards High Performance Voxel-based 3D Object Detection (arXiv)
- 官方代码（基于 OpenPCDet）：GitHub: djiajunustc/Voxel-R-CNN (GitHub)
- 改进：RCAVoxel‑RCNN（残差 + 级联注意力，提升小目标）(MDPI)
PV‑RCNN / PV‑RCNN++
- PV‑RCNN: Point-Voxel Feature Set Abstraction for 3D Object Detection (CVF Open Access)
- PV‑RCNN++: semantical point‑voxel feature interaction for 3D object detection（加语义分割、向量池化，Waymo 上 150m×150m 范围 10FPS 左右）(arXiv)
- 这些可以作为你增强 RoI 内点特征的参考。
CenterPoint（voxel 版本）
- Center-based 3D Object Detection and Tracking（CVPR 2021）(Tianwei Yin)
- GitHub: tianweiy/CenterPoint；还有 TensorRT/ROS2 部署版以及针对 Livox 的 fork (GitHub)。
- Livox 官方的 livox_detection 也是 anchor‑free 思路，支持多种 Livox 点云模式，前向 200m×89.6m 约 45ms/帧（2080Ti）(GitHub)。你可以借它的 数据预处理与 anchor‑free 头 思路。
最新一些 voxel + Transformer / GNN 的工作（可当模块参考）
- VoxT‑GNN：融合 Transformer 和 GNN，专门强调对小目标的处理 (ScienceDirect)。
- HP‑PV‑RCNN：用 Mamba 优化 PV‑RCNN 的 3D backbone，兼顾速度和精度 (ScienceDirect)。

3.2 PILLAR（PointPillars 及其改进）

如果你后面需要一个更轻量的“实时型版本”，可以再搞一条 Pillar 分支：

PointPillars（经典 pillar 基线）
- 原论文：PointPillars: Fast Encoders for Object Detection from Point Clouds（CVPR 2019）(MathWorks)。
- 思路：把点云划分为一根根“立柱”，在 BEV 上做 2D 卷积，非常快。
PillarNeXt（CVPR 2023）
- 重新审视 pillar 型检测器，发现“最简单的 pillar 模型 + 合理网络设计”在精度和延迟上都很优秀 (CVF Open Access)。
- 适合作为你如果要写一篇“轻量级单轨检测”的对比基线。
针对小目标的 PointPillars 改进
- Improved 3D Object Detection Based on PointPillars：以 PointPillars 为基线，引入 Transformer 和新的注意力机制提升小目标检测 (MDPI)。
- PEPillar：point-enhanced pillar network，融合点特征和 pillar 特征，两者兼得 (Springer Link)。
- PillarFocusNet：通过“关键柱子关注+感知扩散”机制提升性能，对小/被遮挡目标有帮助 (Nature)。

这些论文大多有中文解读或二次引用，很适合你抄思路到 voxel backbone / BEV FPN 中。

3.3 点（Point‑based）

如果你要专门处理 特别不规则、有明显表面细节 的目标，可以考虑在 RoI 内嵌入点级别网络，以下是典型基线：

PointRCNN
- 直接在 raw point 上做两阶段检测：前景分割 + proposal + refinement (arXiv)。
- GitHub: sshaoshuai/PointRCNN。
- 不建议你直接整套搬过去做主干（对 Tele‑15 这类长距稀疏区域会比较吃力），但它的 RoI 坐标变换、前景分割等模块可以抄到 RoI 内 refinement。
3DSSD
- 轻量级单阶段点云检测器，去掉了耗时的 upsampling 和 refinement，FPS 很高 (arXiv)。
- GitHub: dvlab-research/3DSSD (GitHub)。
Point‑GNN
- 将点云构成近邻图，用 GNN 做检测，精度很高，但工程复杂度也不小 (CVF Open Access)。

这些更多是“给你灵感”：
你完全可以只在 Voxel R‑CNN 的 RoI Head 里嵌入一个 小号 PointNet/3DSSD‑style 模块，而不是重写整个 pipeline。

3.4 总览/综述类资料（看全局结构 & 常见 trick）

方便你快速找到“还能改啥”的两类综述：

A Survey on Deep-Learning-Based LiDAR 3D Object Detection (MDPI)
A Survey of Robust LiDAR-based 3D Object Detection Methods（ITSC 2022）(arXiv)

里面会系统总结：数据增强、loss、采样策略、注意力、Transformer 等常见改进点，你可以对照 Voxel R‑CNN 的每个模块想“我能在哪一层加点料”。

4. 你可以实际动手的一个“改法路线图”（总结一下）

给你一个可落地的步骤建议，不用一次全上：

阶段 1：跑通基线
- 基于 OpenPCDet 的 Voxel R‑CNN，按你给的 XYZ 范围 & 体素大小改好 dataset & voxel cfg，先在 0–80m 上训到收敛。
阶段 2：小目标增强
- 在 BEV backbone 上加 FPN + 高分辨率近轨道走廊。
- 对 RPN/ROI 的正负样本做距离分层采样。
- 引入 IoU/Focal Loss、GT sampling 扩充小目标。
阶段 3：不规则目标增强
- 在 RoI Head 里增加一个基于 RoI 内点的 PointNet/轻量级 Transformer。
- 参考 PV‑RCNN/PV‑RCNN++ 的 keypoint 抽样和 RoI Grid Pooling 结构。
阶段 4：考虑实时性 & 工程化
- 测试当前 FPS，不够的话：
  - 适度加大远区体素尺寸；
  - 调整稀疏卷积通道数；
  - 如果需要再做一个 PointPillars/PillarNeXt 轻量版本作为“实时备份方案”。

如果你后面愿意，把你现在的 OpenPCDet 配置（yaml）贴一份，我可以直接帮你改一版“Voxel R‑CNN for Tele‑15 单轨小目标”的具体参数（包括 voxel cfg、anchor 尺寸、FPN 通道等），这样你可以直接对照着在工程里实现。

Answer 2

那我就按你现在的条件，直接给一个**“单阶段 + 体素化 + 好改 + 文献多”**的路线。

一句话先定基线

推荐基础模型：OpenPCDet 里的 CenterPoint (voxel 版本) 单阶段检测器

它本质是：体素编码 + 稀疏 3D backbone + BEV neck + CenterHead 单阶段中心点检测头。(GitHub)
OpenPCDet 已经有现成的配置 cbgs_voxel0075_res3d_centerpoint.yaml，是 voxel 模型，改你自己的点云范围和体素大小就能跑。(GitHub)
CenterPoint 原始论文本身就是单阶段中心点 head +（可选）第二阶段 refinement，你完全可以只用第一阶段，当做“单阶段检测”用。(CVF Open Access)
围绕 CenterPoint / voxel 单阶段的改进论文非常多（CenterPoint‑SAE、VSAC、各种 Transformer / IoU-aware 版本），中文资料也多，方便你参考和“抄作业”。(ScienceDirect)

下面分三块说：

为什么选 CenterPoint(voxel) 做你的单阶段体素基线
结合 Tele‑15 悬挂单轨场景，CenterPoint 大概怎么配
“大家体素化都在改什么”——列出典型改进点 + 对应算法来源

1. 为什么选 CenterPoint(voxel) 做单阶段体素基线

1.1 模型属性：完全符合你提的三个关键点

单阶段：
- 主检测头是一个 BEV 上的 CenterHead，直接预测中心热力图 + 尺寸 + 方向 + 速度，没有 RPN/RoI 这些二阶段结构。(CVF Open Access)
体素化：
- 在 OpenPCDet 的 voxel 版本里，是 transform_points_to_voxels + VoxelResBackBone8x + HeightCompression → 真·稀疏 3D 体素 backbone。(GitHub)
OpenPCDet 里已有实现：
- 官方在 nuScenes 已经支持 CenterPoint voxel 模型，你只要把 POINT_CLOUD_RANGE 和 VOXEL_SIZE 换成你的，就能直接训练。(Gitee)

相比其它单阶段体素化模型：

CIA‑SSD：也是典型单阶段体素检测，用 SPConvNet + IoU‑aware 头，在 KITTI 上速度/精度都很强，但官方代码不是基于 OpenPCDet，迁移成本稍大。(GitHub)
VoxelNeXt / FSD / Voxel Transformer 系：更前沿、结构更复杂，调参和工程代价明显更大；你现在是要先把 Tele‑15 单轨场景跑顺，再慢慢加料。(CVF Open Access)

综合下来，CenterPoint(voxel) = 工程门槛低 + 文献最多 + 可扩展改法一大堆，非常适合做你这条线的“母模型”。

2. 结合 Tele‑15 单轨场景的 CenterPoint(voxel) 配置思路

2.1 点云范围 & 体素设置（按你给的参数）

你给的是：

X: [0, 160] m
Y: [-20, 20] m
Z: [-2, 6] m
体素：[0.1, 0.1, 0.2] m

在 OpenPCDet 里，大致这样改（伪配置示意）：

yaml
DATA_CONFIG:
  POINT_CLOUD_RANGE: [0.0, -20.0, -2.0, 160.0, 20.0, 6.0]

DATA_PROCESSOR:
  - NAME: transform_points_to_voxels
    VOXEL_SIZE: [0.1, 0.1, 0.2]
    MAX_NUMBER_OF_VOXELS: { 'train': 200000, 'test': 200000 }

MODEL:
  NAME: CenterPoint
  VFE:
    NAME: MeanVFE
  BACKBONE_3D:
    NAME: VoxelResBackBone8x
  MAP_TO_BEV:
    NAME: HeightCompression
  BACKBONE_2D:
    NAME: BaseBEVBackbone
  DENSE_HEAD:
    NAME: CenterHead
    # 其他 head 配置按 nuScenes 模型改

X/Y 方向 0.1m 分辨率 —— 适合你的小目标 + 跨轨道 40m 宽度；
Z 方向 0.2m，对 −2~6m 这种较窄高度来说足够；
MAX_NUMBER_OF_VOXELS 你用 3090，24G 显存，200k 左右问题不大，慢了再往下调。

2.2 单轨 + 小目标 + 不规则目标要注意的两点

小目标 / 远距离目标
- 使用 CenterHead 时，热力图 Gaussian 半径要适当减小，避免远距离小物体的中心响应被抹平；
- 可以实现“距离分层的目标采样”：如 0–40m / 40–80m / 80–160m 三段，对远距离段提高正样本占比，这是很多中心点/anchor‑free 模型上常见的 trick（不少文章提到长距 detection 要分段采样，这里不展开引用具体一篇综述）。(MDPI)
不规则目标
- Anchor‑free 的好处就是不太依赖预设长宽高，对形状怪的构件比较友好；
- RoI 这层你不打算用（二阶段），就可以更多地在 BEV neck 和 head 上做多尺度 + 上下文建模（下面第 3 部分会专门列）。

3. “大家在体素模型上都改什么？”——按模块拆 + 附典型论文

我按模块来讲，你可以把这些模块当作「可抄的积木」，往 CenterPoint 里塞。

3.1 体素表示层的改进点

3.1.1 密度感知 / 距离感知体素（解决长距离稀疏 & 小目标）

PDV：Point Density‑Aware Voxels（CVPR 2022）(arXiv)
- 来源：Point Density-Aware Voxels for LiDAR 3D Object Detection。
- 改进点：
  - 显式建模点密度与距离的关系，给每个体素一个 density feature；
  - RoI Pooling 时用 KDE + 自注意力，根据密度做加权；
  - 在 Waymo 上针对远距离目标有明显提升；
- 你可以怎么用在 CenterPoint 上：
  - 在 VFE 输入上加一维 “density” 通道：#points / 体素体积，或用论文里归一化公式；
  - 在 BEV neck 前增加一个“密度注意力模块”，对稀疏远距离体素适当放大权重，补强 80–160m 段的小目标。

3.1.2 体素筛选 / 体素净化（去掉大量背景体素，提速 + 减噪）

VPSNet：Voxel Purification & Selection Net（2024）(Springer Link)
- 来源：VPSNet: 3D object detection with voxel purification and fully sparse detection。
- 改进点：
  - 在全稀疏 voxel 框架里，用一个voxel feature refinement 模块选出“有价值体素”，抑制背景体素；
  - 一方面提速，一方面减少背景噪声带来的误检；
- 套在 CenterPoint 上：
  - 在 3D backbone 中间插一个 “voxel scoring + top‑k 保留” 模块，对明显在空中/地下/远离轨道的体素直接裁掉，既加速，也有利于你这种“细长轨道 + 空中背景很多”的场景。
Salient Voxel Enhancement / SVEFusion(ScienceDirect)
- 虽然原文是 LiDAR + 4D radar，多模态，但它的思路是“只保留显著体素”，你可以借鉴其显著性评分方式（比如与邻域对比度、时间一致性等）做纯 LiDAR 版筛选。

3.1.3 时序体素编码（连续帧融合，适用于 Tele‑15）

TM3DOD：Temporal Motion‑Aware 3D Object Detection（2024）(MDPI)
- 来源：LiDAR-Based 3D Temporal Object Detection via Motion-Aware LiDAR Feature Aggregation。
- 改进点：
  - 提出 Temporal Voxel Encoder (TVE)，对连续帧在体素层聚合，建模体素内部的时间关系；
  - 在 BEV 上生成 motion feature，与当前帧特征融合，提升动态目标检测；
- 你可以做的精简版本：
  - 把 Tele‑15 的 2–3 帧点云拼在一起，增加一个 TVE 类似的“时间注意力模块”，输出一个带时间特征的 voxel feature，再送给 CenterPoint backbone。

对于你这种悬挂单轨+车体运动轨迹规范的场景，时序信息很有价值，能帮助区分“轨道结构” vs “真正的障碍物”。

3.2 3D 体素 Backbone / 注意力的改进点

3.2.1 Voxel Self‑Attention / Transformer

VSAC：Voxel Self‑Attention and Center‑Point（iScience 2024）(Cell)
- 来源：Voxel self-attention and center-point for 3D object detector。
- 改进点：
  - 在体素 backbone 上加一个 Voxel Self‑Attention Network，显式建模体素间长距离关系；
  - 提出 PST‑FPN (Pseudo Spatiotemporal FPN)，融合多尺度 & 类时间信息；
  - 用的也是 CenterPoint 式的 center head，非常贴合你要的方向。
- 迁移到你的 CenterPoint 里：
  - 在 VoxelResBackBone8x 的中高层插入 VSAC 风格的 self‑attention block；
  - 把 BEV neck 换成 PST‑FPN 风格的多尺度 neck（后面 3.3 再展开）。
优化版 Voxel Transformer + CIA‑SSD（Optimized Voxel Transformer with CIA‑SSD）(ScienceDirect)
- 用 VoTr 作为体素 backbone，通过自注意力实现大范围 voxel 交互，同时借鉴 CIA‑SSD 的空间‑语义特征融合；
- 对应改进点是：用 Transformer 替代部分稀疏卷积，提升长距上下文建模能力，对远距离小目标比较友好。
VoxSeT / MsSVT++ / VoxT‑GNN 等
- VoxSeT：Voxel Set Transformer，通过 set‑to‑set 注意力做体素特征建模。(GitHub)
- MsSVT++：混合尺度稀疏 voxel Transformer + Center Voting 单阶段检测器，专门通过“投票中心体素”提升定位精度。(arXiv)
- VoxT‑GNN：把 Transformer + GNN 结合起来，针对小目标提出 region‑to‑region 的特征交互机制。(ScienceDirect)

这些论文你可以先看结构，把其中的小号 Transformer / GNN block 拿出来，替换/补充你现有 3D backbone 的某几层，不用整套全搬。

3.2.2 结构信息融合 / 结构注意力

SIF：Deep Structural Information Fusion for 3D Object Detection on LiDAR Data(ScienceDirect)
- 改进点：
  - 提出一个 Structural Information Fusion (SIF) 模块，从点云中提取“结构感知的体素特征”（例如边缘、平面等），作为 voxel-based 检测器的输入；
  - 这个模块比较轻量，能显著提升单阶段/多阶段体素 detector。
- 对你的意义：
  - 单轨悬挂系统中，轨道、立柱、车体本身都有很强的结构特征，引入结构注意力能帮助你区分“工程构件 vs 异常物体”。

3.3 BEV Neck / 多尺度特征的改进点

3.3.1 CenterPoint‑SAE：空间感知增强的 CenterPoint

CenterPoint‑SAE：Spatial Awareness Enhancement based single-stage anchor-free 3D detector(ScienceDirect)
- 来源：Spatial awareness enhancement based single-stage anchor-free 3D object detection for autonomous driving。
- 改进点：
  - 在 CenterPoint 的 backbone + neck 上，设计了带 GS‑Conv（ghost + shuffle） 的轻量卷积，用来增强空间感知；
  - 重新设计 FPN 风格的多尺度 neck，使得小目标（如行人/交通锥）在 BEV 上特征更明显；
  - 检测部分保持单阶段 CenterHead 形式，速度还能维持 ~11FPS 级别。
- 迁移方式：
  - 直接对照它的结构，把你的 BaseBEVBackbone 换成 SAE 的 neck（卷积 block & 上采样结构）。

3.3.2 PST‑FPN：伪时空特征金字塔（VSAC）

来自 VSAC 里的 Pseudo Spatiotemporal FPN (PST‑FPN)：在 BEV 上同时考虑多个尺度 + 类时间通道，用 FPN 式结构融合。(ScienceDirect)
对你的场景，PST‑FPN 有两点价值：
1. 多尺度 = 有利于小目标（比如悬挂构件、落物）；
2. 时序通道 = Tele‑15 连续扫描时，能够把轨道/车体的稳定结构强化出来，突出“新出现的小障碍”。

3.3.3 Region‑aligned 单阶段体素检测

Region‑aligned Single-Stage Point Cloud Object Detector（2025）(Springer Link)
- 指出：现有 voxel 单阶段 detector 通常要做一次 Sparse → Dense 高度压缩（Height Compression） 到 BEV，这会破坏高度结构；
- 提出一种“region‑aligned”的特征压缩 + cross‑semantic attention，让 3D 体素特征在压到 BEV 时保持更合理的对齐。
对你来说：Z 范围本来就小（−2~6m），如果把高度结构处理好，对悬挂系统的构件/不规则物体会更敏感，可以考虑借鉴其“对齐 + 注意力”思路替换 HeightCompression。

3.4 检测 Head & Loss 的改进点（IoU‑aware / 邻域投票等）

3.4.1 CIA‑SSD：IoU‑Aware 单阶段体素检测器

CIA‑SSD：Confident IoU-Aware Single-Stage object Detector from point cloud(arXiv)
- 来源：AAAI 2021 + GitHub 开源实现。(GitHub)
- 主要改进点：
  - 提出 Spatial‑Semantic Feature Aggregation (SSFA) 模块，融合空间/语义特征；
  - 引入 IoU‑aware 分支：预测每个候选框的 IoU，用这个 IoU 去修正分类置信度，缓解 cls/reg 不对齐问题；
  - 在 KITTI Car 测试集上，以单阶段方法拿到了很高的 AP，同时保持 ~30ms 量级的推理时间。
- 迁移到 CenterPoint 的玩法：
  - 在 CenterHead 中加一个 pred_iou 分支，训练时用真值 IoU 做监督；
  - 推理时用 score = sigmoid(cls) * sigmoid(pred_iou) 当最终得分，提升小目标/远距离框的精度排序；
  - 可把 SSFA 的结构简化成一个小 neck 放在 BEV backbone 和 CenterHead 之间。

3.4.2 NIV‑SSD：邻域 IoU 投票（Neighbor IoU‑Voting）

NIV‑SSD：Neighbor IoU-voting Single-Stage Object Detector(ScienceDirect)
- 改进点：
  - 引入 Neighbor IoU Voting (NIV) 策略，用周围候选框的回归输出统计信息，去修正分类置信度；
  - 本质上也是解决 cls/reg 不对齐，但重点在“邻域统计”。
- 你可以做一个轻量版，把“邻域 IoU 投票”融合到 CenterPoint 的后处理（在 NMS 之前对置信度再校一次）。

3.4.3 Fully Sparse + Center‑based（FSD / FSDv2）

FSD：Fully Sparse 3D Object Detection(NeurIPS Proceedings)
- 完全在稀疏 3D 体素空间内做检测，复杂度与点数线性、与感知范围几乎无关，非常适合长距。
FSDv2：Improving Fully Sparse 3D Object Detection with Virtual Voxels(arXiv)
- 提出 Virtual Voxels，解决 fully sparse 结构里的“中心特征缺失”问题。
对你来说：
- 如果以后要把 X 范围从 160m 拉得再更远，可以考虑把 CenterHead 的思想结合到 FSDv2 的虚拟体素框架里，但这属于第二阶段（工程量较大）。

3.5（可选）语义 / 多模态 / 融合类改进

如果你未来接入相机或语义分割结果，可以参考：

CenterPoint‑Se：在 CenterPoint 上加入预先算好的语义特征（PMF 多模态语义），证明语义能显著提升检测精度，仓库里是基于 OpenPCDet 改的，非常适合你直接开箱参考。(GitHub)
VoxelNextFusion / UVTR：统一 voxel 表示进行 LiDAR‑Camera 融合，用 Transformer 融合稀疏体素与稠密图像特征，长距离/小目标提升明显。(arXiv)

4. 给你一个实际可落地的“改进组合”示例

如果你想要一个工程上可一步一步做的路线，可以按下面顺序堆：

基线：
- OpenPCDet 的 cbgs_voxel0075_res3d_centerpoint.yaml → 改成你的 POINT_CLOUD_RANGE 和 VOXEL_SIZE=[0.1,0.1,0.2]，先训通。
体素 & 时序增强（简单 + 收益明显）：
- 在 VFE 里加一维 density 通道，参考 PDV 的做法；(arXiv)
- 如果 FPS 还能接受，再加 1–2 帧点云，套一个精简版 TVE（Temporal Voxel Encoder）做时序体素聚合。(MDPI)
BEV neck + 小目标：
- 参考 CenterPoint‑SAE 和 VSAC 的 PST‑FPN，把 BaseBEVBackbone 替换成多尺度 FPN 式 neck，加强小目标的 BEV 表达。(ScienceDirect)
Head / Loss 增强：
- 按 CIA‑SSD 的思路，在 CenterHead 里加一个 IoU‑aware 分支，训练 IoU，测试用 score = cls * iou；(AAAI Open Access Journals)
- 如果还想更“极致”，结合 NIV‑SSD 的邻域投票做一次后处理级别的 score 校正。(ScienceDirect)

这套下来，你仍然保持：

单阶段 + 体素化 + CenterHead 的整体框架；
FPS 受到一定影响，但在 3090 + 你这个 160m×40m 范围下，一般还能维持一个“工程可用”的水平（按 nuScenes 上 CenterPoint‑voxel 和 CenterPoint‑SAE 报告的速度估计）。(GitHub)

如果你愿意，下一步你可以把你现在的 CenterPoint 配置（yaml）贴出来，我可以按上面这些具体给你标：在哪一段代码/模块里插 PDV 密度、在哪一层加 self‑attention、CenterHead 多加哪几个输出通道，这样你实现时就更有目标感。

Answer 3

好，既然你基线定成 VoxelNeXt，那我们就围着「单阶段 + 完全稀疏体素」这一套来设计一版**“悬挂单轨小目标专用版 VoxelNeXt”**，并且每个改动都给你对应的论文来源，方便你去查中英文资料。

0. 先统一一下基线：你的 VoxelNeXt 长啥样

VoxelNeXt 本身的特点你应该已经看过，这里只点关键点，跟后面的改动强相关：

完全稀疏体素框架：从 VFE → 3D 稀疏 backbone → 稀疏高度压缩（Sparse Height Compression）→ 稀疏 2D head，全程不用 dense BEV 和 anchor/center。(ar5iv)
额外下采样层 + 多 stage 拼接：在普通 SparseConv backbone 上再加两个下采样层（stride 到 16、32），把最后 3 个 stage 对齐后拼接，直接扩大感受野。(ar5iv)
Spatially Voxel Pruning：根据特征范数对体素做“空间剪枝”，只对前 50% 高响应体素做膨胀，节省算力。(ar5iv)
稀疏高度压缩 + 稀疏 2D head：z 维压成 2D 稀疏 BEV，再用稀疏 head 做预测，支持 sparse max‑pool 代替 NMS。(ar5iv)
官方实现已合入 OpenPCDet，GitHub 上说明“VoxelNeXt 已 merge 到官方 OpenPCDet 代码”。(GitHub)

对你来说，最重要的优点是：

对**长距离（Argoverse2、Waymo）**已经验证过精度 + FPS，都在完全稀疏体素框架下跑通，这跟你 Tele‑15 的 160m 前向、轨道场景非常契合。(ar5iv)

1. 先把「Tele‑15 单轨版 VoxelNeXt」跑起来

1.1 点云范围 & 体素参数

你给的范围和体素：

X: [0, 160] m
Y: [-20, 20] m
Z: [-2, 6] m
体素：[0.1, 0.1, 0.2] m

在 VoxelNeXt（OpenPCDet 版）里，大概就是：

yaml
POINT_CLOUD_RANGE: [0.0, -20.0, -2.0, 160.0, 20.0, 6.0]
VOXEL_SIZE: [0.1, 0.1, 0.2]

DATA_PROCESSOR:
  - NAME: transform_points_to_voxels
    VOXEL_SIZE: [0.1, 0.1, 0.2]
    MAX_NUMBER_OF_VOXELS: { 'train': 200000, 'test': 200000 }

160 × 40 × 8m + 完全稀疏：

理论体素数：1600 × 400 × 40 ≈ 2560 万，但 VoxelNeXt 和 spconv 只对非空体素做运算。
3090 + 24G 显存 + VoxelNeXt 自带的 voxel pruning，在这个范围内是可行的（Waymo、Argoverse2 的感知范围更大也能跑）。(ar5iv)

1.2 利用“单轨场景先验”做预裁剪

悬挂单轨的一个优势是：场景结构先验特别强，可以直接把很多“永远没目标的位置”裁掉，提高稀疏性、减 false positive：

你可以在 data loader 里提前做：

Y 方向软裁剪：如果轨道投影在 y≈0 附近，很多情况下 ±15m 就够用，可以先保守按 ±20 跑，后续根据实际数据再缩。
Z 方向过滤：
- 地面以下（比如 z < −1m）通常没有真实目标，可以直接丢；
- 很高的空域（z > 某阈值）若几乎没有障碍，也可以过滤。
基于 rail/结构的 mask：
- 如果你有轨道中心线的 CAD/地图，可以只保留距离轨道一定范围内的点（例如 6–8m），强行压缩背景体素。

这些预处理能让 VoxelNeXt 的voxel pruning 更有效：它原本是按特征范数丢体素，你可以先在几何层面对“明显没用”的区域做一次硬裁减。(ar5iv)

2. 围绕 VoxelNeXt 的「体素改进点」怎么选？——分模块讲 + 给论文来源

我按模块拆成 5 大类，每一类都给你：改动点 → 适合你的原因 → 对应论文/来源。你可以从“简单 + 不太影响 FPS”的开始堆。

2.1 Backbone：面向“长距 + 轨道障碍”的稀疏注意力（RVSA‑3D 系）

改动 2.1‑A：在 VoxelNeXt backbone 里加 SPA（子流形池化注意力）

来源：RVSA‑3D（Voxel-based fully sparse attention 3D object detection for rail transit obstacle perception）

RVSA‑3D 专门为轨道交通远距离稀疏障碍物检测设计了一个完全稀疏的注意力框架，包括：
- SPA（Submanifold Pooling Attention）
- MIF（Multi-scale Information Fusion）
- HSA（High-confidence Sparse Attention）(Science Explorer)
SPA 的核心思想是：在子流形稀疏卷积的基础上嵌入注意力 + 池化，在做下采样时，把信息更好地“对齐到中心体素”，缓解稀疏 backbone 的“中心特征缺失”问题（这点 VoxelNeXt 原文里也提到过 center-missing 的问题）。(ar5iv)

你怎么改 VoxelNeXt：

在 spconv_backbone_voxelnext.py 里，每个 down-sampling block 替换为：
- subMConv → pool（同一个 voxel 邻域的统计，如 mean/max）→ 注意力（channel attention 或简单双线性）→ 下采样 Conv。
保持输入输出的稀疏索引格式不变，这样不会破坏完全稀疏的框架。

效果预期：

对你的远距离小目标（轨道上的异物、吊挂件等），SPA 可以让稀疏表面点的特征更集中，下采样后不会丢掉关键信息。
论文本身也是 rail transit 场景 + 完全稀疏注意力，场景和你非常接近，中文新闻和解读也很多，便于参考。(EbioTrade)

改动 2.1‑B：在高层 stage 引入“高置信稀疏注意力”（HSA）

RVSA‑3D 的 HSA 是利用当前检测结果中的高置信目标，生成一个稀疏 attention map，反过来强化与这些目标相关的高层体素特征。(Science Explorer)

在 VoxelNeXt 里可以做一个轻量版：

在训练后期 / 推理时：
1. 用初步预测得到一批高置信体素 query；
2. 在 Stage 5/6 特征上，对这些 query 体素扩一个邻域，做一次局部 self‑attention；
3. 把更新后的特征再送去 height compression + head。

对你有啥用：

轨道场景里，远处小障碍物通常点很少，通过 HSA 可以让“已经被初步检测出来的疑似障碍物”在高层特征中获得更强的强化，减少漏检。
这一块的源码/伪代码可以基本抄 RVSA‑3D 的结构，只需要从 3D 卷积换成稀疏卷积 + 稀疏 attention。

2.2 Voxel 选择 / 净化：减少无效背景体素 + 提升 FPS（VPSNet 系）

改动 2.2‑A：用 VPSNet 的“voxel purification”替换/增强 VoxelNeXt 的 prune

来源：VPSNet: 3D object detection with voxel purification and fully sparse detection

VPSNet 指出：很多 fully sparse 检测器（包括 FSD、VoxelNeXt）都只按特征强度做剪枝，忽略了更高级的“有价值 vs 背景”判断，于是提出：
- 加一个 voxel feature refinement 模块（小网络）给每个体素打一个 importance 分数；
- 只保留高分体素参与后续计算，既减少算力又降低背景噪声误检。(Springer Link)

你怎么用在 VoxelNeXt：

VoxelNeXt 目前的 Spatially Voxel Pruning 是“按 feature magnitude 排序，保留 top 50%”。(ar5iv)
你可以在每个 prune 位置前加一层小 MLP 或 1×1 sparse conv：
- 输入：当前体素特征 + 额外几维几何先验（如距离、相对轨道中心的偏移、相对地面的高度等）；
- 输出：1 维 score（0~1），按 score 大小做保留/丢弃。
这样就从“单纯看特征范数”进化成“结合场景先验的体素选择”。

为什么对你特别合适：

悬挂单轨的大量点集中在：轨道梁、立柱、地面、天空噪声，这些位置如果你只关心轨道附近的小障碍，大部分都是“高频但没用”的背景。
VPSNet 的思路正好就是：在 fully sparse 检测里，先把背景体素滤干净，再去做检测。(Springer Link)

2.3 Density / Distance 感知：远距离小目标（PDV 系 + Tele‑15 特性）

改动 2.3‑A：在 VFE 里加入 Point Density & Depth 特征（PDV）

来源：Point Density-Aware Voxels for LiDAR 3D Object Detection（PDV，CVPR 2022）

PDV 观察到：LiDAR 点云随距离变稀疏，远处小目标点数更少，直接体素化容易丢信息，于是：
- 显式建模每个体素的 点密度，以及密度与距离的关系；
- 在 RoI 池化和 score 预测里用密度做补偿，提高远距离行人/骑行者等小目标的检测。(arXiv)

把 PDV 思想塞进 VoxelNeXt：

在体素编码时，额外计算：
- density = (#points_in_voxel) / voxel_volume
- range = sqrt(x^2 + y^2 + z^2) 或仅用前向 x
把 [x, y, z, intensity] 扩展为 [x, y, z, intensity, density, range]，喂给 VFE 的 MLP。
在 head 里，你还可以加一个小分支，用 {density, range} 去调节分类 score（例如学习一个 Δlogit）。

好处：

Tele‑15 是长距窄 FOV 雷达，远处点更稀疏，PDV 这种 density 感知特征非常契合长距场景；
PDV 有完整开源 + 很多 CSDN 中文读后感，改起来比较有“教程感”。(GitHub)

改动 2.3‑B：强度直方图增强（Intensity-Aware Voxel Encoder）

来源：LiDAR-Based Intensity-Aware Outdoor 3D Object Detection（Sensors 2024）

这篇工作提出了一种 intensity-aware voxel encoder：
- 在每个体素内做强度值的直方图/统计，拼接到体素特征中；
- 实验证明在 KITTI 上对行人、骑行类小目标有更好的鲁棒性，FPS 依然可以到 ~40。(MDPI)

在 VoxelNeXt 怎么做：

在 VFE 前，对体素内点的 intensity 做：
- min / max / mean / variance
- 或者 8/16 维的简单直方图（可选）
把这些统计量拼到体素特征向量上，再送进 SparseConv backbone。

为什么对悬挂单轨有价值：

很多“非轨道异物”和“轨道金属构件”，在 intensity 上的分布是不同的；
对 Tele‑15 这类固态雷达，强度分布相对比较稳定，直方图特征能帮你分辨“噪声点 vs 实体物体”。

2.4 多尺度聚合 & 小目标：用 RAE3D / VoxT‑GNN 的思路改 VoxelNeXt Head

改动 2.4‑A：多尺度 voxel 聚合到 query（RAE3D 的 MVA‑PQ）

来源：RAE3D: Multiscale Aggregation-Enhanced 3D Object Detection for Rail Transit Obstacle Perception

RAE3D 也是单阶段 3D 检测器，专门针对轨道交通障碍物，提出了：
- MVA‑PQ（Multiscale Voxel feature Aggregation on Point Queries）
  - 对每个 query（相当于关键点）从多尺度 voxel 特征里聚合信息；
- BEV‑MLA（BEV Multi-Level Auxiliary），对 BEV 多尺度特征做辅助监督。(X-MOL)

迁移到 VoxelNeXt：

VoxelNeXt 已经在 backbone 里有 6 个 stage，并且最后把 Stage 4–6 的特征对齐后拼起来。(ar5iv)
你可以：
1. 对每个 query voxel，从 Stage 4/5/6 中都取对应位置的特征（或邻域 pooling）；
2. 通过一个小型“多尺度聚合模块”（类似 RAE3D MVA‑PQ）将这几层特征加权融合；
3. 把聚合后的特征送进 VoxelNeXtHead 做回归/分类。

为什么对小不规则目标特别有用：

小目标在高层（大步长）里几乎消失，但在低层仍有细节；
多尺度聚合能让 query voxel 既拥有大的感受野，又保留局部结构，特别适合你这种“杆件、吊挂件、落物”这类不规则小物。

改动 2.4‑B：局部 region‑to‑region 聚合（VoxT‑GNN）

来源：VoxT-GNN: Transformer and GNN based 3D object detection

VoxT‑GNN 把 3D 检测看成“region-to-region 的变换”，在体素域里构建图，用 Transformer + GNN 来特意增强小目标的特征建模。(sciencedirect.com)

你可以做一个简化版本，只用于 VoxelNeXt 的 head 前：

对每个 query 体素，在 3D 或 2D 稀疏空间中找若干邻居（比如 k=16）；
在这些邻居之间跑 1–2 层轻量自注意力 / GNN；
输出再接入 VoxelNeXtHead。

这样，你不用重写整个框架，只是把 head 前多了一小段「局部结构建模」，对小目标的轮廓/边界非常友好。

2.5 检测头 & Loss：IoU‑aware + 邻域投票

OpenPCDet 版 VoxelNeXtHead 本身就支持一个 IoU 分支（很多教程里都提到了 “VoxelNeXtHead 支持 IoU 分支预测”），你可以在此基础上借鉴 CIA‑SSD/NIV‑SSD 的做法。(CSDN Blog)

改动 2.5‑A：CIA‑SSD 风格的 IoU‑aware Head

来源：CIA‑SSD: Confident IoU-Aware Single-Stage Object Detector from Point Cloud

CIA‑SSD 在 anchor‑based 单阶段检测里加了一个 IoU 分支，学习每个候选框与 GT 的 IoU，并用 score = cls_prob * iou_pred 作为最终得分，使分类置信度与回归质量对齐。(arXiv)

把概念挪到 VoxelNeXt：

在 VoxelNeXtHead 中：
- 已有分类 + box 回归分支，可以加一个单独的 IoU 分支（或直接启用已有 IoU head）；
- Loss 用 L1 或 BCE 对 IoU 进行回归；
- 推理时用 final_score = sigmoid(cls) * sigmoid(iou)。
对你这种远距离小异物，用 IoU‑aware 方式能让“框得更准的小物体”在排序中更靠前，减少被大目标/假阳性压下去的情况。

改动 2.5‑B：NIV‑SSD 邻域 IoU 投票（Neighbor IoU Voting）

来源：NIV‑SSD: Neighbor IoU-voting Single-Stage Object Detector

NIV‑SSD 提出对每个候选框，用邻域候选框的 IoU 信息做投票，修正分类置信度，更好地对应“真实物体簇”的质量。(Springer Link)

在 VoxelNeXt 里可以把它做成纯后处理模块：

先用纯 sparse max‑pool / NMS 得到一批候选框；
对每个框，在 3D 空间找临近若干框（IoU 大于某阈值），计算这些邻居的平均/加权 IoU；
用这个邻域 IoU 去微调该框的 score。

这一步对 FPS 影响很小，但能修正一些“孤立噪声框”和“重叠的真目标”，对小目标尤其有帮助。

2.6 时序 + 轨道场景：充分利用 VoxelNeXt 的 tracking 扩展

VoxelNeXt 原文已经展示：通过记录 “哪个体素预测出哪个 box”，就可以直接做 voxel association tracking，在 nuScenes tracking 榜上拿到 SOTA。(ar5iv)

对你的悬挂单轨场景，可以用一个**“检测 + 简单跟踪”联动增强小目标**的思路：

改动 2.6‑A：两帧或三帧体素时间融合

类似一些 “Temporal Motion-Aware 3D Detection” 的工作，对连续帧体素做聚合，使真正的障碍物在多个时刻一致出现，而噪声随机出现。(arXiv)

简化实现：

融合最近 2–3 帧 Tele‑15 点云（配准到当前车体坐标系）；
在 voxelization 时附加一个 “时间索引/相对时间”通道；
在 backbone 的早期 stage 用 1–2 层「时序卷积 / 注意力」聚合时间维度。

改动 2.6‑B：利用 voxel association 做“轨道占用”判断

对于“轨道区域小障碍”的场景，你可以用 VoxelNeXt tracking 中的voxel association，在 2–3 帧之间看看某些 voxels 是否持续产生检测：
- 若某段轨道上的某 cluster 体素在多个时间点都有检测框，且相对轨道位置基本不变，就可以在系统层面标记为“铁定障碍”；
- 这对 Tele‑15 这类非重复扫描 + 稀疏噪声的雷达特别有帮助。(ar5iv)

3. 一个「可逐步落地」的 VoxelNeXt 改进路线

最后，我给你串成一条具体路线，你可以按阶段堆功能，随时在地图上看 FPS / 精度怎么变化。

阶段 1：基线 VoxelNeXt + Tele‑15 适配

用 OpenPCDet 自带的 VoxelNeXt config（nuScenes / Waymo 版）为模板，
改 POINT_CLOUD_RANGE、VOXEL_SIZE=[0.1,0.1,0.2]、MAX_NUM_VOXELS，
加上“单轨场景的几何裁剪”（Y/Z 过滤、轨道附近 mask）。

目标：先在 0–80m 拉通训练和评估，确认数据、坐标系、标注都没问题。

阶段 2：长距 + 小目标增强（相对便宜的改法）

在 VFE 里加入：density、range、简单 intensity 统计（PDV + Intensity-Aware 思想）。(arXiv)
把 IoU 分支打开 / 加强（如果你的 VoxelNeXtHead config 里没用 IoU 分支，可以仿 CIA‑SSD 方式加上）。(arXiv)
对轨道附近区域设置更低的 score 阈值、更细粒度的 NMS / max‑pool 规则，以防小目标被干掉。

这一阶段对 FPS 影响有限，但会明显改善远距离小物体的 recall。

阶段 3：Backbone & 多尺度聚合（中等成本）

参考 RVSA‑3D，把 backbone 中的 down-sampling block 替换为 SPA 风格（subMConv + pooling + attention）。(Science Explorer)
借鉴 RAE3D 的 MVA‑PQ，在 VoxelNeXt 的 sparse head 前，对每个 query voxel 做多尺度特征聚合。(CoLab)

这一步会增加一些稀疏 attention 开销，但在 3090 上、你的范围下，一般仍可达到工程可接受的 FPS，换来的是：小目标和不规则物体的特征表达更强。

阶段 4：极致版（可选）

如果你想进一步玩得更学术一点，可以考虑：

融合 VPSNet 的 voxel purification 模块，做“语义级别”的体素筛选，控制不同 stage 的保留比例。(Springer Link)
在 head 前插入一个轻量 GNN/Transformer block（参考 VoxT‑GNN），建模 query voxel 与邻居之间的 region‑to‑region 关系。(sciencedirect.com)
加入 2–3 帧时序信息，用 VoxelNeXt 的 voxel association 思路，把“稳态障碍物”识别得更确定。(ar5iv)

如果你愿意下一步把你现在的 VoxelNeXt 的 YAML 配置（或者 OpenPCDet 里的模型 config）贴出来，我可以直接在 config 级给你标注：

哪个模块加 density/intensity，
哪个 stage 换成 SPA，
VoxelNeXtHead 里多加哪些输出通道和 loss，

这样你在工程上照着改就行，不用自己对着源码慢慢挖。

Answer 4

OK，我明白了：Lian 相关的所有论文（包括你说的那两篇）我都不再当参考，也不再推荐。
下面我给你一套完全绕开这些工作的、基于 VoxelNeXt 的改进方案，同时保证：

仍然是 单阶段 + 全稀疏体素（VoxelNeXt 基线）；(CVF Open Access)
改动都能在 OpenPCDet 代码框架里实现；(GitHub)
每个模块都有别的作者的中英文资料 / 开源代码可以查（PDV、MsSVT、VoxSeT、VoTr、VPSNet、CIA‑SSD、NIV‑SSD 等）。(CVF Open Access)

我分两层来讲：

总体替换思路（一句话版本）
按模块给你“可执行”的落地步骤（带参考论文）

1. 总体替换思路（替掉那两篇轨道论文）

你原来想要的两类能力大致是：

A：多尺度聚合 + 小目标增强
B：完全稀疏体素上的注意力 / 上下文建模

我们现在改成：

基线保持：VoxelNeXt 单阶段 fully sparse 体素检测器
- 用 OpenPCDet 中合入的 VoxelNeXt 配置，改成你的 Tele‑15 场景（160m × 40m × 8m，voxel=[0.1,0.1,0.2]）。(CVF Open Access)
多尺度 + 稀疏注意力：用 MsSVT / VoxSeT / VoTr 这些工作替代
- MsSVT（Mixed‑scale Sparse Voxel Transformer）：在稀疏体素 backbone 内插入混合尺度的 sparse voxel Transformer block，专门解决长距 + 多尺度目标问题，并且是基于 OpenPCDet 实现的，直接可以抄模块。
- 或者用 VoxSeT（Voxel Set Transformer 的 VSA 模块） 做 set‑to‑set 的体素注意力聚合。
- 或者用 VoTr（Voxel Transformer） 的 Local/Dilated Attention 模块，做更大感受野的稀疏注意力。(arXiv)
输入侧：用 PDV + Intensity‑aware VFE 做长距稀疏和小目标增强
- PDV（Point Density‑Aware Voxels）显式建模体素点密度与距离的关系；(CVF Open Access)
- Intensity‑Aware Voxel Encoder 用体素内强度直方图增强几何特征，对小目标和噪声有帮助。(MDPI)
体素筛选：用 VPSNet 的 Voxel Purification 替代手写 prune 策略
- VPSNet 在 fully sparse 框架里加入 voxel feature refinement 模块，为每个体素打分，只保留“有价值体素”，减少背景体素并节约计算。(Springer Nature)
Head & Loss：用 CIA‑SSD + NIV‑SSD 的 IoU‑aware 思想替代之前提到的 rail‑specific 设计
- CIA‑SSD：单阶段检测里加一个 IoU 分支，对 cls 分数做 IoU aware 校正；
- NIV‑SSD：提出 Neighbor IoU‑Voting，用邻域回归结果的统计量再修正分类置信度；

总结一句话：

用「VoxelNeXt + MsSVT/VoxSeT/VoTr + PDV + VPSNet + CIA‑SSD/NIV‑SSD」这一套，完全替掉原来那两篇轨道论文里的注意力和多尺度思想。

2. 按模块给你一个“可执行”的改法路线

下面是你可以真正在工程里一步步做的东西，我按从易到难排一下顺序。

2.1 阶段 0：先把 Tele‑15 版 VoxelNeXt 跑起来（不用任何 fancy 模块）

目标： 把数据、坐标系、标注、Loss 都跑通，先在 0–80m 训收敛，再扩到 160m。

在 OpenPCDet 里拷贝一个 VoxelNeXt 的配置（例如 nuScenes / Waymo 上那套）。(GitHub)
把这些键改成你的参数（伪代码）：

yaml
POINT_CLOUD_RANGE: [0.0, -20.0, -2.0, 160.0, 20.0, 6.0]
VOXEL_SIZE: [0.1, 0.1, 0.2]

DATA_PROCESSOR:
  - NAME: transform_points_to_voxels
    VOXEL_SIZE: [0.1, 0.1, 0.2]
    MAX_NUMBER_OF_VOXELS: { 'train': 200000, 'test': 200000 }

在 data loader 里加简单几何裁剪（建议）：
- 丢掉 z < −2.5m 的点（地面以下）；
- 如果确认轨道附近 ±15m 足够，也可以最后把 Y 范围缩到 [-15, 15] 减算力；
- 对于 Tele‑15 特性，若存在明显的远处天空噪声，可按高度阈值过滤。

2.2 阶段 1：输入 VFE 改造 —— PDV + Intensity‑aware（轻量，收益大）

2.2.1 加入 PDV 风格的 density / range 特征

参考：PDV (Point Density‑Aware Voxels)(CVF Open Access)

在 VoxelNeXt 的 voxel encoder 前，对每个 voxel 额外算：

N = #points_in_voxel
density = N / voxel_volume（体素体积=0.1×0.1×0.2）
range = sqrt(x_center^2 + y_center^2 + z_center^2) 或仅用 x_center（前向距离）

然后把原先的输入 (x,y,z,intensity,...) 扩展成：

text
[x_rel, y_rel, z_rel, intensity, density, range]

在 config 里体现为 VFE 的输入通道数增加（例如从 4 → 6），后面 MLP 的第一层 in_channels 对应修改即可。
PDV 的开源仓库本身就是基于 OpenPCDet，你可以直接参考他们如何在 VFE 里加 density。

2.2.2 引入 Intensity‑Aware Voxel Encoder（直方图）

参考：LiDAR‑Based Intensity‑Aware Outdoor 3D Object Detection(MDPI)

思路很简单：

在每个 voxel 内，对 intensity 做一个 K 维直方图（比如 K=8 或 16）：
- 预先归一化 intensity 到 [0,1]
- 计算每个 bin 的计数 / 频率
把这 K 维直方图 + intensity_mean / intensity_var 拼到 voxel 特征向量里：

text
[x_rel, y_rel, z_rel, intensity_mean, density, range, hist_bin_1..hist_bin_K]

VFE 的第一层 MLP 输入通道数随之增加。

代码层面可以仿照他们在 mmdetection3d 里的 IVEF 实现，只是把数据结构替换成 OpenPCDet 的 voxel 格式即可。(GitHub)

对你场景的意义：

Tele‑15 的回波强度对材料/物体类别有区分度；
悬挂单轨里，“轨道/支架”和“异物/小目标”的 intensity 分布不一样；
这一步不增加多少计算量，但能提升对小、不规则目标的判别力。

2.3 阶段 2：Backbone 插入稀疏 Transformer 做多尺度 + 长距注意力

这里我们用别的作者的稀疏 voxel Transformer来替代你之前想用的轨道专用注意力。

2.3.1 方案 A：用 MsSVT 的 Mixed‑scale Sparse Voxel Block

参考：MsSVT / MsSVT++

MsSVT 提出一种 混合尺度稀疏 voxel Transformer，用不同大小的稀疏窗口 + self‑attention 捕获局部细节和长距上下文；
代码是基于 OpenPCDet 实现的，仓库里有 spconv 的 backbone 模块，可以直接移植 block。

如何嵌入 VoxelNeXt：

VoxelNeXt backbone 中通常有多级 stage（例如 stage1～stage6）。(arXiv)
保持前两级还是普通 SparseConv（对近处高分辨率区域性价比高）；
在中高层级（比如 stage4、stage5）把原来的 SparseConvBlock 换成 MsSVTBlock：
- MsSVTBlock 内部是：
  - 稀疏 voxel window 划分（多种窗口大小）；
  - window 内 self‑attention + FFN；
  - residual 连接。
在 config 里增加 MsSVTBlock 的参数，如 WINDOW_SIZES=[9,13,17]、NUM_HEADS=4 等——可以直接照着 MsSVT 的 config 调小一档。

为什么适合你：

轨道场景是一个典型的“大范围 + 细长结构 + 小目标”组合；
MsSVT 就是为“多尺度 + 大感受野”设计的，你相当于把它当一个通用多尺度稀疏注意力模块用，不依赖任何轨道论文。

2.3.2 方案 B（备选或补充）：用 VoTr / VoxSeT 做通用 sparse attention

如果你觉着 MsSVT 太重，也可以只用 VoTr 或 VoxSeT 的一个 block：

VoTr：Voxel Transformer —— 提出 sparse voxel module + submanifold voxel module，支持 Local / Dilated attention，两种机制都可以在不大幅增加算力的情况下扩大感受野。(arXiv)
VoxSeT：Voxel Set Transformer —— 用 Voxel Set Attention (VSA) 模块，把体素特征看成 set，做 set‑to‑set translation，侧重全局上下文。

嵌入方式类似 MsSVT：

从各自的 GitHub 拉一个 VoTrBlock / VSA 模块；(GitHub)
在 VoxelNeXt backbone 的中高层 stage 里，用这些注意力 block 替换部分卷积 block；
保持整体输出 shape 和稀疏索引不变。

2.4 阶段 3：体素筛选（Voxel Purification）—— VPSNet 思路

参考：VPSNet: 3D object detection with voxel purification and fully sparse convolutional networks(Springer Nature)

VPSNet 解决的问题和 VoxelNeXt 很像：fully sparse detector 里，背景体素多、计算浪费、易误检。它做了两件事：

一个 voxel feature refinement 网络，为每个体素预测一个“重要性分数”；
按分数筛选体素，只保留一部分高分体素进入后续 stage。

你可以在 VoxelNeXt 的 prune 位置这样改：

原本 VoxelNeXt 的 pruner 是按 feature 范数或固定比例筛体素；(arXiv)
现在在 prune 前加一层 1×1 SparseConv / MLP：
- 输入：该 voxel 特征 f + 可选几何先验（距离、y 偏离轨道中心、z 高度等）；
- 输出：一个标量 score∈(0,1)；
按 score 排序，保留 top‑K 或分段阈值（例如保留 60%）。

这样做的好处：

对单轨场景来说，大量轨道梁、立柱、天空背景本身是固定结构，可以交给这个小网络学会“这些体素不重要”；
算力集中到轨道附近的运动/异常体素上，同时还能减少背景误检。

2.5 阶段 4：Head + Loss —— 用 CIA‑SSD + NIV‑SSD 的 IoU‑aware 技巧

2.5.1 在 VoxelNeXtHead 里加 IoU 分支（CIA‑SSD 思想）

参考：CIA‑SSD（Confident IoU‑Aware Single‑Stage Object Detector）

CIA‑SSD 做了两件你可以直接借鉴的事：

IoU 分支：预测每个框与真值的 IoU；
用 score = cls_prob × iou_pred 做最终置信度，使分类分数与回归质量一致。

在 VoxelNeXtHead 里：

多加一个分支 iou_head 输出标量 IoU；
IoU 的监督用真值 IoU + L1 / BCE loss；
前向时：

python
final_score = sigmoid(cls_logit) * sigmoid(iou_logit)

OpenPCDet 的 CIA‑SSD 仓库是直接基于 PCDet 写的，你可以参考它的 DenseHead 实现 IoU 分支细节。

2.5.2 后处理层做 Neighbor IoU‑Voting（NIV‑SSD 思想）

参考：NIV‑SSD：Neighbor IoU‑Voting Single‑Stage Object Detector

NIV‑SSD 的核心是在 NMS 前后，对每个候选框利用周围候选框的 IoU 信息修正分数：

对每个框 B：
1. 找一圈邻居框 {B_i}，IoU > τ；
2. 用邻居的 IoU / 分数做加权平均，得到一个“邻域 IoU 投票”值；
3. 用这个投票值去修正 B 的 score（比如线性插值）。

在 VoxelNeXt 中，这完全可以做成独立后处理模块，不影响前向 FPS 太多，但能显著减少小目标被误排、孤立假阳性问题。

NIV‑SSD 也有基于 PCDet 的开源实现，你甚至可以直接把其 IoU voting 的后处理代码拷过来。

2.6 阶段 5（可选）：长时序增强 + 占用判断（基于 VoxelNeXt 的 tracking）

VoxelNeXt 原文已经说明：它可以天然做 voxel‑level tracking（通过追踪哪些体素产生了哪个框），在 nuScenes tracking 榜上表现很好。(CVF Open Access)

对悬挂单轨 + Tele‑15 的场景，你可以做一个比较简单的时序增强，只做两件事：

多帧融合：
- 把最近 2–3 帧点云（对齐到当前车体坐标）一起 voxelize；
- 在 VFE 里再加一维 “frame_id / Δt” 通道（类似 PDV 加的 density / range）；
- 在 backbone 的前两级用 1–2 个“时间卷积 / 简单 self‑attention”聚合时间维度。
轨道占用判断：
- 对同一空间位置的 voxels，在多帧中反复产生“高 IoU / 高分数的小框”，就认为是真障碍；
- 一次性噪声 / 点云抖动很快会被时间维度过滤掉。

这部分不依赖任何特定论文，主要是工程逻辑；如果之后你想写论文，可以再去找专门做 temporal 3D detection 的工作来对齐。

3. 小结：现在这套方案怎么替代你不能用的论文？

原来想用的“轨道场景专用 Attention + 多尺度聚合”
→ 现在统一换成 MsSVT / VoTr / VoxSeT 这种“通用稀疏 voxel Transformer + 多尺度”模块，而且都有 PCDet 实现可以参考。(CVF Open Access)
原来想用的“fully sparse + rail attention”
→ 现在用 VoxelNeXt 的 fully sparse 框架 + VPSNet 的 voxel purification + PDV 的 density / Intensity‑aware VFE，同样解决远距离稀疏 + 背景多的问题。(CVF Open Access)
Head / Loss 部分原来提到的做法
→ 现在全部换成 CIA‑SSD / NIV‑SSD 的 IoU‑aware 技巧，它们是非常通用的单阶段 3D 检测 trick，而且资料很多。

如果你愿意，下一步你可以把当前的 VoxelNeXt YAML 配置 发给我一份，我可以直接在上面帮你标注：

具体在哪个模块加 PDV / intensity 特征；
哪个 stage 换成 MsSVT 或 VoTr block；
VoxelNeXtHead 里多加哪些 IoU 输出和 loss；
VPSNet 风格的 voxel scoring 放在哪一层做 prune。

这样你基本就是按“清单式”修改，而不用一行行地啃源码。

Answer 5

可以的。在 OpenPCDet / VoxelNeXt 里，把 PDV 风格的 density / range 加到“voxel encoder 前”的最省事位置，就是改 VFE（Voxel Feature Encoder）：它拿到 voxels / voxel_num_points / voxel_coords 后，先做原来的 mean 特征，再把 density、range 拼接到 batch_dict['voxel_features'] 里即可（后面的 sparse backbone 会自动吃更高维的 voxel feature）。

下面给你一个“从哪里复制到哪里 + 直接能跑的代码骨架”。

你要复制/新增哪些文件？

Step 0：先看你现在 VoxelNeXt 用的是哪个 VFE

打开你的 VoxelNeXt yaml，找到：

yaml
MODEL:
  VFE:
    NAME: MeanVFE   # 或 DynMeanVFE / DynamicMeanVFE 之类

大多数 VoxelNeXt 配置会用 MeanVFE（PCDet 里 MeanVFE forward 会在 batch_dict 里写入 voxel_features）。(GitHub)
batch_dict 里也确实有 voxels/voxel_coords/voxel_num_points 这些键。(GitHub)

以下我按 MeanVFE 来给最直接的改法（如果你是 DynMeanVFE，我在末尾也给你替换点）。

方案 A（推荐）：复制 MeanVFE → 新建 PDVMeanVFE

Step 1：复制文件

把原文件复制一份（你本地 OpenPCDet 工程里）：

源文件：OpenPCDet/pcdet/models/backbones_3d/vfe/mean_vfe.py
目标文件：OpenPCDet/pcdet/models/backbones_3d/vfe/pdv_mean_vfe.py

mean_vfe.py 本身就是把 voxel 内点特征求均值并写入 batch_dict['voxel_features']。(GitHub)

Step 2：把下面代码粘进 `pdv_mean_vfe.py`（可直接替换整个文件）

python
import torch
from .vfe_template import VFETemplate


class PDVMeanVFE(VFETemplate):
    """
    在 MeanVFE 的输出上追加两个 voxel-level 特征：
      - density: num_points / voxel_volume（可选 log1p 归一化）
      - range: voxel center 的距离（默认 sqrt(x^2 + y^2)）
    """

    def __init__(self, model_cfg, num_point_features, voxel_size, point_cloud_range, **kwargs):
        super().__init__(model_cfg=model_cfg)

        self.num_point_features = num_point_features
        self.voxel_x, self.voxel_y, self.voxel_z = voxel_size
        self.pc_range = point_cloud_range

        # 与 OpenPCDet 的 PillarVFE 一样的中心点 offset 计算方式（coords: [b, z, y, x]）
        # 其中 x 索引在 coords[:, 3]，y 在 coords[:, 2]，z 在 coords[:, 1] ([GitHub](https://github.com/open-mmlab/OpenPCDet/blob/master/pcdet/models/backbones_3d/vfe/pillar_vfe.py?utm_source=chatgpt.com))
        self.x_offset = self.voxel_x / 2 + self.pc_range[0]
        self.y_offset = self.voxel_y / 2 + self.pc_range[1]
        self.z_offset = self.voxel_z / 2 + self.pc_range[2]

        self.voxel_volume = self.voxel_x * self.voxel_y * self.voxel_z

        # 可在 yaml 里配置
        self.use_xy_range = getattr(self.model_cfg, 'USE_XY_RANGE', True)      # True: sqrt(x^2+y^2), False: sqrt(x^2+y^2+z^2)
        self.density_log1p = getattr(self.model_cfg, 'DENSITY_LOG1P', True)    # True: log1p(density)
        self.range_scale = getattr(self.model_cfg, 'RANGE_SCALE', 1.0)         # 例如 160.0，把 range 除一下避免数值偏大

    def get_output_feature_dim(self):
        # 原来 MeanVFE 输出 C 维，这里额外 +2（density, range）
        return self.num_point_features + 2

    @torch.no_grad()
    def _compute_voxel_center(self, coords, dtype):
        # coords shape: (M, 4) = [batch_idx, z, y, x]
        x_center = coords[:, 3].to(dtype) * self.voxel_x + self.x_offset
        y_center = coords[:, 2].to(dtype) * self.voxel_y + self.y_offset
        z_center = coords[:, 1].to(dtype) * self.voxel_z + self.z_offset
        return x_center, y_center, z_center

    def forward(self, batch_dict, **kwargs):
        # keys 与 OpenPCDet 一致：voxels / voxel_num_points / voxel_coords ([GitHub](https://github.com/open-mmlab/OpenPCDet/issues/1377?utm_source=chatgpt.com))
        voxels = batch_dict['voxels']                 # (M, T, C)
        voxel_num_points = batch_dict['voxel_num_points']  # (M,)
        coords = batch_dict['voxel_coords']           # (M, 4) [b, z, y, x]

        # 1) 原 MeanVFE：对 voxel 内点特征求均值
        points_sum = voxels.sum(dim=1)  # (M, C)
        normalizer = torch.clamp_min(voxel_num_points.view(-1, 1), min=1.0).type_as(voxels)
        mean_feat = points_sum / normalizer  # (M, C)

        # 2) density = num_points / voxel_volume （可选 log1p）
        density = voxel_num_points.type_as(voxels) / self.voxel_volume
        if self.density_log1p:
            density = torch.log1p(density)

        # 3) range：用 voxel center 计算
        x_center, y_center, z_center = self._compute_voxel_center(coords, voxels.dtype)
        if self.use_xy_range:
            rng = torch.sqrt(x_center * x_center + y_center * y_center)
        else:
            rng = torch.sqrt(x_center * x_center + y_center * y_center + z_center * z_center)

        if self.range_scale and self.range_scale != 1.0:
            rng = rng / float(self.range_scale)

        # 4) 拼接到 voxel_features
        voxel_features = torch.cat(
            [mean_feat, density.unsqueeze(1), rng.unsqueeze(1)],
            dim=1
        ).contiguous()

        batch_dict['voxel_features'] = voxel_features
        return batch_dict

Step 3：注册这个新 VFE（非常关键）

打开：OpenPCDet/pcdet/models/backbones_3d/vfe/__init__.py

在里面加上 import，并把它加入 __all__（OpenPCDet 的 VFE registry 就是靠这里暴露出来的，很多中文解读也会提到 MeanVFE/PillarVFE/... 都在这里）。(CSDN Blog)

示例（你按自己文件风格放）：

python
from .pdv_mean_vfe import PDVMeanVFE

__all__ = {
    # ...
    'PDVMeanVFE': PDVMeanVFE,
}

Step 4：改 yaml，把 VFE 换成你新类

在你的 VoxelNeXt 配置里：

yaml
MODEL:
  VFE:
    NAME: PDVMeanVFE
    USE_XY_RANGE: True
    DENSITY_LOG1P: True
    RANGE_SCALE: 160.0   # 你前向最大 160m，建议除一下，数值更稳

这样就完成了：每个 voxel 在进入 sparse backbone 之前，特征维度从 C 变成 C+2（多了 density/range）。

常见坑（避免你跑半天才发现）

coords 的顺序不要搞错
OpenPCDet 的 coords 通常是 [batch, z, y, x]，并且 coords[:,3] 用来算 x 中心、coords[:,2] 算 y、coords[:,1] 算 z，这个在官方 PillarVFE 里就是这么写的。(GitHub)
你用上面代码就保持一致。
输出维度一定要改 get_output_feature_dim()
否则 backbone 以为输入还是原维度，会维度不匹配。
range 要做缩放（建议）
直接 0~160 的数值也能训，但和别的特征尺度差太大不太舒服，我建议 RANGE_SCALE: 160.0。

如果你用的不是 MeanVFE，而是 DynMeanVFE 怎么办？

思路完全一样：
你就把 dynamic_mean_vfe.py（或 DynMeanVFE 对应文件）复制成 pdv_dynamic_mean_vfe.py，然后在它的 forward 最后，同样用 voxel_num_points + voxel_coords 算 density/range，再 cat 到输出 voxel_features。

（你只需要把“输出写入 batch_dict['voxel_features'] 那一行前后”那段 cat 逻辑搬过去即可。）

如果你把你当前用的 VoxelNeXt yaml 里 VFE 那一段贴出来（就那几十行），我可以按你实际用的是 MeanVFE 还是 DynMeanVFE，把“应该复制哪个文件名、你工程里对应的真实路径”给你对齐到完全一致，避免你本地和我说的命名差一点点导致 import 找不到。

Answer 6

整体思路没问题：你这段 PDVMeanVFE 的 forward 逻辑（mean + density + range 然后写回 batch_dict['voxel_features']）是对的，用在你当前 VFE: NAME: MeanVFE 这条链路上也成立。

但我建议你做两件“小修”，保证兼容不同 OpenPCDet/PDV 分支，并且不容易踩坑：

1) 你这段代码“是否能对”？——关键检查点

✅ A. `voxel_coords` 的索引顺序

在 OpenPCDet 里，voxel_coords 通常是 [batch, z, y, x]，所以：

coords[:, 3] → x index
coords[:, 2] → y index
coords[:, 1] → z index

你代码里就是这么用的，这点是对的（跟 pillar_vfe.py 的写法一致）。 (GitHub)

✅ B. 输出维度要 +2

你 get_output_feature_dim() 返回 num_point_features + 2 是必须的，否则后面 backbone 第一层通道会对不上。

⚠️ C. 构造函数签名可能不兼容（你现在这版最容易报错的点）

很多 OpenPCDet 版本里的 MeanVFE 的 __init__ 不显式带 voxel_size, point_cloud_range，而是靠 **kwargs 吞掉多余参数（你的环境也可能这样）。

所以你这版 __init__(..., voxel_size, point_cloud_range, ...) 在某些分支上会因为没传这俩参数而直接报错。

✅ 解决：把签名改成“可选参数 + 从 kwargs 里兜底拿”。

2) 我建议你用的“最终可用版本”（更稳）

把你 PDVMeanVFE 的 __init__ 改成下面这样（其余 forward 逻辑不需要动）：

python
def __init__(self, model_cfg, num_point_features, voxel_size=None, point_cloud_range=None, **kwargs):
    super().__init__(model_cfg=model_cfg)

    # 兼容：有的分支是通过 kwargs 传进来的
    if voxel_size is None:
        voxel_size = kwargs.get('voxel_size', None)
    if point_cloud_range is None:
        point_cloud_range = kwargs.get('point_cloud_range', None)

    assert voxel_size is not None, "PDVMeanVFE needs voxel_size"
    assert point_cloud_range is not None, "PDVMeanVFE needs point_cloud_range"

    self.num_point_features = num_point_features
    self.voxel_x, self.voxel_y, self.voxel_z = voxel_size
    self.pc_range = point_cloud_range
    ...

这样无论你是 OpenPCDet 原版还是 PDV fork，都更不容易炸。

3) 你问的重点：代码“从哪里复制到哪里”——按你现在 `MeanVFE` 的工程来做

你现在是 VFE: NAME: MeanVFE，所以最稳的方式是：复制 MeanVFE -> 新建一个 PDVMeanVFE，不动原来的 MeanVFE。

Step 1：复制文件

在你的工程里找到：

pcdet/models/backbones_3d/vfe/mean_vfe.py

复制成：

pcdet/models/backbones_3d/vfe/pdv_mean_vfe.py

（无论你是 OpenPCDet 仓库还是 PDV 仓库，路径基本都长这样）

Step 2：把 `pdv_mean_vfe.py` 内容替换成你的 `PDVMeanVFE`（用我上面建议的“兼容版 init”）

保持类名 PDVMeanVFE。

Step 3：注册新 VFE（必须）

编辑：

pcdet/models/backbones_3d/vfe/__init__.py

加两行：

python
from .pdv_mean_vfe import PDVMeanVFE

__all__.update({
    'PDVMeanVFE': PDVMeanVFE,
})

（你也可以按你工程里 __all__ 的写法加进去；核心是：让 builder 能按字符串找到类）

Step 4：改 yaml

把你配置里的：

yaml
VFE:
  NAME: MeanVFE

改成：

yaml
VFE:
  NAME: PDVMeanVFE
  USE_XY_RANGE: True
  DENSITY_LOG1P: True
  RANGE_SCALE: 160.0

4) 最后提醒两点（非常实用）

你加了 2 个通道后，基本不能直接加载原来 MeanVFE 对应的 pretrained 权重（第一层输入通道变了）——要么重新训，要么手动处理权重 shape。
range 用 sqrt(x^2+y^2) 还是只用 x？

单轨前向场景，很多时候 x 就够了（更稳定，且 y 变化小）。
你可以把 USE_XY_RANGE=False，然后改成 rng = x_center（甚至不用 sqrt）。

如果你愿意，我也可以按你“悬挂式单轨”更推荐的做法，把 rng 直接改成 x_center / 160（只用前向距离），这对长距离小目标一般更友好、数值更稳。

如果你把你当前工程里 pcdet/models/backbones_3d/vfe/__init__.py 的内容贴一小段（看它的 __all__ 怎么写），我可以把“注册那几行”写成完全匹配你工程风格的版本，避免你因为 registry 写法不同导致 KeyError: PDVMeanVFE。

Answer 7

先看你的表，然后直接给结论，再说下一步怎么搞 IVE（Intensity‑Aware VFE）。

1. 先读一下你的结果，顺便回答：基线还用 VoxelNeXt 吗？

表里关键几行（我摘一下）：

模型	mAR	mAP	FPS
Second	63.49	44.36	106
PV_RCNN	72.74	55.82	10
Part_A2	66.47	54.97	38
PointRCNN	81.81	74.73	19
VoxelRCNN	61.34	44.96	69
VoxelNeXt	53.09	40.81	62
VFE（= VoxelNeXt + PDV VFE）	58.91	43.90	64

理解成：

VoxelNeXt 行：原始 VoxelNeXt（MeanVFE）。
VFE 行：你把 MeanVFE 换成我给你的 PDVMeanVFE 之后的结果。

可以看出：

PDV VFE 把 VoxelNeXt 的 mAP 从 40.81 → 43.90，mAR 从 53.09 → 58.91，而 FPS 还是 62→64，几乎没变，这说明：
- 密度 + range 这一步是“有用且不太贵”的。
单阶段 + voxel/pillar 里：
- Second：44.36 mAP / 106 FPS
- CenterPoint：41.96 mAP / 65 FPS
- VoxelNeXt(+PDV)：43.90 mAP / 64 FPS
  ⇒ 精度上 VoxelNeXt(+PDV) 已经非常接近 Second，速度也够用。

你一开始的要求是：

单阶段
体素化
能适配你 Tele‑15 的长距离（X 0–160m）
后面还要继续堆很多稀疏注意力、多尺度之类的改进

在这几个条件下，我还是建议：

研究基线继续用 VoxelNeXt（现在这版 = VoxelNeXt + PDV VFE），Second/PointRCNN/PartA2/PV‑RCNN 当“对比/上界”。

原因简单说三条：

长距 & 大场景：你的前向 160m，如果用 Second 那种 dense BEV，在想保持 0.1m 级别分辨率时，显存和算力压力比 fully sparse 大很多；VoxelNeXt 本来就是针对 Argoverse/Waymo 这种大场景设计的 fully sparse 体素网络，更适合你。
可扩展性：后面你想加 Transformer、voxel pruning、multi-scale aggregation，这些现成工作几乎都是围绕 VoxelNeXt/FSD/PV‑RCNN 这一挂写的，直接“抄模块”更方便。
你已经验证了一步改进有效：PDV VFE 在你的数据上确实抬了 3 个点 mAP，这说明 VoxelNeXt 的 pipeline 跟你的 Tele‑15 + 单轨场景是配得上的。

所以：不用换基线，就以「VoxelNeXt + PDV VFE」作为当前 baseline，继续往上加 IVE（Intensity aware）等模块。

2. PDV 的 density/range 和 Intensity‑Aware VFE 是什么关系？

这两个是两套互补的特征，都是加在 VFE 里的：

PDV 风格特征（你已经做了）
- density = num_points_in_voxel / voxel_volume
- range = |voxel center 到雷达的距离|（你可以只用 x 或 sqrt(x²+y²)）。
- 作用：解决“远处小目标点少 & 点云随距离变稀疏”这个问题。
Intensity‑Aware Voxel Encoder（下一步要做的）
- 在每个 voxel 里，对 intensity 的分布 做建模，比如直方图或均值/方差等统计。
- 作用：
  - 强反射 vs 弱反射的材料区别（塑料布、风筝、鸟、无人机外壳…）
  - 区分噪声点 / 光斑 / 实体物体。

这两个完全可以叠加：
你现在的输出是：

text
[mean_feat, density, range]   # mean_feat 是 (x,y,z,intensity,...) 的均值

下一步就是变成：

text
[mean_feat, density, range, intensity_hist_or_stats...]

3. 怎么在现有 PDVMeanVFE 上加 Intensity 直方图？

你现在的 PDVMeanVFE 大致是这样（我简化了一下，忽略注释）：

python
class PDVMeanVFE(VFETemplate):
    def __init__(self, model_cfg, num_point_features, voxel_size=None, point_cloud_range=None, **kwargs):
        super().__init__(model_cfg=model_cfg)
        ...
        self.num_point_features = num_point_features
        self.voxel_x, self.voxel_y, self.voxel_z = voxel_size
        self.pc_range = point_cloud_range
        self.voxel_volume = self.voxel_x * self.voxel_y * self.voxel_z
        self.use_xy_range = getattr(self.model_cfg, 'USE_XY_RANGE', True)
        self.density_log1p = getattr(self.model_cfg, 'DENSITY_LOG1P', True)
        self.range_scale = getattr(self.model_cfg, 'RANGE_SCALE', 1.0)

    def get_output_feature_dim(self):
        return self.num_point_features + 2  # density + range

    @torch.no_grad()
    def _compute_voxel_center(self, coords, dtype):
        ...

    def forward(self, batch_dict, **kwargs):
        voxels = batch_dict['voxels']           # (M, T, C)
        voxel_num_points = batch_dict['voxel_num_points']  # (M,)
        coords = batch_dict['voxel_coords']     # (M,4)

        points_sum = voxels.sum(dim=1)
        normalizer = torch.clamp_min(voxel_num_points.view(-1, 1), 1.0).type_as(voxels)
        mean_feat = points_sum / normalizer     # (M, C)

        density = voxel_num_points.type_as(voxels) / self.voxel_volume
        if self.density_log1p:
            density = torch.log1p(density)

        x_center, y_center, z_center = self._compute_voxel_center(coords, voxels.dtype)
        if self.use_xy_range:
            rng = torch.sqrt(x_center * x_center + y_center * y_center)
        else:
            rng = torch.sqrt(x_center * x_center + y_center * y_center + z_center * z_center)
        if self.range_scale != 1.0:
            rng = rng / float(self.range_scale)

        voxel_features = torch.cat(
            [mean_feat, density.unsqueeze(1), rng.unsqueeze(1)],
            dim=1
        ).contiguous()

        batch_dict['voxel_features'] = voxel_features
        return batch_dict

3.1 我的建议：新建一个 `PDVIntensityVFE` 类（在原文件上加功能）

在同一个 pdv_mean_vfe.py 文件里，把类改名/新建为 PDVIntensityVFE，在 __init__ 里多加几个配置项：

python
class PDVIntensityVFE(VFETemplate):
    def __init__(self, model_cfg, num_point_features, voxel_size=None, point_cloud_range=None, **kwargs):
        super().__init__(model_cfg=model_cfg)

        if voxel_size is None:
            voxel_size = kwargs.get('voxel_size', None)
        if point_cloud_range is None:
            point_cloud_range = kwargs.get('point_cloud_range', None)
        assert voxel_size is not None and point_cloud_range is not None

        self.num_point_features = num_point_features
        self.voxel_x, self.voxel_y, self.voxel_z = voxel_size
        self.pc_range = point_cloud_range
        self.voxel_volume = self.voxel_x * self.voxel_y * self.voxel_z

        # PDV 部分
        self.use_xy_range = getattr(self.model_cfg, 'USE_XY_RANGE', True)
        self.density_log1p = getattr(self.model_cfg, 'DENSITY_LOG1P', True)
        self.range_scale = getattr(self.model_cfg, 'RANGE_SCALE', 1.0)

        # intensity 相关配置
        self.intensity_idx = getattr(self.model_cfg, 'INTENSITY_IDX', 3)   # 一般 xyzI 里 I = 3
        self.num_hist_bins = getattr(self.model_cfg, 'NUM_HIST_BINS', 8)
        self.hist_min = getattr(self.model_cfg, 'HIST_MIN', 0.0)
        self.hist_max = getattr(self.model_cfg, 'HIST_MAX', 1.0)

注意：如果你数据里 intensity 是 0–255，就把 HIST_MAX 设成 255.0；如果已经归一化到 [0,1]，就保持 1.0。

然后更新输出维度：

python
    def get_output_feature_dim(self):
        # 原始 C + 2(PDV) + num_hist_bins(IVE)
        return self.num_point_features + 2 + self.num_hist_bins

3.2 在 `forward` 里加直方图

紧接着你现在的 mean/density/range 之后，加一段 intensity 直方图：

python
    def forward(self, batch_dict, **kwargs):
        voxels = batch_dict['voxels']                 # (M, T, C)
        voxel_num_points = batch_dict['voxel_num_points']  # (M,)
        coords = batch_dict['voxel_coords']           # (M, 4)

        points_sum = voxels.sum(dim=1)                # (M, C)
        normalizer = torch.clamp_min(
            voxel_num_points.view(-1, 1), 1.0
        ).type_as(voxels)
        mean_feat = points_sum / normalizer           # (M, C)

        # ---------- PDV: density ----------
        density = voxel_num_points.type_as(voxels) / self.voxel_volume
        if self.density_log1p:
            density = torch.log1p(density)

        # ---------- PDV: range ----------
        x_center, y_center, z_center = self._compute_voxel_center(coords, voxels.dtype)
        if self.use_xy_range:
            rng = torch.sqrt(x_center * x_center + y_center * y_center)
        else:
            rng = torch.sqrt(x_center * x_center + y_center * y_center + z_center * z_center)
        if self.range_scale != 1.0:
            rng = rng / float(self.range_scale)

        # ---------- IVE: intensity histogram ----------
        # 取出强度通道 (M, T)
        intensity = voxels[:, :, self.intensity_idx]

        M, T = intensity.shape
        device = intensity.device

        # 只对真实点做统计（> num_points 的位置是 padding）
        idx = torch.arange(T, device=device).view(1, -1)
        valid_mask = idx < voxel_num_points.view(-1, 1)   # (M, T) bool

        # 限制在 [hist_min, hist_max] 范围
        intensity = torch.clamp(intensity, self.hist_min, self.hist_max)

        # 计算 K 段区间
        edges = torch.linspace(self.hist_min, self.hist_max, self.num_hist_bins + 1, device=device)
        denom = torch.clamp_min(voxel_num_points.type_as(voxels), 1.0)

        hist_list = []
        for k in range(self.num_hist_bins):
            lower = edges[k]
            upper = edges[k + 1] + (1e-6 if k == self.num_hist_bins - 1 else 0.0)

            bin_mask = valid_mask & (intensity >= lower) & (intensity < upper)
            # 统计该 bin 内点数 / num_points，得到频率
            bin_count = bin_mask.float().sum(dim=1) / denom
            hist_list.append(bin_count.view(-1, 1))

        hist_feat = torch.cat(hist_list, dim=1)   # (M, K)

        # ---------- 拼接所有特征 ----------
        voxel_features = torch.cat(
            [mean_feat, density.unsqueeze(1), rng.unsqueeze(1), hist_feat],
            dim=1
        ).contiguous()

        batch_dict['voxel_features'] = voxel_features
        return batch_dict

这段代码做的就是你说的 “Intensity‑Aware Voxel Encoder（直方图）” 的工程版：对每个 voxel 的 intensity 做 K 段直方图，最后拼成一个 K 维特征。

3.3 注册 & 配置修改（和之前 PDVMeanVFE 一样）

在 pcdet/models/backbones_3d/vfe/__init__.py 里：

python
from .pdv_mean_vfe import PDVIntensityVFE

__all__.update({
    'PDVIntensityVFE': PDVIntensityVFE,
})

在你的 VoxelNeXt 配置 里，把 VFE 改成：

yaml
MODEL:
  VFE:
    NAME: PDVIntensityVFE
    USE_XY_RANGE: True
    DENSITY_LOG1P: True
    RANGE_SCALE: 160.0        # 前向 160m，或者 120 之类
    INTENSITY_IDX: 3          # xyzI 顺序
    NUM_HIST_BINS: 8          # 可以先 8，看效果再增加
    HIST_MIN: 0.0             # intensity 范围
    HIST_MAX: 1.0             # 如果你的 intensity 已经归一化

不用手工改 backbone 的输入通道数，get_output_feature_dim 会自动告诉 backbone“我现在多了 K+2 维”。

4. 这一步对结果的预期

PDV VFE 已经把 Drone/Bird 提升得挺明显，但 Plastic_sheet / Kite 还比较差，这两个目标很多时候在 geometry 上特别难，但在 强度分布上往往有特点（薄膜、绸带、小物体、反光特性跟轨道/车体不同）。
Intensity 直方图会让模型更容易学到：“某一类目标在 intensity 上主要集中在哪些 bins”，有机会拉升 Plastic_sheet、Kite、Bird 这几类的 AP。
计算量：直方图部分是 K 次简单的逐点比较 + 求和，对 8 或 16 个 bin 来说开销很小，不太会明显拖慢你 60+ FPS 的推理。

一句总结

基线继续用：VoxelNeXt + 现在这版 PDV VFE；
下一步就按上面代码，把 VFE 升级成 PDVIntensityVFE，在特征维度上加上 intensity 直方图；
做完这一步，你就有了一个“Density + Range + Intensity‑Histogram 的体素编码”，可以专门看一下 Plastic_sheet / Kite / Bird 几类的提升情况。

如果你愿意，把你现在 VoxelNeXt 的 yaml（特别是 MODEL: 那一大段）贴出来一份，我可以直接在上面帮你改成一份“完整可跑的 PDVIntensityVFE 配置”，你只要复制就能训。

Answer 8

从你新截图这一行看（我按列顺序理解为 mAR / mAP / FPS / Drone / Plastic_sheet / Kite / Balloon / Bird）：

加入强度直方图后：mAR≈59，mAP≈44.306，FPS≈62
对比你上一版（PDV density/range 的 VFE）：mAR≈58.91，mAP≈43.90，FPS≈64
→ 整体 mAP 只涨了 ~0.4，属于“小幅有效但不惊艳”；但分类别是有变化的：Plastic_sheet 明显涨（13.79→18.02），Kite 反而掉了些。

结论：强度模块不用“死磕”

它现在的表现更像“对某些材质类目标有帮助，但不是主瓶颈”。建议你把它当作一个可保留的弱增益模块，最多再做一次“低成本纠偏”，然后把精力转到更大收益的方向。

1）强度直方图为什么提升不大（最常见的 3 个原因）

强度没做距离衰减校正
激光强度通常随距离衰减、随入射角变化。你又已经加入了 range 特征，直方图容易学成“距离分桶”，增益就会被抵消。
MeanVFE 已经把 intensity mean 吃进去了
你原始 mean_feat 里包含 intensity 的均值（甚至还包含 padding 的影响方式），直方图等于“重复提供信息”，提升自然有限。
直方图对 Kite/Bird 这类稀疏小目标不稳定
点数太少时，直方图噪声大，容易让模型过拟合某些 bin，导致个别类别掉点。

2）对强度模块：只建议你做 1 个“可执行替换”，别无限优化

✅ 建议的替换：把“直方图”换成“强度统计 + 距离校正”（更稳、更便宜）

做法（放在你 VFE 里）：

先做一个强度距离校正（二选一就行）
- I_corr = log1p(I)（最稳）
- 或 I_corr = I * (range^2)（更“物理”，但要 clamp，防止远距离爆炸）
然后不要直方图，改成 4 个统计量（对小目标更稳定）：
- I_mean, I_std, I_max, I_min（都只统计 valid points）
最后拼接：[mean_feat, density, range, I_mean, I_std, I_max, I_min]

为什么这比直方图更可能涨分：

点很少时，统计量比直方图稳得多
计算更快
对材质差异（Plastic_sheet）仍然敏感

如果你愿意，我可以按你现有的 PDVIntensityVFE 代码，把“直方图那段”直接改成统计量那段，给你一份可直接替换粘贴的版本。

做完这一步，如果提升还是很小（<0.5 mAP），就可以正式停止在强度模块上投入了。

3）下一步该做什么？（比继续改强度更可能大涨的方向）

你现在的瓶颈更像是 小目标/远距离/稀疏点 + 类别不均衡，下面这些通常收益更大：

A. 训练数据侧：专门“喂小目标”（通常是最大收益）

DB Sampling / Copy-Paste（按类补齐）
把 Kite / Plastic_sheet / Bird / Drone 这种稀有类做数据库采样，强行提高出现频率。
（OpenPCDet 原生就支持 GT sampling，改配置就能做）
距离分段重采样
把 80–160m 的目标在训练里权重拉高（或者做分段采样），否则模型很容易只优化近处。

这两条往往比你在 VFE 上“加十个特征”都更有效。

B. 模型侧：保分辨率（对小目标非常关键）

VoxelNeXt 很快，但如果 backbone 下采样过猛，小目标直接在特征图里消失。你可以尝试：

减少一次下采样 / 或把某个 stage stride 调小
让最终用于 head 的特征更“细”

这类改动对 mAR/mAP 往往是实打实的提升（代价是 FPS 可能掉一点，但你现在 60+ 还有空间）。

C. Head/打分侧：IoU-aware（常见“白捡”提升）

加一个 IoU 分支，推理用 score = cls * iou
这个对“小目标排序”和减少假阳性很有效，通常提升比强度直方图更稳定。

D. 多帧融合（Tele-15 场景尤其推荐）

Tele-15 的点云天然存在“单帧稀疏/不均匀”，2~3 帧融合经常能明显抬小目标 recall（尤其 Bird/Kite 这种点太少的）。

给你一个最省时间的执行顺序（建议你就按这个跑）

强度模块最后一试：直方图 → 强度统计（mean/std/min/max）+ log1p(I)
立刻上 DB Sampling / 类均衡采样（优先给 Kite/Plastic_sheet/Bird）
做距离分段采样或 loss 加权（优先远距离段）
再改 stride/下采样（保分辨率）
加 IoU-aware score
最后上 2~3 帧融合

如果你把你现在 **VoxelNeXt 的 yaml（DATA_AUGMENTOR 那段 + MODEL head 那段）**贴出来，我可以直接告诉你：

DB sampling / 类均衡具体在哪几行开、每类配多少采样数
VoxelNeXt backbone 哪一层改 stride 最“划算”
IoU-aware 分支在 OpenPCDet 里通常怎么加（改哪些文件/哪些输出）

Answer 9

你现在这套 CenterPoint +（VoxelResBackBone8x）+ PDV( density/range ) + intensity-hist VFE 能跑到 mAP 54.592 / mAR 67.25 / FPS 89，已经是一个很强、而且“改动可控”的基线了。下一步如果在你列的这些方向里选一个最值得先做、成功率最高的，我会选：

我更推荐你先做：CenterPoint-SAE（改 BEV neck / 2D backbone）

理由：

最贴合你当前结构：你现在就是 HeightCompression -> BaseBEVBackbone -> CenterHead。SAE的核心改动就是替换/改造 BEV 侧的 backbone+neck，对你侵入最小，基本不碰 3D backbone、VFE、head 的接口。(DBLP)
更直接解决“小目标在 BEV 特征里不显著”的问题：你现在 FEATURE_MAP_STRIDE=8，小目标（Bird/Kite/Plastic_sheet）在热力图上很容易变成“几个像素的点”。SAE的多尺度/FPN式增强通常比你继续在 VFE 上加统计特征更有效。(DBLP)
速度风险可控：你现在 89 FPS，有足够余量；SAE 用轻量卷积（GS-Conv/ghost+shuffle 思路）本质是在 2D BEV 上做增强，通常比上 3D sparse Transformer 省。(DBLP)

顺便确认一下：CenterPoint-SAE 这篇作者是 Xinyu Sun 等，并不是你之前要求避开的那位作者体系。(DBLP)

你落地怎么做（可执行步骤）

保留你现在 VFE / 3D backbone / CenterHead 不动
新建一个 pcdet/models/backbones_2d/sae_bev_backbone.py（或直接复制 base_bev_backbone.py 改）
- 把其中的普通 ConvBlock 替换为 GS-Conv 风格的轻量块（ghost conv + channel shuffle），并把 FPN 融合做得更“偏小目标”（更强调浅层特征的上采样融合）。
在 pcdet/models/backbones_2d/__init__.py 注册新 backbone

配置里把

yaml
BACKBONE_2D:
  NAME: BaseBEVBackbone

改成

yaml
BACKBONE_2D:
  NAME: SAEBaseBEVBackbone   # 你注册的新名字

优先观察三类指标：
- Bird/Kite 的 recall 是否上升
- 误检是否增加（尤其 Drone/Balloon）
- FPS 下降多少（你有富余，掉到 60+ 也仍然能接受）

其他选项我怎么排优先级（按“你现在的 CenterPoint 结构”）

第二优先：Region-aligned（替换 HeightCompression 的思路）

这类方法针对 “Sparse→BEV 压缩导致高度结构信息损失/对齐不好”，对你这种 Z 范围小但目标形态不规则 的场景确实可能有收益。(ScienceDirect)
但它比 SAE 更侵入：你要动 MAP_TO_BEV 的实现和特征对齐方式，调参周期更长。建议 SAE 做完、收益吃到以后再上。

第三优先：PST-FPN（VSAC 那套）

VSAC 是在 CenterPoint 风格上加 voxel self-attention + “伪时空 FPN”，思路没问题，作者也不是你之前避开的那位。(ScienceDirect)
但对你来说它的工程风险在于：你需要更明确它“伪时空”的输入到底来自哪里（多帧？还是特征重排？），否则很容易变成“做了一堆结构但收益不稳定”。我会放在 SAE/Region-aligned 之后。

暂时不建议你现在用在 CenterPoint 上：MsSVT / VoTr / VoxSeT（稀疏 3D Transformer）

这些更适合 VoxelNeXt/FSD 这类 fully sparse 3D pipeline，你现在是 CenterPoint 的 “voxel 3D backbone + 压 BEV + 2D head”。
要把 sparse transformer 融进 VoxelResBackBone8x，改动大、调参也更难，且对 FPS 打击不确定（你现在 89 FPS 很香，别轻易用重锤）。VoTr 本身是 voxel transformer 检测框架，工程迁移成本会更高。([AAAI Open Access

](https://ojs.aaai.org/index.php/AAAI/article/download/16470/16277?utm_source=chatgpt.com))

关于你现在的 VFE：要不要继续死磕？

你已经证明“VFE 加 density/range/intensity”能带来收益，但它现在更像辅助项。
下一步我不建议你在直方图上无限迭代；更值钱的是 BEV 多尺度表达（SAE）和 更细的输出分辨率/更适合小目标的热力图设定。

小提醒：你配置里写的是 VFE: NAME: PDVMeanVFE，但类里实际上已经包含 intensity-hist 了——为了后续不混乱，建议你把类名/配置名统一成 PDVIntensityVFE（纯工程可维护性问题，不影响结果）。

你如果同意走 SAE 路线

把你当前的 BaseBEVBackbone 源码（pcdet/models/backbones_2d/base_bev_backbone.py）贴出来，或者告诉我你 OpenPCDet 的具体版本/分支（有些文件结构略有差异），我可以按你的代码结构给你一个“最小改动版 SAE backbone”的落地改法：改哪些层、输出通道怎么对齐、config 怎么写，保证你直接能跑起来。

Answer 10

你现在的 BaseBEVBackbone 本质上就是 CenterPoint 原版 neck：把多尺度特征直接上采样到同一尺寸后 concat，并没有区分不同尺度特征对输出的贡献。论文里明确指出这是原版 CenterPoint neck 的问题，并提出 BGC neck = 简化 BiFPN（带可学习权重的快速归一化融合）+ GS-Conv + size conversion concat 来做跨尺度交互再对齐拼接。 (1-s2.0-S0141938224001859-main.pdf)

下面我给你一份能直接在 OpenPCDet 跑起来的实现：把你的 BaseBEVBackbone 替换为一个 “SAE-BGC 版 BEV backbone/neck”（只动 2D BEV 部分，HeightCompression 不用改）。

1) 新增文件：`pcdet/models/backbones_2d/sae_bgc_bev_backbone.py`

这个实现做了论文 BGC 的关键点：

fast normalized weighted fusion（公式(1) 那个权重归一化融合） (1-s2.0-S0141938224001859-main.pdf)

GS-Conv（标准卷积 + 深度可分离卷积 + shuffle 混合通道信息） (1-s2.0-S0141938224001859-main.pdf)

融合后仍然用你原来那套 deblocks 做 size conversion + concat（对应论文“size conversion concatenation module”） (1-s2.0-S0141938224001859-main.pdf)

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


def channel_shuffle(x: torch.Tensor, groups: int = 2) -> torch.Tensor:
    # x: (B, C, H, W)
    b, c, h, w = x.size()
    assert c % groups == 0
    x = x.view(b, groups, c // groups, h, w)
    x = x.transpose(1, 2).contiguous()
    return x.view(b, c, h, w)


class ConvBNReLU(nn.Module):
    def __init__(self, in_c, out_c, k=3, s=1, p=1, groups=1):
        super().__init__()
        self.conv = nn.Conv2d(in_c, out_c, k, s, p, groups=groups, bias=False)
        self.bn = nn.BatchNorm2d(out_c, eps=1e-3, momentum=0.01)
        self.act = nn.ReLU()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))


class GSConv(nn.Module):
    """
    GS-Conv: 标准卷积 + 深度可分离卷积 + shuffle
    论文描述：标准卷积和 depth-wise separable conv 顺序执行，然后 concat + shuffle。 (1-s2.0-S0141938224001859-main.pdf)
    """
    def __init__(self, in_c, out_c, k=3, s=1, p=1, shuffle_groups=2):
        super().__init__()
        assert out_c % 2 == 0, "GSConv requires even out_channels"
        mid = out_c // 2
        self.conv1 = ConvBNReLU(in_c, mid, k=1, s=1, p=0)
        self.dwconv = ConvBNReLU(mid, mid, k=k, s=s, p=p, groups=mid)
        self.shuffle_groups = shuffle_groups

    def forward(self, x):
        x1 = self.conv1(x)
        x2 = self.dwconv(x1)
        out = torch.cat([x1, x2], dim=1)
        return channel_shuffle(out, groups=self.shuffle_groups)


class FastNormalizedFusion(nn.Module):
    """
    fast normalized weighted fusion:
      O = sum(w_i * I_i) / (eps + sum(w_i))
    论文公式(1)。 (1-s2.0-S0141938224001859-main.pdf)
    """
    def __init__(self, n_inputs: int, eps: float = 1e-4):
        super().__init__()
        self.eps = eps
        self.w = nn.Parameter(torch.ones(n_inputs, dtype=torch.float32), requires_grad=True)

    def forward(self, inputs):
        assert len(inputs) == len(self.w)
        w = F.relu(self.w)
        denom = w.sum() + self.eps
        out = 0.0
        for i, x in enumerate(inputs):
            out = out + (w[i] / denom) * x
        return out


class SimplifiedBiFPN_GS(nn.Module):
    """
    简化 BiFPN + GS-Conv（论文 BGC neck 核心） (1-s2.0-S0141938224001859-main.pdf)
    支持 2-level 或 3-level。
    """
    def __init__(self, channels: int, num_levels: int, eps: float = 1e-4):
        super().__init__()
        assert num_levels in [2, 3]
        self.num_levels = num_levels

        # 每个融合点：先权重融合，再 GS-Conv 进一步交互（论文说 GS-Conv 用于进一步融合） (1-s2.0-S0141938224001859-main.pdf)
        if num_levels == 2:
            self.fuse_p_low = FastNormalizedFusion(2, eps=eps)
            self.gs_low = GSConv(channels, channels)
            self.fuse_p_high = FastNormalizedFusion(2, eps=eps)
            self.gs_high = GSConv(channels, channels)
        else:
            self.fuse_p4_td = FastNormalizedFusion(2, eps=eps)
            self.gs_p4_td = GSConv(channels, channels)

            self.fuse_p3_td = FastNormalizedFusion(2, eps=eps)
            self.gs_p3_td = GSConv(channels, channels)

            # 中间尺度更关键：我们给 p4_out 融合 3 路（p4_in + p4_td + down(p3_td)），也对应论文“中间尺度更关键”的直觉 (1-s2.0-S0141938224001859-main.pdf)
            self.fuse_p4_out = FastNormalizedFusion(3, eps=eps)
            self.gs_p4_out = GSConv(channels, channels)

            self.fuse_p5_out = FastNormalizedFusion(2, eps=eps)
            self.gs_p5_out = GSConv(channels, channels)

    def forward(self, feats):
        # feats: list of tensors, ordered from low-level(high-res) -> high-level(low-res)
        if self.num_levels == 2:
            p3, p4 = feats
            p3_td = self.gs_low(self.fuse_p_low([p3, F.interpolate(p4, size=p3.shape[-2:], mode='nearest')]))
            p4_out = self.gs_high(self.fuse_p_high([p4, F.max_pool2d(p3_td, kernel_size=2, stride=2)]))
            return [p3_td, p4_out]

        p3, p4, p5 = feats
        p4_td = self.gs_p4_td(self.fuse_p4_td([p4, F.interpolate(p5, size=p4.shape[-2:], mode='nearest')]))
        p3_td = self.gs_p3_td(self.fuse_p3_td([p3, F.interpolate(p4_td, size=p3.shape[-2:], mode='nearest')]))

        p4_out = self.gs_p4_out(self.fuse_p4_out([p4, p4_td, F.max_pool2d(p3_td, kernel_size=2, stride=2)]))
        p5_out = self.gs_p5_out(self.fuse_p5_out([p5, F.max_pool2d(p4_out, kernel_size=2, stride=2)]))
        return [p3_td, p4_out, p5_out]


class SAEBGCBEVBackbone(nn.Module):
    """
    给 OpenPCDet 用的 CenterPoint-SAE(BGC neck) 版本：
    - blocks: 仍然按你 BaseBEVBackbone 的方式抽取多尺度 BEV 特征
    - 先把每个尺度通道对齐到 BIFPN_CHANNELS（论文里 CSP 做通道对齐，我们用 1x1 conv 近似） (1-s2.0-S0141938224001859-main.pdf)
    - 简化 BiFPN + GS-Conv 融合
    - deblocks 做 size conversion，再 concat 输出统一尺度特征 (1-s2.0-S0141938224001859-main.pdf)
    """
    def __init__(self, model_cfg, input_channels):
        super().__init__()
        self.model_cfg = model_cfg

        assert self.model_cfg.get('LAYER_NUMS', None) is not None
        layer_nums = self.model_cfg.LAYER_NUMS
        layer_strides = self.model_cfg.LAYER_STRIDES
        num_filters = self.model_cfg.NUM_FILTERS

        upsample_strides = self.model_cfg.UPSAMPLE_STRIDES
        num_upsample_filters = self.model_cfg.NUM_UPSAMPLE_FILTERS

        num_levels = len(layer_nums)
        assert num_levels in [2, 3], "BGC实现建议用 2 或 3 个尺度"
        self.num_levels = num_levels

        # BiFPN 统一通道数（建议设成 256，和你现在 num_upsample_filters 匹配）
        self.bifpn_channels = int(getattr(self.model_cfg, 'BIFPN_CHANNELS', max(num_upsample_filters)))
        self.bifpn_eps = float(getattr(self.model_cfg, 'BIFPN_EPS', 1e-4))

        c_in_list = [input_channels, *num_filters[:-1]]
        self.blocks = nn.ModuleList()
        for idx in range(num_levels):
            cur_layers = [
                nn.ZeroPad2d(1),
                nn.Conv2d(
                    c_in_list[idx], num_filters[idx], kernel_size=3,
                    stride=layer_strides[idx], padding=0, bias=False
                ),
                nn.BatchNorm2d(num_filters[idx], eps=1e-3, momentum=0.01),
                nn.ReLU()
            ]
            for _ in range(layer_nums[idx]):
                cur_layers.extend([
                    nn.Conv2d(num_filters[idx], num_filters[idx], kernel_size=3, padding=1, bias=False),
                    nn.BatchNorm2d(num_filters[idx], eps=1e-3, momentum=0.01),
                    nn.ReLU()
                ])
            self.blocks.append(nn.Sequential(*cur_layers))

        # 通道对齐（近似论文 CSP 对齐）
        self.align_convs = nn.ModuleList([
            nn.Sequential(
                nn.Conv2d(num_filters[i], self.bifpn_channels, kernel_size=1, bias=False),
                nn.BatchNorm2d(self.bifpn_channels, eps=1e-3, momentum=0.01),
                nn.ReLU()
            )
            for i in range(num_levels)
        ])

        self.bifpn = SimplifiedBiFPN_GS(self.bifpn_channels, num_levels=num_levels, eps=self.bifpn_eps)

        # size conversion（复用你原来的 deblocks 逻辑，但输入通道改为 bifpn_channels）
        self.deblocks = nn.ModuleList()
        for idx in range(num_levels):
            stride = upsample_strides[idx]
            out_c = num_upsample_filters[idx]

            if stride > 1 or (stride == 1 and not self.model_cfg.get('USE_CONV_FOR_NO_STRIDE', False)):
                self.deblocks.append(nn.Sequential(
                    nn.ConvTranspose2d(
                        self.bifpn_channels, out_c,
                        upsample_strides[idx],
                        stride=upsample_strides[idx], bias=False
                    ),
                    nn.BatchNorm2d(out_c, eps=1e-3, momentum=0.01),
                    nn.ReLU()
                ))
            else:
                # stride < 1 的情况
                s = int(np.round(1 / stride))
                self.deblocks.append(nn.Sequential(
                    nn.Conv2d(self.bifpn_channels, out_c, s, stride=s, bias=False),
                    nn.BatchNorm2d(out_c, eps=1e-3, momentum=0.01),
                    nn.ReLU()
                ))

        c_in = sum(num_upsample_filters)
        if len(upsample_strides) > num_levels:
            self.deblocks.append(nn.Sequential(
                nn.ConvTranspose2d(c_in, c_in, upsample_strides[-1], stride=upsample_strides[-1], bias=False),
                nn.BatchNorm2d(c_in, eps=1e-3, momentum=0.01),
                nn.ReLU(),
            ))

        self.num_bev_features = c_in

    def forward(self, data_dict):
        spatial_features = data_dict['spatial_features']
        x = spatial_features

        feats = []
        for i in range(len(self.blocks)):
            x = self.blocks[i](x)
            feats.append(x)

        # 对齐通道 -> BiFPN 融合
        feats = [self.align_convs[i](feats[i]) for i in range(self.num_levels)]
        feats = self.bifpn(feats)

        # size conversion + concat（对应论文 size conversion concatenation） (1-s2.0-S0141938224001859-main.pdf)
        ups = []
        for i in range(self.num_levels):
            ups.append(self.deblocks[i](feats[i]))

        x = torch.cat(ups, dim=1) if len(ups) > 1 else ups[0]
        if len(self.deblocks) > self.num_levels:
            x = self.deblocks[-1](x)

        data_dict['spatial_features_2d'] = x
        return data_dict

2) 注册模块

编辑：pcdet/models/backbones_2d/__init__.py

加入：

python
from .sae_bgc_bev_backbone import SAEBGCBEVBackbone

并确保 __all__ 或构建器能找到这个类（不同版本 OpenPCDet 写法不同，你按你工程原来的注册方式加进去即可）。

3) 修改你的 YAML（最小改动版：不改层数，只换 neck）

你现在 BACKBONE_2D 改成：

yaml
BACKBONE_2D:
    NAME: SAEBGCBEVBackbone

    LAYER_NUMS: [5, 5]
    LAYER_STRIDES: [1, 2]
    NUM_FILTERS: [128, 256]

    UPSAMPLE_STRIDES: [1, 2]
    NUM_UPSAMPLE_FILTERS: [256, 256]

    # 新增
    BIFPN_CHANNELS: 256
    BIFPN_EPS: 0.0001

这版就是把论文说的“给不同尺度加权融合 + GS-Conv 交互”加进去（原文：引入改造 BiFPN + GS-Conv，并使用可学习权重衡量不同分辨率特征贡献）。 (1-s2.0-S0141938224001859-main.pdf)

4) 更“贴论文”的建议：把 2-level 改成 3-level（更推荐）

论文是 3 个尺度做 BGC，并强调“最终对齐到中间尺度更关键”。 (1-s2.0-S0141938224001859-main.pdf)
你要更接近论文结构，可以把 BACKBONE_2D 调成 3 个 stage：

yaml
BACKBONE_2D:
    NAME: SAEBGCBEVBackbone

    LAYER_NUMS: [5, 5, 3]
    LAYER_STRIDES: [1, 2, 2]
    NUM_FILTERS: [128, 256, 256]

    UPSAMPLE_STRIDES: [1, 2, 4]
    NUM_UPSAMPLE_FILTERS: [256, 256, 256]

    BIFPN_CHANNELS: 256
    BIFPN_EPS: 0.0001

这会更像论文的三尺度融合流程（你 FPS 很富余，通常扛得住）。

5) 你问“按论文还要不要改 HeightCompression / backbone？”

论文的另外一条线是 SSDCM backbone：用 SPD-Conv 避免 stride conv 丢信息、DO-Conv 提升表征、Coordinate Attention 建立长距依赖。 (1-s2.0-S0141938224001859-main.pdf)
但它是针对 2D pseudo-image backbone（pillar encoder 后） 的。你现在是 voxel 3D backbone + HeightCompression，所以我建议顺序是：

先上 BGC neck（上面这份代码）：最贴你现有结构、风险最低
再考虑“Region-aligned / 替换 HeightCompression”那条（你之前也提到过）

6) 你怎么验证你改对了（很关键）

跑起来后，检查三件事：

model.backbone_2d.num_bev_features 是否还是 512（或你期望的值）
data_dict['spatial_features_2d'] 的 spatial size 是否和原来一致（通常 stride=8 对齐 CenterHead）
训练时 loss 正常下降，且不会出现维度 mismatch（最常见的是 BIFPN_CHANNELS 没对齐导致）

如果你希望我把这套 直接改成“最接近论文 Fig.6 的 BGC 图结构”（包括它提到的“去掉最大/最小尺度某些中间节点、给中间尺度加额外边”那种更严格的拓扑），你把你当前训练用的 **LAYER_NUMS/LAYER_STRIDES/NUM_FILTERS/UPSAMPLE_STRIDES 的最终版本（你打算用 2-level 还是 3-level）**确定一下，我就按那个尺度拓扑把 SimplifiedBiFPN_GS 精确化。

Answer 11

这个报错的根因很明确：做“加权融合”时，两个输入特征图的空间尺寸不一致（比如 H=13 和 H=12），导致 out + w*x 直接炸了。

你现在的错误发生在这一句（p5_out 那里）：

python
p5_out = self.gs_p5_out(self.fuse_p5_out([p5, F.max_pool2d(p4_out, kernel_size=2, stride=2)]))

F.max_pool2d(stride=2) 在遇到 奇数尺寸 的特征图时会 向下取整，所以 p4_out 下采样后不一定正好等于 p5 的尺寸（这在 BEV 尺寸不是 2 的幂、或某层 stride 之后出现 odd size 时很常见）。而论文里的 fast normalized fusion 公式(1)要求参与融合的特征必须对齐到同一尺寸。(1-s2.0-S0141938224001859-main.pdf)

✅ 最稳的修法：所有“downsample”都改成按目标尺寸对齐

把 “pool by 2” 改成 adaptive pool 到 ref 的 shape（不会再出现 13/12 这种错位）。

你要改的文件

pcdet/models/backbones_2d/sae_bgc_bev_backbone.py

1）在 `SimplifiedBiFPN_GS` 里加两个对齐函数

把下面代码加到 class SimplifiedBiFPN_GS(nn.Module): 里面（例如 forward 上方）：

python
@staticmethod
def _up_to(x, ref):
    # 上采样到 ref 的 H,W
    if x.shape[-2:] != ref.shape[-2:]:
        x = F.interpolate(x, size=ref.shape[-2:], mode='nearest')
    return x

@staticmethod
def _down_to(x, ref):
    # 下采样到 ref 的 H,W（避免 odd size 的 floor 导致 13/12 不一致）
    if x.shape[-2:] != ref.shape[-2:]:
        x = F.adaptive_max_pool2d(x, output_size=ref.shape[-2:])
    return x

2）把 forward 里所有 `max_pool2d(...)` 替换成 `_down_to(...)`

把 forward（num_levels==3 的分支）改成下面这样（只展示需要改的关键几行）：

python
p3, p4, p5 = feats

p4_td = self.gs_p4_td(self.fuse_p4_td([p4, self._up_to(p5, p4)]))
p3_td = self.gs_p3_td(self.fuse_p3_td([p3, self._up_to(p4_td, p3)]))

p4_out = self.gs_p4_out(self.fuse_p4_out([p4, p4_td, self._down_to(p3_td, p4)]))
p5_out = self.gs_p5_out(self.fuse_p5_out([p5, self._down_to(p4_out, p5)]))

return [p3_td, p4_out, p5_out]

如果你用的是 num_levels==2（两尺度），同理把那里的 max_pool2d 改为：

python
p3_td = self.gs_low(self.fuse_p_low([p3, self._up_to(p4, p3)]))
p4_out = self.gs_high(self.fuse_p_high([p4, self._down_to(p3_td, p4)]))

为什么这样改符合论文思路？

论文的 BGC neck 本质是 跨尺度 bidirectional flow + 可学习权重融合，再用 GS-Conv 做进一步融合，并强调多尺度特征需要对齐、再进入后续 size conversion + concat。(1-s2.0-S0141938224001859-main.pdf)
你现在的问题只是在工程实现上：下采样方式导致尺寸无法严格对齐，用 adaptive_max_pool2d 直接对齐到目标尺寸是最稳妥的实现方式（不会破坏公式(1)的“对齐后融合”假设）。(1-s2.0-S0141938224001859-main.pdf)

你改完后如何快速确认没坑（建议你做一次）

在 SimplifiedBiFPN_GS.forward 里临时打印一次 shape（跑 1 iter 就关掉）：

python
if not hasattr(self, "_printed"):
    print("p3", p3.shape, "p4", p4.shape, "p5", p5.shape)
    self._printed = True

只要你看到 _down_to(p4_out, p5) 输出和 p5 完全一样，就不会再报错。

如果你把你现在 BACKBONE_2D 的三层配置（LAYER_NUMS/STRIDES/FILTERS/UPSAMPLE_STRIDES）贴一下，我还可以顺手帮你检查：哪一层最容易产生 odd size，以及是否需要把某个 stride/upsample 调整得更“规整”，让 BEV 金字塔更稳定。

Answer 12

这个报错和上一个一样，本质还是 多尺度特征在拼接前没有严格对齐到同一张 BEV 尺寸。

这次炸在：

python
x = torch.cat(ups, dim=1)
# ups 里第 3 个张量 H/W 是 52，而其它是 50

原因：ConvTranspose2d 在输入特征尺寸出现 odd/不整除时，输出尺寸可能会差 1～2 个像素（跟 kernel/stride 的组合有关），所以不同 level 的 deblocks[i](feat[i]) 不能保证永远同尺寸。

✅ 最简单且最稳的修法：cat 前统一把 ups resize 到同一尺寸

你要改哪里

文件：pcdet/models/backbones_2d/sae_bgc_bev_backbone.py

1）确保顶部有

python
import torch.nn.functional as F

2）在 `SAEBGCBEVBackbone.forward()` 里，生成 `ups` 后、cat 前插入对齐代码

把你当前这一段：

python
ups = []
for i in range(self.num_levels):
    ups.append(self.deblocks[i](feats[i]))

x = torch.cat(ups, dim=1) if len(ups) > 1 else ups[0]

改成：

python
ups = []
for i in range(self.num_levels):
    ups.append(self.deblocks[i](feats[i]))

# ---- 新增：对齐所有 ups 的空间尺寸（用第0层作为目标尺寸，通常是最高分辨率）----
target_hw = ups[0].shape[-2:]
for i in range(len(ups)):
    if ups[i].shape[-2:] != target_hw:
        ups[i] = F.interpolate(ups[i], size=target_hw, mode='nearest')

x = torch.cat(ups, dim=1) if len(ups) > 1 else ups[0]

这一步能 100% 解决你现在的 Expected size 50 but got 52。

更“保守”的版本（可选）：用最大尺寸当 target，避免下采样

如果你担心把 52 resize 到 50 会丢一点边缘信息，可以改成对齐到 最大 H/W：

python
max_h = max([u.shape[-2] for u in ups])
max_w = max([u.shape[-1] for u in ups])
target_hw = (max_h, max_w)
ups = [u if u.shape[-2:] == target_hw else F.interpolate(u, size=target_hw, mode='nearest') for u in ups]

建议你顺手做一次 shape 打印（只跑 1 iter）

在 cat 前临时加：

python
if not hasattr(self, "_printed"):
    for i, u in enumerate(ups):
        print("ups[{}] shape = {}".format(i, tuple(u.shape)))
    self._printed = True

确认所有 ups 的 H/W 一致后再删掉。

额外提醒：为什么你会频繁遇到 odd size？

你 BaseBEVBackbone 里的每个 stage 首层是：

python
ZeroPad2d(1) + Conv2d(kernel=3, stride=..., padding=0)

这种写法在 stride=2 时对某些输入尺寸会产生 odd 尺寸链式传播；之后转置卷积上采样就容易出现 “差 1～2 像素”。所以 cat 前统一对齐 是最靠谱的工程解。

你把这处对齐加上后，如果还有新的报错（比如 CenterHead 的 heatmap size 对不上），把你当前 BACKBONE_2D 的 3-level 配置（LAYER_NUMS / LAYER_STRIDES / UPSAMPLE_STRIDES）贴一下，我会直接帮你把 stride/upsample 组合调成“天然不会出奇数尺寸”的那种结构。

Answer 13

你这个“上了 SAE/BGC neck 之后指标直接崩盘”，基本不是论文思路不行，而是“迁移方式 + 尺度/对齐/训练稳定性”出了问题。

论文里 BGC neck 是为 pillar pseudo-image + 3-stage SSDCM backbone 设计的：它强调 CenterPoint 原 neck “无差别上采样再 concat、不考虑各尺度贡献”，因此用 可学习权重融合 + GS-Conv + size conversion concat 来做跨尺度交互与对齐。(1-s2.0-S0141938224001859-main.pdf) 另外论文也明确说 backbone 与 neck 是协同的。(1-s2.0-S0141938224001859-main.pdf)
你现在是 voxel 3D backbone + HeightCompression 的 BEV，直接搬一个“类 BiFPN 拓扑”非常容易把 BEV 网格与标签映射（FEATURE_MAP_STRIDE=8）搞出细微错位；再加上你为了修 shape 用了 interpolate/adaptive pool，可能进一步引入“像素级偏移”，对 anchor-free 的 center heatmap 很致命。

下面给你一个“最稳的处理策略”：别硬上完整版 BiFPN，先做 SAE-lite（只做论文最核心、风险最低的点），确保不会把你 54.6 mAP 的基线毁掉。

先做：SAE-lite（推荐），只解决“各尺度贡献没区分”

论文批评点：原 neck “上采样到同一尺寸直接 concat，没考虑不同分辨率贡献”。(1-s2.0-S0141938224001859-main.pdf)
那我们先做一个几乎不会崩的替换：

仍用你原来的 blocks/deblocks
每个 up 分支乘一个可学习权重（fast normalized fusion 的简化版），再 concat
（论文公式是加权融合思想，权重归一化的动机一致。(1-s2.0-S0141938224001859-main.pdf)）
（可选）在 concat 后加一个 GS-Conv 轻量增强（论文解释 GS-Conv 的目的：缓解 depth-wise 通道信息分离，提升融合表达。(1-s2.0-S0141938224001859-main.pdf)）

代码：在 `BaseBEVBackbone` 上最小改动版

新建：pcdet/models/backbones_2d/sae_weighted_bev_backbone.py

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


def channel_shuffle(x, groups=2):
    b, c, h, w = x.shape
    assert c % groups == 0
    x = x.view(b, groups, c // groups, h, w).transpose(1, 2).contiguous()
    return x.view(b, c, h, w)


class ConvBNReLU(nn.Module):
    def __init__(self, in_c, out_c, k=3, s=1, p=1, groups=1):
        super().__init__()
        self.conv = nn.Conv2d(in_c, out_c, k, s, p, groups=groups, bias=False)
        self.bn = nn.BatchNorm2d(out_c, eps=1e-3, momentum=0.01)
        self.act = nn.ReLU()

    def forward(self, x):
        return self.act(self.bn(self.conv(x)))


class GSConv(nn.Module):
    """按论文描述：standard conv + depth-wise separable conv，然后 concat + shuffle。(1-s2.0-S0141938224001859-main.pdf)"""
    def __init__(self, in_c, out_c, k=3, s=1, p=1, shuffle_groups=2):
        super().__init__()
        assert out_c % 2 == 0
        mid = out_c // 2
        self.conv1 = ConvBNReLU(in_c, mid, k=1, s=1, p=0)
        self.dwconv = ConvBNReLU(mid, mid, k=k, s=s, p=p, groups=mid)
        self.shuffle_groups = shuffle_groups

    def forward(self, x):
        x1 = self.conv1(x)
        x2 = self.dwconv(x1)
        out = torch.cat([x1, x2], dim=1)
        return channel_shuffle(out, groups=self.shuffle_groups)


class SAEWeightedBEVBackbone(nn.Module):
    """
    SAE-lite:
      - 保持 CenterPoint 原来的 size conversion + concat 框架
      - 在 concat 前加“可学习权重”（解决论文指出的“不同尺度贡献未区分”问题）(1-s2.0-S0141938224001859-main.pdf)
      - 可选：concat 后加 GSConv
    """
    def __init__(self, model_cfg, input_channels):
        super().__init__()
        self.model_cfg = model_cfg

        layer_nums = self.model_cfg.LAYER_NUMS
        layer_strides = self.model_cfg.LAYER_STRIDES
        num_filters = self.model_cfg.NUM_FILTERS

        upsample_strides = self.model_cfg.UPSAMPLE_STRIDES
        num_upsample_filters = self.model_cfg.NUM_UPSAMPLE_FILTERS

        num_levels = len(layer_nums)
        c_in_list = [input_channels, *num_filters[:-1]]

        self.blocks = nn.ModuleList()
        self.deblocks = nn.ModuleList()

        for idx in range(num_levels):
            cur_layers = [
                nn.ZeroPad2d(1),
                nn.Conv2d(c_in_list[idx], num_filters[idx], kernel_size=3,
                          stride=layer_strides[idx], padding=0, bias=False),
                nn.BatchNorm2d(num_filters[idx], eps=1e-3, momentum=0.01),
                nn.ReLU()
            ]
            for _ in range(layer_nums[idx]):
                cur_layers.extend([
                    nn.Conv2d(num_filters[idx], num_filters[idx], kernel_size=3, padding=1, bias=False),
                    nn.BatchNorm2d(num_filters[idx], eps=1e-3, momentum=0.01),
                    nn.ReLU()
                ])
            self.blocks.append(nn.Sequential(*cur_layers))

            stride = upsample_strides[idx]
            if stride > 1 or (stride == 1 and not self.model_cfg.get('USE_CONV_FOR_NO_STRIDE', False)):
                self.deblocks.append(nn.Sequential(
                    nn.ConvTranspose2d(num_filters[idx], num_upsample_filters[idx],
                                       upsample_strides[idx], stride=upsample_strides[idx], bias=False),
                    nn.BatchNorm2d(num_upsample_filters[idx], eps=1e-3, momentum=0.01),
                    nn.ReLU()
                ))
            else:
                s = int(np.round(1 / stride))
                self.deblocks.append(nn.Sequential(
                    nn.Conv2d(num_filters[idx], num_upsample_filters[idx], s, stride=s, bias=False),
                    nn.BatchNorm2d(num_upsample_filters[idx], eps=1e-3, momentum=0.01),
                    nn.ReLU()
                ))

        self.fuse_eps = float(getattr(self.model_cfg, "FUSE_EPS", 1e-4))
        self.fuse_w = nn.Parameter(torch.ones(num_levels, dtype=torch.float32), requires_grad=True)

        self.use_post_gsconv = bool(getattr(self.model_cfg, "USE_POST_GSCONV", False))

        c_in = sum(num_upsample_filters)
        self.num_bev_features = c_in
        if self.use_post_gsconv:
            # concat 后轻量增强
            self.post = GSConv(c_in, c_in)

    def forward(self, data_dict):
        spatial_features = data_dict['spatial_features']
        x = spatial_features

        ups = []
        for i in range(len(self.blocks)):
            x = self.blocks[i](x)
            ups.append(self.deblocks[i](x))

        # ---- 关键：按论文“贡献度”思想做 fast normalized weighting（简化版）(1-s2.0-S0141938224001859-main.pdf)
        w = F.relu(self.fuse_w)
        w = w / (w.sum() + self.fuse_eps)

        target_hw = ups[0].shape[-2:]
        for i in range(len(ups)):
            # 只做“对齐尺寸”，不要做任意缩放比例；这里用 pad/crop 更稳（避免插值引入位置偏移）
            u = ups[i]
            if u.shape[-2:] != target_hw:
                th, tw = target_hw
                h, w0 = u.shape[-2:]
                # crop
                u = u[:, :, :min(h, th), :min(w0, tw)]
                # pad
                pad_h = th - u.shape[-2]
                pad_w = tw - u.shape[-1]
                if pad_h > 0 or pad_w > 0:
                    u = F.pad(u, (0, max(pad_w, 0), 0, max(pad_h, 0)))
                ups[i] = u

            ups[i] = ups[i] * w[i]

        out = torch.cat(ups, dim=1) if len(ups) > 1 else ups[0]
        if self.use_post_gsconv:
            out = self.post(out)

        data_dict['spatial_features_2d'] = out
        return data_dict

YAML 怎么改

yaml
BACKBONE_2D:
  NAME: SAEWeightedBEVBackbone
  LAYER_NUMS: [5, 5]
  LAYER_STRIDES: [1, 2]
  NUM_FILTERS: [128, 256]
  UPSAMPLE_STRIDES: [1, 2]
  NUM_UPSAMPLE_FILTERS: [256, 256]

  FUSE_EPS: 0.0001
  USE_POST_GSCONV: True   # 先开着；如果不稳就关掉

这个 SAE-lite 基本不会把 grid 对齐关系打乱（只做 crop/pad 对齐，不做插值缩放），而且严格对应论文指出的痛点：不同尺度贡献度要区分。(1-s2.0-S0141938224001859-main.pdf)

为什么你“完整版 BGC/类 BiFPN”会把指标搞崩（最可能的 3 个原因）

你不是论文的 pillar pseudo-image pipeline：论文 neck 依赖其 backbone 输出的三尺度特征，并强调两者协同。(1-s2.0-S0141938224001859-main.pdf) 你用 voxel+HeightCompression 强行套 BiFPN，语义分布不同，容易适得其反。
插值/池化对齐会引入位置偏移：anchor-free 的 heatmap 对“中心点落在哪个像素”非常敏感。
通道数/尺度数变化导致训练不稳定：比如你从 512 变 768、或多加一层 stride，CenterHead 的超参（LR、warmup、shared channel）可能不再合适。

你现在应该怎么做（推荐执行顺序）

先回滚到你最强的基线（67.25/54.592/89）确认可复现。
上面这个 SAE-lite 先跑一个短训（比如 10~20 epoch）看趋势：
- 只要 mAP 不掉/小涨，再完整训
如果 SAE-lite 稳，再逐步加复杂度：
- 先 USE_POST_GSCONV=False（只权重不加 GSConv）跑一版
- 再打开 GSConv
不要立刻回到完整版 BiFPN：你现在任务是“小目标+细长结构+5类”，先吃到稳定增益更重要。

如果你愿意，我可以再帮你做一个“从你现有 voxel BEV 出发的、更合理的 BGC 版本”：保持 stride=8 严格对齐、取消任何非整数缩放，只做“中间尺度对齐 + 权重融合 + size conversion concat”（论文也强调最终对齐到中间尺度的重要性。(1-s2.0-S0141938224001859-main.pdf)）。
你把你当前 spatial_features 的输入尺寸（H,W）和每个 stage 后的尺寸（打印一下）发我，我就按你的尺寸链把 neck 结构写成“绝不会产生偏移/插值缩放”的版本。

Answer 14

你现在这个现象（只改 VFE 能涨，但一动 neck/backbone 反而掉）其实很常见：对你这种 voxel-3D backbone + HeightCompression 的 CenterPoint 来说，SAE 论文里的 BGC neck 是围绕 pillar pseudo-image + SSDCM backbone 设计的；它在论文里也明确说：CenterPoint 原 neck “不区分不同分辨率贡献”，BGC 用 可学习权重 + GS-Conv + size-conversion concat 来融合多尺度特征。(1-s2.0-S0141938224001859-main.pdf) 但它的提升在论文里本来就不大（BGC 单独 +0.6 mAP），而且**和他们的 SSDCM backbone 是“互相增益/协同”**的。(1-s2.0-S0141938224001859-main.pdf)(1-s2.0-S0141938224001859-main.pdf)
所以在你的 pipeline 上强行搬 neck，很可能吃不到收益，甚至会因为 BEV 网格对齐/尺度链路差异让 anchor-free heatmap 更难学。

下面给你一个“继续改进”的更稳路线（按优先级排，都是你现在这套代码上能直接做的）。

0) 先把“最强 baseline”锁死

你最强的是：PDVMeanVFE(+density/range + intensity hist) + 原 BaseBEVBackbone + 原 HeightCompression（mAP 54.592）。
接下来所有改动都基于它做 单点消融，否则你会一直被“结构改动导致的训练不稳定/对齐误差”干扰。

1) 你现在最该优先优化的：小类（Kite/Bird）＝数据与正样本分配

你目前各类差异非常大（Balloon 很高、Kite/Bird 很低），这通常不是“特征不够”而是：

样本数/点数少（小目标、稀疏）
heatmap 正样本区域太小（radius 太小 or 被阈值压掉）
类不平衡导致分类头偏置

1.1 先做 DB Sampling（强烈推荐，收益通常比改 neck 更大）

在 custom_dataset.yaml 的 DATA_AUGMENTOR 加 gt_sampling，并对 Kite/Bird 过采样。示例（你按实际 dbinfos 路径改）：

yaml
DATA_AUGMENTOR:
  DISABLE_AUG_LIST: []
  AUG_CONFIG_LIST:
    - NAME: gt_sampling
      USE_ROAD_PLANE: False
      DB_INFO_PATH: ['custom_dbinfos_train.pkl']
      PREPARE:
        filter_by_min_points: ['Drone:5', 'Plastic_sheet:5', 'Kite:3', 'Balloon:5', 'Bird:3']
      SAMPLE_GROUPS: ['Drone:10', 'Plastic_sheet:12', 'Kite:30', 'Balloon:6', 'Bird:30']
      NUM_POINT_FEATURES: 4
      REMOVE_EXTRA_WIDTH: [0.0, 0.0, 0.0]
      LIMIT_WHOLE_SCENE: True

目标很简单：让每个 batch 里 Kite/Bird 经常出现，否则你再怎么改特征，头也学不到。

1.2 调 heatmap 正样本半径（MIN_RADIUS / GAUSSIAN_OVERLAP）

你现在 MIN_RADIUS: 2 对小目标不一定合适：有时半径过大反而把相邻目标“糊一起”，有时半径过小正样本太少。建议你做两组对比（只改一个参数）：

方案 A：MIN_RADIUS: 1（更贴小目标）
方案 B：GAUSSIAN_OVERLAP: 0.05（让半径计算更“宽松”）

这一步通常会显著影响 Kite/Bird 的 recall。

2) 继续沿你“VFE 特征增强”思路：别再堆 histogram，改成“更稳的统计量 + 轻量门控”

你已经验证：Intensity-hist 对整体提升有限，原因往往是直方图太“硬”、噪声大、还会挤占主特征学习能力。

推荐替换：把 hist 改成 4 个统计量（更稳）

在 VFE 里增加：

I_mean, I_std, I_max, I_min（只对 valid points）
保留 density, range 这样从 +8 bins 变成 +4 stats，更稳定、也更不容易过拟合。

并且加一个 门控系数（让网络自己决定这些附加特征用多少）：

python
gate = torch.sigmoid(self.extra_gate)   # nn.Parameter(shape=[extra_dim])
extra = extra * gate
voxel_features = torch.cat([mean_feat, extra], dim=1)

你现在已经看到：一旦网络结构动太大就掉分，所以这种“轻改动”更适合你。

3) 你的结构层面下一步，我更建议动这里：HeightCompression（保留 BEV 尺度，不破坏对齐）

你之前也提到“HeightCompression 会破坏高度结构”。这在你的场景（悬挂物/薄片/鸟/风筝）很可能是真瓶颈。

SAE 论文里 neck 的核心是“更好融合上下文”，但它也强调 backbone/neck 是协同的；在你这里，更直接的上下文损失点就是 把 (C,D,H,W) 直接 view 成 (C*D,H,W)。(1-s2.0-S0141938224001859-main.pdf)

3.1 给你一个“几乎不改其他模块”的 HeightAttentionCompression

它做的事：

先对每个 height slice 学一个权重（softmax）
再加权后 仍然 flatten 成 C*D（所以后面 BEV backbone/head 不用改）

新建 pcdet/models/backbones_2d/map_to_bev/height_attn_compression.py：

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

class HeightAttnCompression(nn.Module):
    def __init__(self, model_cfg, **kwargs):
        super().__init__()
        self.model_cfg = model_cfg
        self.num_bev_features = self.model_cfg.NUM_BEV_FEATURES
        # LazyLinear：第一次 forward 自动推断 C
        self.fc = nn.LazyLinear(1)
        self.eps = 1e-6

    def forward(self, batch_dict):
        x = batch_dict['encoded_spconv_tensor'].dense()   # (N,C,D,H,W)
        N, C, D, H, W = x.shape

        # (N,C,D) 先把空间平均，学每个 D 的权重
        xd = x.mean(dim=(3,4))                 # (N,C,D)
        xd = xd.permute(0, 2, 1).contiguous()  # (N,D,C)
        logits = self.fc(xd).squeeze(-1)       # (N,D)
        w = F.softmax(logits, dim=1).view(N, 1, D, 1, 1)  # (N,1,D,1,1)

        x = x * w                               # 加权
        x = x.view(N, C * D, H, W).contiguous() # 仍然输出 (N,C*D,H,W)

        batch_dict['spatial_features'] = x
        batch_dict['spatial_features_stride'] = batch_dict['encoded_spconv_tensor_stride']
        return batch_dict

注册：pcdet/models/backbones_2d/map_to_bev/__init__.py 加一行 import。

配置改成：

yaml
MAP_TO_BEV:
  NAME: HeightAttnCompression
  NUM_BEV_FEATURES: 256

这类改动通常比你硬搬 BiFPN neck 更“贴合 voxel BEV”，而且不会引入插值导致的中心点偏移。

4) 你已经有很高 FPS：可以用“提高分辨率/减少下采样”换 mAP（对小目标最有效）

这是小目标检测最直接的杠杆之一：

把 xy voxel size 从 0.1 降到 0.075 或 0.05
或把 FEATURE_MAP_STRIDE 从 8 变成 4（需要 3D backbone 输出更高分辨率 BEV）

先从 voxel size 开始，因为它对代码侵入最小；代价是显存/速度下降，但你现在 80+ FPS，完全扛得住。

你下一步怎么跑实验（给你一个最省事的顺序）

按这个顺序，一次只改一个点：

DB Sampling（重点过采样 Kite/Bird）
MIN_RADIUS=1（或 GAUSSIAN_OVERLAP=0.05 二选一先试）
HeightAttnCompression 替换 HeightCompression
VFE：hist → 统计量 + gate
voxel size 变小

只要其中任意一步让 Kite/Bird 的 AP 明显上来，整体 mAP 基本就能超过你现在的 54.592。

如果你把下面两样东西贴一下，我可以把“MIN_RADIUS/GAUSSIAN_OVERLAP/采样比例/voxel size”直接给你算成更贴你数据的建议值（不用你盲试）：

每类训练样本数量（或者每类 gt box 总数）
每类 box 的平均尺寸（l,w,h）和平均点数（大概也行）

Answer 15

你现在这份**“把增强器写到主 cfg 的 DATA_CONFIG 下面”的改法，大概率不会生效（甚至会直接 YAML 解析失败），所以还不能直接开始做你期望的 db-sampling 实验**。原因和正确改法如下。

1) 你现在的写法哪里有问题

问题 A：层级写错了（会被忽略）

在 OpenPCDet 的 dataset config 里，增强器是挂在：

DATA_AUGMENTOR: { DISABLE_AUG_LIST, AUG_CONFIG_LIST }

而你把 DISABLE_AUG_LIST / AUG_CONFIG_LIST 直接写在 DATA_CONFIG: 下一级（没有 DATA_AUGMENTOR: 这一层），数据集代码读不到，就会继续用 _BASE_CONFIG_ 里的旧增强器配置。

问题 B：缩进不合法（可能直接报 YAML error）

你这段里 - NAME: gt_sampling 下面的注释和 USE_ROAD_PLANE 的缩进不一致，标准 YAML 会报错。

2) 正确的写法（可以直接跑）

如果你希望在主 cfg 里覆盖 _BASE_CONFIG_ 的增强器，请这样写（注意缩进）：

yaml
DATA_CONFIG:
  _BASE_CONFIG_: /media/jd/4997BB1603CFE2C4/lw/Openpcdet/tools/cfgs/dataset_configs/custom_dataset.yaml

  DATA_AUGMENTOR:
    DISABLE_AUG_LIST: []
    AUG_CONFIG_LIST:
      - NAME: gt_sampling
        USE_ROAD_PLANE: False
        DB_INFO_PATH: [custom_dbinfos_train.pkl]
        PREPARE:
          filter_by_min_points: ['Drone:5', 'Plastic_sheet:5', 'Kite:3', 'Balloon:3', 'Bird:3']
        SAMPLE_GROUPS: ['Drone:10', 'Plastic_sheet:12', 'Kite:30', 'Balloon:6', 'Bird:30']
        NUM_POINT_FEATURES: 4
        DATABASE_WITH_FAKELIDAR: False
        REMOVE_EXTRA_WIDTH: [0.0, 0.0, 0.0]
        LIMIT_WHOLE_SCENE: True

      - NAME: random_world_flip
        ALONG_AXIS_LIST: ['x']

      - NAME: random_world_rotation
        WORLD_ROT_ANGLE: [-0.78539816, 0.78539816]

      - NAME: random_world_scaling
        WORLD_SCALE_RANGE: [0.95, 1.05]

如果你只写 gt_sampling，那就等于把原来 _BASE_CONFIG_ 里的 flip/rot/scale 都覆盖掉了（不一定是你想要的）。上面这个版本是“保持原增强，只改采样比例”。

3) 我建议你先别用 SAEWeightedBEVBackbone 做这轮实验

你现在的经验已经说明：换 neck（SAE/BGC 风格）在你的 voxel+BEV pipeline 上容易掉点。而且论文里 BGC neck 的收益本来就不大（单独只有小幅提升），并且他们明确说 **BGC neck 和他们的 SSDCM backbone 是“协同增益/互相促进”**的。(1-s2.0-S0141938224001859-main.pdf)
同时他们提出 BGC 的动机是“CenterPoint neck 不区分不同分辨率特征贡献”，并用“fast normalized weighted fusion + GS-Conv”去做融合。(1-s2.0-S0141938224001859-main.pdf) (1-s2.0-S0141938224001859-main.pdf)
但你当前 backbone/neck 输入形态与论文的 pillar pseudo-image 管线不一致（论文整体是 pillar encoder→pseudo-image→SSDCM→BGC）。(1-s2.0-S0141938224001859-main.pdf)

所以这轮你要验证“db sampling + heatmap 半径”是否救 Kite/Bird，请先把 BACKBONE_2D 回滚成 BaseBEVBackbone，只动数据增强和 MIN_RADIUS/GAUSSIAN_OVERLAP，避免变量耦合。

4) 你这轮实验前，务必做 1 个“生效性检查”

启动训练后看 log/保存的 cfg（OpenPCDet 会 dump 一份最终 cfg）里是否出现：

DATA_CONFIG.DATA_AUGMENTOR.AUG_CONFIG_LIST
SAMPLE_GROUPS 是否是你设的 Kite:30, Bird:30

如果 dump 里还是旧的，那说明覆盖没生效（通常就是层级/缩进问题）。

5) 额外一个你现在配置里“很可能在暗中拖后腿”的点

你的 POINT_CLOUD_RANGE 是 [0, -20, -2, 160, 20, 6]，但 POST_CENTER_LIMIT_RANGE 还是 [-160, -75.2, -5, 160, 75.2, 8]（明显不是同一套范围）。建议改成一致：

yaml
POST_CENTER_LIMIT_RANGE: [0, -20, -2, 160, 20, 6]

这不会影响训练 label 的生成，但会影响推理阶段的过滤边界，建议统一，避免“评测时把一部分框过滤掉/保留无意义区域”。

你问“就可以开始实验是吧？”

按你现在那份写法：不建议开始（大概率增强器覆盖不生效/缩进有误）。
按我上面给的正确层级与缩进改好 + 回滚 BaseBEVBackbone 做单变量实验：就可以开始。

如果你把训练启动后 dump 出来的最终 cfg 里 DATA_CONFIG.DATA_AUGMENTOR 那一段贴出来（几十行即可），我可以帮你确认“覆盖到底有没有生效”，以及你现在的 gt_sampling 是否真的在把 Kite/Bird 拉起来。

Answer 16

这个报错不是你数据/训练的问题，是因为你现在的网络里用了 torch.nn.Lazy*（LazyLinear / LazyConv）。OpenPCDet 的 tools/train.py 会在 model 刚创建完就做一次参数量统计：

python
sum([m.numel() for m in model.parameters()])

但 Lazy 模块的参数此时还是 UninitializedParameter，所以直接炸掉：

Attempted to use an uninitialized parameter ... when you are using a LazyModule

解决方案（推荐）：不要用 LazyLinear，换成“无 Lazy”的高度注意力

把你 HeightAttnCompression 里那句 nn.LazyLinear(1) 改掉即可。下面这个版本不依赖 C 通道数，参数一开始就初始化好，不会触发这个错误。

✅ 替换 `pcdet/models/backbones_2d/map_to_bev/height_attn_compression.py`

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

class HeightAttnCompression(nn.Module):
    def __init__(self, model_cfg, **kwargs):
        super().__init__()
        self.model_cfg = model_cfg
        self.num_bev_features = self.model_cfg.NUM_BEV_FEATURES
        self.eps = getattr(self.model_cfg, 'FUSE_EPS', 1e-6)

        # 不用 Lazy：输入固定是 (N, 1, D)
        self.attn = nn.Sequential(
            nn.Conv1d(1, 8, kernel_size=1, bias=True),
            nn.ReLU(inplace=True),
            nn.Conv1d(8, 1, kernel_size=1, bias=True)
        )

    def forward(self, batch_dict):
        x = batch_dict['encoded_spconv_tensor'].dense()   # (N, C, D, H, W)
        N, C, D, H, W = x.shape

        # (N, D)：对通道+空间做汇聚，得到每个高度层的“强度”
        xd = x.abs().mean(dim=(1, 3, 4))                  # (N, D)
        logits = self.attn(xd.unsqueeze(1)).squeeze(1)    # (N, D)

        w = F.softmax(logits, dim=1).view(N, 1, D, 1, 1)  # (N,1,D,1,1)
        x = x * w
        x = x.view(N, C * D, H, W).contiguous()

        batch_dict['spatial_features'] = x
        batch_dict['spatial_features_stride'] = batch_dict['encoded_spconv_tensor_stride']
        return batch_dict

这个版本不会再触发 Lazy 参数未初始化的问题。

还要做两件小事

pcdet/models/backbones_2d/map_to_bev/__init__.py 里注册一下：

python
from .height_attn_compression import HeightAttnCompression

cfg 里写：

yaml
MAP_TO_BEV:
  NAME: HeightAttnCompression
  NUM_BEV_FEATURES: 256

然后就可以重新训练了。

备选方案（不推荐，但也能跑）：改 train.py 跳过 UninitializedParameter

如果你就是想继续用 Lazy，也可以改 tools/train.py 统计参数那行（不如上面干净）：

python
import torch
from torch.nn.parameter import UninitializedParameter

param_cnt = 0
for p in model.parameters():
    if isinstance(p, UninitializedParameter):
        continue
    param_cnt += p.numel()
logger.info(f'... param count: {param_cnt} ...')

如果你把你当前使用的 HeightAttnCompression / SAEWeightedBEVBackbone 文件名和代码位置说一下（你现在哪个模块里用了 Lazy），我也可以直接指出你工程里“哪一行 Lazy”导致的，并给你最小改动版补丁。

Answer 17

你现在这个现象（一换 SAE/BiFPN/Height-attn 一类模块，mAP 从 54.x 掉到 44.x）其实很常见：** 不是“VFE 不行”，而是你把一个“强依赖特定前端/特征形态”的 neck 迁到了另一个 pipeline，上下游统计分布和尺度对齐不匹配**。

尤其是 CenterPoint-SAE 论文里也明确：BGC neck 单独带来的提升很小（他们消融里 BGC 仅 +0.6% mAP），而且 SSDCM backbone + BGC neck 是“互相促进/协同增益”，组合起来提升才更明显。(1-s2.0-S0141938224001859-main.pdf) 这意味着：你只“换 neck/换融合”但 backbone/输入形态不同（你是 voxel→HeightCompression→BEV，论文是 pillar pseudo-image→SSDCM→BGC），很容易掉点。(1-s2.0-S0141938224001859-main.pdf)

下面给你一个下一步最稳、最可能把指标拉回去并继续涨的路线（按优先级）：

0）先止损：回到你当前“最强基线”

你目前最强的是：PDVMeanVFE(+density/range + intensity hist) + 原 HeightCompression + BaseBEVBackbone + CenterHead（那组 67.25 / 54.592 / 89 FPS）。

先把这些全部回滚（把 SAEWeightedBEVBackbone、Height-attn/BiFPN 那套先关掉），否则你后面做任何改动都看不出来到底是谁在拖后腿。

1）你现在配置里有一个会“暗杀评测”的点：范围不一致

你的数据集范围是：

POINT_CLOUD_RANGE: [0, -20, -2, 160, 20, 6]

但你 cfg 里很多轮还在用：

POST_CENTER_LIMIT_RANGE: [-160, -75.2, -5, 160, 75.2, 8]

这会导致推理/评测阶段过滤框的区域和训练/数据处理区域不一致（尤其 Y 方向差太大），很可能让指标莫名其妙变差。

✅ 直接统一成：

yaml
POST_PROCESSING:
  POST_CENTER_LIMIT_RANGE: [0, -20, -2, 160, 20, 6]

2）不要继续“死磕 SAE neck”，先把小类（Kite/Bird）用更便宜的方式拉起来

你现在的类别很不均衡，小目标多，且点数少。与其先上复杂 neck，我更建议你按下面 3 个“必涨方向”做：

2.1 先做多 Head 分组（强烈推荐）

把 5 类硬塞一个 head，会让共享卷积同时适配大目标（Balloon）和极小目标（Bird/Kite），学习冲突很大。

把 CLASS_NAMES_EACH_HEAD 分成“空中小目标组”和“相对更大/更稳定组”，例如：

yaml
DENSE_HEAD:
  CLASS_NAMES_EACH_HEAD: [
    ['Bird', 'Kite'],
    ['Drone', 'Plastic_sheet', 'Balloon']
  ]

这在 OpenPCDet 的 CenterHead 里成本很低，但经常比换 neck 更稳。

2.2 重新调 heatmap 半径：别用“0.05 overlap + min_radius=1”

你为了小目标把 GAUSSIAN_OVERLAP 改到 0.05、MIN_RADIUS 改到 1，这组合经常会把 heatmap 正样本铺太开或太尖锐，造成分类回归都不稳（你现在掉点就很像这个问题叠加了 neck 不稳）。

✅ 建议你先回到更常用、更稳的：

yaml
TARGET_ASSIGNER_CONFIG:
  GAUSSIAN_OVERLAP: 0.1
  MIN_RADIUS: 2

然后只做一维搜索：

固定 overlap=0.1，试 MIN_RADIUS: 2 → 3 → 4（小目标通常更吃 min_radius）
或固定 min_radius=2，试 overlap：0.1 → 0.12 → 0.15

一次只改一个参数。

2.3 DB Sampling：你现在的比例太激进，先“温和增广”

你把 Kite/Bird 采样拉到 30，非常容易引入：

场景不合理拼贴（分布漂移）
过拟合到 DB 里的少量形态
与真实遮挡/背景不一致

✅ 更稳的做法是“逐步加权”：

先从 Kite:10, Bird:10 开始
再到 15
最后才到 20+

并且 filter_by_min_points 不要太低（太低会把噪声 GT 拉进来），建议：

Bird/Kite 至少 3~5 点（你现在可以）
Drone/Balloon 适当更高一点（比如 8~10）

3）Intensity 直方图提升不明显：我建议换成“更稳的强度统计量”

直方图对你这种小数据集、强度分布可能不稳定的传感器，很容易学不到泛化规律。

你可以保留 PDV 的 density/range，但把直方图改为 3 个统计量（更稳）：

I_mean, I_std, I_max（或再加一个 I_min）

这样通道少、噪声低，往往比 8-bin histogram 更有效。

如果你愿意我可以把你当前 PDVMeanVFE 里 hist 那段直接替换成统计量版（改动很小）。

4）如果你还有算力富余（你现在 FPS 85~89 很富），最有效的是：提高 BEV 分辨率

你现在 voxel 是 0.1×0.1×0.2。对 Bird/Kite 这类小目标，横向分辨率往往才是瓶颈。

下一轮可以试：

VOXEL_SIZE: [0.075, 0.075, 0.2]
或更激进 [0.05, 0.05, 0.2]（注意 max voxels 要加大，比如 train 100k / test 140k）

这个改动经常比换 neck 更“硬核有效”，但会降 FPS——你有余量。

你下一步我建议你就按这个顺序做（最少实验次数）

回滚 neck 到 BaseBEVBackbone + HeightCompression，统一 POST_CENTER_LIMIT_RANGE
CLASS_NAMES_EACH_HEAD 做分组（先跑一轮）
heatmap：回到 overlap=0.1/min_radius=2，然后只搜索 min_radius
DB sampling：从温和比例开始逐步加
intensity hist → intensity 统计量（如果 hist 一直没收益）
最后再动 voxel_size 提分辨率

如果你把你当前 best（54.592）那份 cfg 和 现在差的 cfg（各贴 MODEL 和 DENSE_HEAD/TARGET_ASSIGNER/POST_PROCESSING 这几段就行）发我，我可以帮你把“回滚 + 分 head + 统一范围 + heatmap 恢复”的那版 cfg 直接给你写成一份可跑的对照实验配置。

Answer 18

可以，既然你要彻底舍弃 SAE / BiFPN / Height-attn 这一套 neck 改法，我建议换一个更“CenterPoint 友好”、更不挑前端特征形态、同时对你这种“小目标 + 类不均衡”更有效的新模块：

新推荐模块（优先做这个）：IoU-Aware / Quality-Aware CenterHead（质量分支重打分）

你现在的问题很像：heatmap 分类分数和框质量不一致（尤其小目标 Kite/Bird，容易出现“分数高但框不准/假阳性多”）。
一个很稳的改法是：在 CenterHead 里加一个 IoU/Quality 分支，训练时让它学习“这个位置预测框和 GT 的 IoU”，推理时用它校准 score：

score = score_{hm} \times (sigmoid(score_{iou}))^{\alpha}

这样通常能显著降 FP、稳住 NMS、提升 mAP，而且不依赖时序，不需要换 backbone/neck。
（你之前 SAE 那篇论文也强调很多改进存在“协同增益/互相促进”，单独迁移某个模块到不同 pipeline 容易掉点，这也是你现在遇到的情况。 (1-s2.0-S0141938224001859-main.pdf)）

你要改哪些地方（最小改动版）

A) 配置文件改动（先把 iou 分支加进 head）

在 DENSE_HEAD -> SEPARATE_HEAD_CFG 增加一条：

yaml
SEPARATE_HEAD_CFG:
  HEAD_ORDER: ['center', 'center_z', 'dim', 'rot', 'iou']
  HEAD_DICT: {
    'center': {'out_channels': 2, 'num_conv': 2},
    'center_z': {'out_channels': 1, 'num_conv': 2},
    'dim': {'out_channels': 3, 'num_conv': 2},
    'rot': {'out_channels': 2, 'num_conv': 2},
    'iou': {'out_channels': 1, 'num_conv': 2},
  }

再加两个超参（可放在 DENSE_HEAD 里）：

yaml
IOU_LOSS_WEIGHT: 1.0
IOU_SCORE_POWER: 1.0   # α，先 1.0

B) 代码改动（CenterHead 增加 iou loss + 推理重打分）

你要改的文件一般是：

pcdet/models/dense_heads/center_head.py

1）forward：多输出一个 `iou_preds`

CenterHead 的 head 构建通常是按 HEAD_ORDER/HEAD_DICT 自动建的，所以你只要确保：

pred_dicts 里包含 'iou' 的输出（很多版本会自动放进去）

2）loss：对正样本 center 的预测框算 IoU，当作监督信号

关键思想：

你已经有每个 GT center 的索引 inds（CenterHead 的 target 里一般叫 ind + mask）
你也能从 reg 分支 decode 出预测框 pred_boxes
对每个 GT 对应位置，取出该位置的预测框，和 GT box 算 IoU，得到 iou_target
用 BCEWithLogitsLoss 监督 iou 分支

伪代码（你照着你当前 CenterHead 的变量名对齐即可）：

python
# 1) 从 pred_dict 取出 iou_pred: (B, 1, H, W)
iou_pred = pred_dict['iou']

# 2) 拿 target 的 ind/mask/gt_boxes（CenterHead 默认就有）
inds = target_dict['ind']      # (B, max_objs)
mask = target_dict['mask']     # (B, max_objs) 0/1
gt_boxes = target_dict['gt_boxes']  # (B, max_objs, 7) 或类似

# 3) 把 iou_pred 按 ind gather 成 (B, max_objs)
iou_pred_gather = _transpose_and_gather_feat(iou_pred, inds)  # 常见工具函数
iou_pred_gather = iou_pred_gather.squeeze(-1)                 # (B, max_objs)

# 4) 同样 gather 出对应位置的 pred boxes
pred_boxes_all = decoded_pred_boxes   # (B, H*W, 7) 或者 (B, H, W, 7) 视实现而定
pred_boxes_gather = gather_pred_boxes(pred_boxes_all, inds)   # (B, max_objs, 7)

# 5) 算 IoU target（建议 detach）
iou_target = iou3d(pred_boxes_gather, gt_boxes)              # (B, max_objs)
iou_target = iou_target.detach().clamp(0, 1)

# 6) loss（只对 mask==1 的位置）
loss_iou = F.binary_cross_entropy_with_logits(
    iou_pred_gather[mask>0], iou_target[mask>0]
)

total_loss += IOU_LOSS_WEIGHT * loss_iou

IoU 计算你可以直接用 OpenPCDet 自带的： pcdet/ops/iou3d_nms/iou3d_nms_utils.py（里面通常有 boxes_iou3d_gpu / boxes_iou_bev 之类）

注意：如果你觉得 3D IoU 太贵，可以先用 BEV IoU 做监督（更便宜，通常也够用）。

3）推理：用 iou 分支校准分数

在 decode / post_processing 前，把 heatmap 分数乘上 iou 分数（建议 sigmoid 后再乘）：

python
hm_score = torch.sigmoid(pred_dict['hm'])         # or 'heatmap'
iou_score = torch.sigmoid(pred_dict['iou'])
hm_score = hm_score * (iou_score ** IOU_SCORE_POWER)
pred_dict['hm'] = torch.logit(hm_score.clamp(1e-4, 1-1e-4))   # 如果后面代码期望 logits
# 或者直接把 hm_score 传入后续 NMS（看你实现）

为什么我更推荐它（相对你之前那些 neck 改法）

不改变特征尺度/对齐方式（你之前那些错误就是尺度对齐、融合分支 shape 对不上，或者分布漂移导致性能崩）
对你这种“Bird/Kite 小且稀疏”的类，提升往往来自：更好的 score calibration + 更少 FP
训练稳定性比换 neck/backbone 强很多，属于“头部小改，收益稳”的路线

下一步你该怎么做（最少试验次数）

回到你当前最强基线（VFE 改好的那套）
只加 IoU 分支（其他都别动）跑一轮
只扫两个超参就够了：
- IOU_LOSS_WEIGHT: 0.5 / 1.0 / 2.0
- IOU_SCORE_POWER: 0.5 / 1.0 / 2.0

如果你把你当前 center_head.py 里这两段贴一下：

assign_targets / get_targets 输出里到底叫什么（ind/mask/anno_box 的字段名）
generate_predicted_boxes / decode_bbox 的输出 shape

我就能把上面伪代码改成完全贴合你工程的可直接复制粘贴 patch（不会再出现 shape 对不上、或者找不到字段名这种坑）。

Answer 19

你这条 CenterPoint-SAE(BGC neck / SSDCM backbone) 的路线，在你的数据上掉点其实很常见：论文里检测头基本完全沿用 CenterPoint 的 head（heatmap/offset/z/size/rot 五分支，heatmap 用 focal，回归用 L1）(1-s2.0-S0141938224001859-main.pdf)，提升主要来自 backbone+neck 的特征保真与跨尺度加权融合(1-s2.0-S0141938224001859-main.pdf)。但你的 pipeline 是 VoxelResBackBone8x → HeightCompression(直接 dense + C*D 展平) → 2D backbone，与论文的 pillar pseudo-image + 三尺度特征流不完全一致，硬迁移很容易引入 尺度对齐/ padding/ stride 的细节误差，最终“结构变强但目标监督变差”，导致整体指标下降。

既然你已经决定舍弃 SAE 那个模块，我更建议你下一步改 CenterHead（最稳、最可控、对小目标最直接）：做一个 Quality-Aware CenterHead：加 IoU 分支 + IoU 纠正打分 + 类别不均衡加权 focal +（可选）每类最小半径。这套改动对你这种 Drone/Kite/Bird 小目标、且类别分布不均衡的场景通常比换 neck 更“划算”。

下面给你直接可用的 center_head.py 修改（在你发的完整文件基础上改，不依赖时序）。

1) 改动目标

加 iou head：预测每个位置 box 的质量（0~1），用于：
- 训练时做 iou loss / iou reg loss（可选）
- 推理时做 score rectification（用 IoU 修正分类分数），减少 FP、提升排序质量
heatmap focal 支持类别权重：对 Kite/Bird 这种弱势类加权（缓解类别不均衡）。
修复你现有代码里 IOU_REG_LOSS 的潜在坑：当前写法如果 IOU_REG_LOSS=True 但没 iou head，会用到未定义的 batch_box_preds_for_iou。

论文里 focal 的超参给的是 α=2, β=4(1-s2.0-S0141938224001859-main.pdf)，下面实现默认就按这个来。

2) center_head.py 直接改（贴“补丁式修改”）

把下面代码段按位置插入/替换即可（我尽量只动必要部分）。

A. `CenterHead.init`：去掉硬 `.cuda()` + 自动加 iou head + 读入可选配置

把你原来这段：

python
cur_class_id_mapping = torch.from_numpy(np.array(
    [self.class_names.index(x) for x in cur_class_names if x in class_names]
)).cuda()
self.class_id_mapping_each_head.append(cur_class_id_mapping)

替换为（不要在 init 里强行 cuda，避免多卡/CPU/设备不一致问题）：

python
cur_class_id_mapping = torch.from_numpy(np.array(
    [self.class_names.index(x) for x in cur_class_names if x in class_names]
)).long()
self.class_id_mapping_each_head.append(cur_class_id_mapping)

然后在 __init__ 里（建议在 self.separate_head_cfg = ... 之前）加入：

python
# ---- Optional: IoU branch / heatmap class weights ----
post_cfg = self.model_cfg.get('POST_PROCESSING', {})
self.use_iou_branch = bool(
    self.model_cfg.get('USE_IOU_BRANCH', False)
    or self.model_cfg.get('IOU_REG_LOSS', False)
    or post_cfg.get('USE_IOU_TO_RECTIFY_SCORE', False)
)

self.hm_alpha = float(self.model_cfg.get('HM_ALPHA', 2.0))
self.hm_beta = float(self.model_cfg.get('HM_BETA', 4.0))
self.hm_class_weights = self.model_cfg.get('HM_CLASS_WEIGHTS', None)  # list[float] or None

然后在构建 cur_head_dict 的循环里，给每个 head 追加 iou 分支（注意：不要放进 HEAD_ORDER）：

找到：

python
cur_head_dict = copy.deepcopy(self.separate_head_cfg.HEAD_DICT)
cur_head_dict['hm'] = dict(out_channels=len(cur_class_names), num_conv=self.model_cfg.NUM_HM_CONV)

在下面加一段：

python
if self.use_iou_branch:
    # 1-channel quality prediction
    cur_head_dict['iou'] = dict(out_channels=1, num_conv=2)

B. 新增一个 “支持类别权重”的 CenterNet focal（替代/可选替代 hm_loss_func）

在 CenterHead 类里（比如 sigmoid() 下面）新增：

python
def centernet_focal_loss(self, pred_hm, gt_hm, class_weights=None, alpha=2.0, beta=4.0):
    """
    pred_hm, gt_hm: (B, C, H, W), pred_hm should already be sigmoid-clamped to (0,1)
    This matches the CenterNet-style focal used by CenterPoint; paper uses alpha=2, beta=4. (1-s2.0-S0141938224001859-main.pdf)
    """
    pos_mask = (gt_hm == 1).float()
    neg_mask = (gt_hm < 1).float()
    neg_weights = torch.pow(1 - gt_hm, beta)

    pred = torch.clamp(pred_hm, min=1e-4, max=1 - 1e-4)

    pos_loss = -torch.log(pred) * torch.pow(1 - pred, alpha) * pos_mask
    neg_loss = -torch.log(1 - pred) * torch.pow(pred, alpha) * neg_weights * neg_mask
    loss = pos_loss + neg_loss

    if class_weights is not None:
        w = pred.new_tensor(class_weights).view(1, -1, 1, 1)
        loss = loss * w

    num_pos = pos_mask.sum()
    return loss.sum() / torch.clamp_min(num_pos, 1.0)

C. 修改 `get_loss()`：hm 用带权 focal（可选），并修复 iou_reg_loss 的变量定义

在 get_loss() 里找到：

python
pred_dict['hm'] = self.sigmoid(pred_dict['hm'])
hm_loss = self.hm_loss_func(pred_dict['hm'], target_dicts['heatmaps'][idx])

替换为：

python
pred_dict['hm'] = self.sigmoid(pred_dict['hm'])
gt_hm = target_dicts['heatmaps'][idx]

# If provided, use weighted focal to fight class imbalance; otherwise keep original loss
if self.hm_class_weights is not None:
    hm_loss = self.centernet_focal_loss(
        pred_hm=pred_dict['hm'],
        gt_hm=gt_hm,
        class_weights=self.hm_class_weights,
        alpha=self.hm_alpha,
        beta=self.hm_beta
    )
else:
    hm_loss = self.hm_loss_func(pred_dict['hm'], gt_hm)

然后在 iou 那块，找到你当前这段（你现在的代码有潜在未定义变量问题）：

python
if 'iou' in pred_dict or self.model_cfg.get('IOU_REG_LOSS', False):

    batch_box_preds = centernet_utils.decode_bbox_from_pred_dicts(...)
    if 'iou' in pred_dict:
        batch_box_preds_for_iou = batch_box_preds.permute(0, 3, 1, 2)
        ...
    if self.model_cfg.get('IOU_REG_LOSS', False):
        iou_reg_loss = loss_utils.calculate_iou_reg_loss_centerhead(
            batch_box_preds=batch_box_preds_for_iou,
            ...
        )

把它改成（关键点：先定义 batch_box_preds_for_iou）：

python
if ('iou' in pred_dict) or self.model_cfg.get('IOU_REG_LOSS', False):

    batch_box_preds = centernet_utils.decode_bbox_from_pred_dicts(
        pred_dict=pred_dict,
        point_cloud_range=self.point_cloud_range, voxel_size=self.voxel_size,
        feature_map_stride=self.feature_map_stride
    )  # (B, H, W, 7 or 9)

    batch_box_preds_for_iou = batch_box_preds.permute(0, 3, 1, 2).contiguous()  # (B, 7/9, H, W)

    if 'iou' in pred_dict:
        iou_loss = loss_utils.calculate_iou_loss_centerhead(
            iou_preds=pred_dict['iou'],
            batch_box_preds=batch_box_preds_for_iou.clone().detach(),
            mask=target_dicts['masks'][idx],
            ind=target_dicts['inds'][idx],
            gt_boxes=target_dicts['target_boxes_src'][idx]
        )
        loss += iou_loss
        tb_dict['iou_loss_head_%d' % idx] = iou_loss.item()

    if self.model_cfg.get('IOU_REG_LOSS', False):
        iou_reg_loss = loss_utils.calculate_iou_reg_loss_centerhead(
            batch_box_preds=batch_box_preds_for_iou,
            mask=target_dicts['masks'][idx],
            ind=target_dicts['inds'][idx],
            gt_boxes=target_dicts['target_boxes_src'][idx]
        )
        if target_dicts['masks'][idx].sum().item() != 0:
            iou_reg_loss = iou_reg_loss * self.model_cfg.LOSS_CONFIG.LOSS_WEIGHTS['loc_weight']
            loss += iou_reg_loss
            tb_dict['iou_reg_loss_head_%d' % idx] = iou_reg_loss.item()
        else:
            loss += (batch_box_preds_for_iou * 0.).sum()
            tb_dict['iou_reg_loss_head_%d' % idx] = (batch_box_preds_for_iou * 0.).sum().item()

D. 修改 `generate_predicted_boxes()`：确保 mapping 在正确 device 上

找到：

python
final_dict['pred_labels'] = self.class_id_mapping_each_head[idx][final_dict['pred_labels'].long()]

替换为：

python
mapping = self.class_id_mapping_each_head[idx].to(final_dict['pred_labels'].device)
final_dict['pred_labels'] = mapping[final_dict['pred_labels'].long()]

3) 配置文件怎么写（最小可跑 + 可控 ablation）

你现在的 neck 我建议先回到 BaseBEVBackbone，先把 head 的收益跑出来（否则你很难判断掉点到底是 neck 还是 head）。

在 DENSE_HEAD 里新增这些（先用保守值）：

yaml
DENSE_HEAD:
  NAME: CenterHead
  USE_IOU_BRANCH: True
  IOU_REG_LOSS: False          # 先关，稳定后再开
  HM_ALPHA: 2.0
  HM_BETA: 4.0                 # 论文同款 (1-s2.0-S0141938224001859-main.pdf)
  HM_CLASS_WEIGHTS: [1.0, 1.0, 2.0, 1.0, 2.0]  # 例子：Kite/Bird 加权（你可按样本量再调）

  POST_PROCESSING:
    USE_IOU_TO_RECTIFY_SCORE: True
    IOU_RECTIFIER: [0.5, 0.5, 0.7, 0.5, 0.7]   # 小目标更依赖 iou 质量，先这样试
    NMS_CONFIG:
      NMS_TYPE: class_specific_nms
      NMS_THRESH: 0.1          # 你现在 0.01 太狠了，容易压掉 TP
      NMS_PRE_MAXSIZE: 4096
      NMS_POST_MAXSIZE: 500

解释一下：SAE 论文强调它能减少 FP/FN、缓解类别不均衡(1-s2.0-S0141938224001859-main.pdf)，我们现在用 IoU-aware + weighted focal 走一条“更直接影响 FP/FN 与类不均衡”的 head 路线，通常比换 neck 更稳定。

4) 你应该怎么做下一步（不走弯路的实验顺序）

按下面顺序做，每一步都只改一个因素：

回退 neck 到 BaseBEVBackbone，保留你现在效果最好的 PDVMeanVFE（这是你目前最可靠的增益来源）。
只开 USE_IOU_BRANCH=True + USE_IOU_TO_RECTIFY_SCORE=True，其它不动，跑一版看 mAP、FP 是否下降。
再加 HM_CLASS_WEIGHTS（只对 Kite/Bird 加权），看这两类是否上升而别的类不掉太多。
最后再考虑开 IOU_REG_LOSS=True（这一步有时会涨，但也更容易不稳定，放最后做）。

如果你愿意，我也可以按你现在 5 类各自样本数量/每类平均点数，把 HM_CLASS_WEIGHTS 和 IOU_RECTIFIER 给你算一个更合理的初始值（不需要时序数据）。你把每类 train 集标注框数量（大概也行）贴一下就行。

Answer 20

你这个报错的根因很明确：你把 iou 也塞进了回归分支的 HEAD_ORDER，导致回归向量维度从 8 变成 9，但 target 仍然是 8 维，所以在 loss_utils._reg_loss 里做 regr * mask（内部会对齐维度）时就炸了：

target ret_boxes 的维度固定是 8：[dx, dy] offset(2) + z(1) + log(dim)(3) + cos,sin(2)
你现在 pred_boxes = cat(center, center_z, dim, rot, iou) 变成 9
=> 于是出现：tensor a (9) must match tensor b (8)

而且论文的 CenterPoint-SAE 检测头仍然是 CenterPoint 的 5 个分支（heatmap/offset/height/dim/orientation），并没有把 IoU 当作 box 回归的一部分。(1-s2.0-S0141938224001859-main.pdf)

✅ 解决方法（推荐做法：不让 iou 参与 reg_loss）

1）先改配置文件：把 `iou` 从 `HEAD_ORDER` 移除

你可以保留 iou 分支，但不要放进 HEAD_ORDER（HEAD_ORDER 只用于 box 回归损失）。

把这段：

yaml
SEPARATE_HEAD_CFG:
  HEAD_ORDER: ['center', 'center_z', 'dim', 'rot','iou']
  HEAD_DICT: {
    ...
    'iou': {'out_channels': 1, 'num_conv': 2},
  }

改成（建议 HEAD_DICT 里也别写 iou，交给代码按 USE_IOU_BRANCH 自动加，避免重复/混乱）：

yaml
SEPARATE_HEAD_CFG:
  HEAD_ORDER: ['center', 'center_z', 'dim', 'rot']
  HEAD_DICT: {
    'center': {'out_channels': 2, 'num_conv': 2},
    'center_z': {'out_channels': 1, 'num_conv': 2},
    'dim': {'out_channels': 3, 'num_conv': 2},
    'rot': {'out_channels': 2, 'num_conv': 2},
  }

USE_IOU_BRANCH: True

同时确保 code_weights 长度还是 8（你现在就是 8，没问题）。

2）再改 `CenterHeadX.get_loss()`：回归时显式排除 `iou`

即使你忘了改配置，也可以在代码里做“保险”，永远不让 iou 进入 pred_boxes：

把你现在这一行：

python
pred_boxes = torch.cat([pred_dict[head_name] for head_name in self.separate_head_cfg.HEAD_ORDER], dim=1)

改成：

python
bbox_order = [n for n in self.separate_head_cfg.HEAD_ORDER if n != 'iou']
pred_boxes = torch.cat([pred_dict[n] for n in bbox_order], dim=1)

这样 pred_boxes 永远是 8 通道，对齐 target（8）就不会再报 9 vs 8。

🔧 额外强烈建议：你现在的 iou 用法会“饱和”，建议改成 sigmoid

你目前推理里写的是：

python
batch_iou = (pred_dict['iou'] + 1) * 0.5

但你的 iou head 没有 tanh，输出是任意实数，(x+1)/2 会非常容易 >1，然后你后面又 clamp 到 [0,1]，会导致大量值直接变 1（信息全没了）。

更稳的做法：

python
batch_iou = pred_dict['iou'].sigmoid()

对应地，score rectify 也就更合理（不会全被 clamp 成 0/1）。

你改完后应满足的维度关系（用来快速自检）

target_boxes 最后一维 = 8
pred_boxes 拼出来最后一维 = 8
iou 分支只用于 iou_loss / score rectify，不参与 reg_loss

如果你愿意把 loss_utils.calculate_iou_loss_centerhead 的实现（那几行）也贴一下，我可以帮你确认：训练时 iou 分支到底应该用 BCE(sigmoid) 还是 L1，以及 target iou 是怎么计算的，这样 iou 分支才不会“训练了但没用 / 反而拖累”。

Answer 21

你这个报错 9 vs 8 的原因已经坐实了：
RegLossCenterNet 期望回归分支维度 固定=8（offset2 + z1 + log(dim)3 + rot2），但你把 iou 也塞进了 HEAD_ORDER，导致 pred_boxes 变成 9 通道，而 target 仍是 8 通道，于是 _reg_loss 里 regr * mask 直接炸。

下面给你“一套正确且更稳的 IoU-branch 用法”（按你贴的 loss_utils.calculate_iou_loss_centerhead 的实现来对齐）。

1）配置文件必须这样改（关键）

✅ 把 `iou` 从 `HEAD_ORDER` 移除

HEAD_ORDER 只能放回归用的 4 个分支：

yaml
SEPARATE_HEAD_CFG:
  HEAD_ORDER: ['center', 'center_z', 'dim', 'rot']
  HEAD_DICT: {
    'center': {'out_channels': 2, 'num_conv': 2},
    'center_z': {'out_channels': 1, 'num_conv': 2},
    'dim': {'out_channels': 3, 'num_conv': 2},
    'rot': {'out_channels': 2, 'num_conv': 2},
  }

✅ `iou` 不要写在 `HEAD_DICT` 里（交给代码自动加）

你代码里已经：

python
if self.use_iou_branch:
    cur_head_dict['iou'] = dict(out_channels=1, num_conv=2)

所以 cfg 里不要再重复写 iou（避免你以后忘了 HEAD_ORDER 又加回来）。

2）代码再加一道“保险”（强烈建议）

在 CenterHeadX.get_loss() 里，把这一行：

python
pred_boxes = torch.cat([pred_dict[head_name] for head_name in self.separate_head_cfg.HEAD_ORDER], dim=1)

改成（就算 cfg 写错也不会再炸）：

python
bbox_order = [n for n in self.separate_head_cfg.HEAD_ORDER if n != 'iou']
pred_boxes = torch.cat([pred_dict[n] for n in bbox_order], dim=1)

3）你现在的 IoU loss 监督是 [-1, 1]，所以 iou 输出必须被“限制到 [-1,1]”

你贴的 loss 里是：

python
iou_target = iou * 2 - 1   # 监督范围 [-1,1]
loss = L1(iou_pred, iou_target)

但你当前 iou head 输出是任意实数（Conv2d 直接输出），这会导致：

训练很难稳定对齐 [-1,1]
推理时你 (iou+1)*0.5 会大量超出 [0,1] 再被 clamp，信息直接被“打平”

✅ 正确做法：对 iou head 输出做 `tanh`

在 CenterHeadX.forward() 里，拿到 pred_dicts 后立刻加：

python
pred_dicts = []
for head in self.heads_list:
    d = head(x)
    if 'iou' in d:
        d['iou'] = torch.tanh(d['iou'])   # 关键：限制到 [-1,1]，匹配你的 iou_loss 设计
    pred_dicts.append(d)

这样：

calculate_iou_loss_centerhead 的监督目标 [-1,1] 会更好学
推理时 (iou+1)/2 会自然落在 [0,1]

然后你 generate_predicted_boxes() 里这句就合理了：

python
batch_iou = (pred_dict['iou'] + 1) * 0.5

4）你配置里还有两处会明显影响效果（建议顺手改）

A）`POST_CENTER_LIMIT_RANGE` 必须和数据集范围一致

你的 dataset 是：

POINT_CLOUD_RANGE: [0, -20, -2, 160, 20, 6]

但你 cfg 里还写的是老的：

[-160, -75.2, -5, 160, 75.2, 8]

✅ 建议直接改成：

yaml
POST_CENTER_LIMIT_RANGE: [0, -20, -2, 160, 20, 6]

不然推理阶段会在不一致的范围做过滤，指标可能莫名掉。

B）你现在 `NMS_THRESH: 0.01` 太狠了

0.01 会把大量正常框也压掉（尤其小目标、框抖动大时），建议先回到更常见范围：

yaml
NMS_THRESH: 0.1

如果你愿意再进一步，我建议把 NMS_TYPE 换成 class_specific_nms（小类更受益）。

5）你下一步该怎么跑实验（最省事、最能定位问题）

建议按下面顺序，一次只动一个变量：

先保证能训练：按上面 1/2/3 改完（移除 HEAD_ORDER 的 iou + tanh iou）
先不开 score rectify，只训练 iou 分支看 loss 是否正常下降：
- USE_IOU_TO_RECTIFY_SCORE: False
再打开 rectify：
- USE_IOU_TO_RECTIFY_SCORE: True
最后再调 IOU_RECTIFIER（先全 0.5，再让 Kite/Bird=0.7）

如果你按上面改完还报错，把新的 traceback 贴出来（尤其是 centernet_utils.decode_bbox_from_heatmap 返回的 final_dict 有没有 pred_iou），我可以把“rectify score”那段改成完全匹配你 centernet_utils 版本的写法（不同 OpenPCDet/CenterPoint fork 在字段名上经常不一样）。

Answer 22

你这组结果掉得这么厉害（mAP 46 vs 54），我几乎可以肯定 不是 “IoU 分支这个思路必然不行”，而是你现在配置里有两处会把 recall 直接砍掉 + 我给你的“类别权重 focal”实现方式会把负样本也一起加权，在 CenterNet/CenterPoint 这种 heatmap 极度稀疏监督里非常容易把训练带偏。

下面按“先止血、再逐步加料”的顺序给你一套可操作的修复方案（每一步都是独立变量，你能清楚看到是哪一步在拖后腿）。

1) 先止血：你现在 cfg 里有两个会明显压死 recall 的设置

A. `POST_CENTER_LIMIT_RANGE` 必须和数据集 `POINT_CLOUD_RANGE` 一致

你的数据集范围是： POINT_CLOUD_RANGE: [0, -20, -2, 160, 20, 6]

但你 cfg 里还写： POST_CENTER_LIMIT_RANGE: [-160, -75.2, -5, 160, 75.2, 8]

这会在推理阶段用一个完全不同的范围过滤框，指标会很怪（尤其 y 范围差太大）。

✅ 改成：

yaml
POST_CENTER_LIMIT_RANGE: [0, -20, -2, 160, 20, 6]

B. `NMS_THRESH: 0.01` 太狠了（基本等于“宁可错杀”）

0.01 会把一堆正常框直接压掉，小目标更惨。你现在 recall 从 67 掉到 60，非常符合这个特征。

✅ 建议先改成：

yaml
NMS_CONFIG:
  NMS_TYPE: class_specific_nms
  NMS_THRESH: 0.1
  NMS_PRE_MAXSIZE: 4096
  NMS_POST_MAXSIZE: 500

并把 SCORE_THRESH 先降一点（先保 recall，再靠 NMS/rectify 控 FP）：

yaml
SCORE_THRESH: 0.05

仅这两条（范围一致 + NMS 0.1）经常就能把 mAP 拉回去一大截。

2) 你现在 “HM_CLASS_WEIGHTS” 的用法会伤训练：它把负样本也一起加权了

你当前 centernet_focal_loss 写法是 loss = (pos_loss + neg_loss) * w。
但 heatmap 里 负样本数量远大于正样本，于是你给 Kite/Bird 的权重=2，会让它们的 负样本惩罚也翻倍，模型会更保守，更不敢打高分 → recall 掉 → mAP 掉。

✅ 正确做法：只给正样本加权（或者只对 pos_loss 加权）

把你 centernet_focal_loss 里这段：

python
loss = pos_loss + neg_loss
if class_weights is not None:
    w = pred.new_tensor(class_weights).view(1, -1, 1, 1)
    loss = loss * w

改成：

python
if class_weights is not None:
    w = pred.new_tensor(class_weights).view(1, -1, 1, 1)
    pos_loss = pos_loss * w     # 只加权正样本
# neg_loss 不加权
loss = pos_loss + neg_loss

然后 先把 cfg 里的 HM_CLASS_WEIGHTS 注释掉跑一轮，确认 IoU 分支单独是否带来稳定提升；再加回权重（但用上面“只加权 pos”的实现）。

3) 你 cfg 里还有一个“加剧不稳定”的点：NUM_HIST_BINS 10

你之前最好成绩是在 bin=8 附近（你一开始就是 8），现在改 10 属于额外变量，而且直方图更细更容易过拟合/噪声更大。

✅ 先回到：

yaml
NUM_HIST_BINS: 8

4) IoU 分支这块，按你 loss 的设计，必须保证输出在 [-1,1]

你 loss 里是把 IoU target 映射到 [-1,1] 并用 L1 回归：

python
iou_target = iou * 2 - 1
loss = L1(iou_pred, iou_target)

所以你必须保证网络输出也被限制到 [-1,1]（否则训练很难稳定）。

你之前做的 tanh(iou) 是对的。确认你现在 forward 里确实有：

python
if 'iou' in d:
    d['iou'] = torch.tanh(d['iou'])

推理里继续用：

python
batch_iou = (pred_dict['iou'] + 1) * 0.5

5) 推荐你下一轮实验的“最稳配置”（先让分数回到 54+ 再谈提升）

先不要上 class weight、不要上 rectify（先验证 iou 分支是不是正常学到质量）。

配置建议（最小变量）

yaml
DENSE_HEAD:
  NAME: CenterHeadX
  USE_IOU_BRANCH: True
  IOU_REG_LOSS: False
  # 先关掉：
  # HM_CLASS_WEIGHTS: ...
  POST_PROCESSING:
    SCORE_THRESH: 0.05
    USE_IOU_TO_RECTIFY_SCORE: False   # 先关
    POST_CENTER_LIMIT_RANGE: [0, -20, -2, 160, 20, 6]
    NMS_CONFIG:
      NMS_TYPE: class_specific_nms
      NMS_THRESH: 0.1
      NMS_PRE_MAXSIZE: 4096
      NMS_POST_MAXSIZE: 500

训练 5～10 个 epoch 看趋势（hm_loss、iou_loss 是否都在降；val recall 是否回升）。
如果这版能回到基线附近，再做下一步：

第二步：打开 rectify（但 rectifier 先保守）

yaml
POST_PROCESSING:
  USE_IOU_TO_RECTIFY_SCORE: True
  IOU_RECTIFIER: [0.3, 0.3, 0.4, 0.3, 0.4]

等稳定后，才把 Kite/Bird 提高到 0.6~0.7。

6) 如果你想“换一个更确定能涨”的模块（不碰 neck / 不碰 head 结构）

在你这种小目标稀疏场景里，最硬核的提升通常来自 更高 BEV 分辨率：

把 voxel 从 [0.1,0.1,0.2] 改到 [0.075,0.075,0.2]（你 FPS 还有余量），并把 max voxels 提一点：

yaml
VOXEL_SIZE: [0.075, 0.075, 0.2]
MAX_NUMBER_OF_VOXELS:
  train: 100000
  test: 140000

这类改动往往比“花式融合 neck”更直接提升 Bird/Kite 的 recall。

你现在立刻该做什么

cfg 改：POST_CENTER_LIMIT_RANGE 对齐 + NMS_THRESH=0.1 + class_specific_nms + SCORE_THRESH=0.05 + hist bins 回 8
代码改：HM_CLASS_WEIGHTS 只加权 pos_loss（或者先彻底关掉 HM_CLASS_WEIGHTS）
先跑 “IoU 分支训练但不 rectify” 的版本，确认不掉点再开 rectify。

如果你把你当前一轮训练 log 里这几项贴出来（前 1~2 个 epoch 就够）：

hm_loss_head_0
loc_loss_head_0
iou_loss_head_0
val 的 [email protected]/0.5

我就能非常快判断：现在到底是 NMS/范围配置导致的“推理阶段掉点”，还是 训练阶段 heatmap/权重把模型带偏。

Answer 23

你现在这组（mAP 52.35，FPS 26）其实已经说明两件事：

精度没回到你最强的 54.59，但差距不算离谱；
速度掉到 26 是明显异常（通常是推理阶段保留了太多候选框 / NMS 太重，或训练阶段每步做了额外 decode+NMS + 3D IoU 计算）。

而你这份 cfg 里有 3 个“不是默认、而且很可能直接拉低精度/拉低速度”的点——它们不算“小调参”，属于明显的配置错误/不匹配，我建议你下一步先只改这 3 处（非常少的改动），把结果拉回正常轨道，再谈提升。

下一步只改 3 处（强烈建议先做）

1）把 `POST_CENTER_LIMIT_RANGE` 改成与你数据集一致

你的数据集范围是：[0, -20, -2, 160, 20, 6]
但你还在用老的 [-160, -75.2, ...]，推理过滤范围不一致会让指标很怪。

把这一行改掉：

yaml
POST_CENTER_LIMIT_RANGE: [0, -20, -2, 160, 20, 6]

2）把 `NMS_THRESH` 从 0.01 改回正常值（否则 recall 和速度都容易崩）

0.01 太苛刻，容易错杀；并且在某些实现里还会导致 NMS 处理的候选数量异常，影响速度。

改成：

yaml
NMS_CONFIG:
  NMS_TYPE: nms_gpu
  NMS_THRESH: 0.1
  NMS_PRE_MAXSIZE: 1000
  NMS_POST_MAXSIZE: 500

你说不想改很多参数：这里其实只是在“恢复到合理默认区间”，不是细调。

3）先关掉 `HM_CLASS_WEIGHTS`（你现在这套实现很容易把负样本也加权，导致模型更保守）

你 cfg 里现在：

yaml
HM_CLASS_WEIGHTS: [1.0, 1.0, 2.0, 1.0, 2.0]

在 CenterNet/CenterPoint 的稀疏 heatmap 里，负样本远多于正样本，如果“负样本也被加权”，模型会更不敢给 Kite/Bird 打分，recall 会掉。

下一轮先直接注释掉：

yaml
# HM_CLASS_WEIGHTS: [1.0, 1.0, 2.0, 1.0, 2.0]

（等你确认 IoU 分支本身是增益，再考虑用“只加权正样本”的实现方式。）

同时我建议你做 1 个“不是调参、是修 bug 级别”的小改动

你 cfg 里写了 IOU_LOSS_WEIGHT: 1.0，但你现在的 CenterHeadX.get_loss() 没有乘这个权重，等于这个超参无效，而且 iou loss 可能过强/过弱都不可控。

在这段里：

python
iou_loss = loss_utils.calculate_iou_loss_centerhead(...)
loss += iou_loss

改成：

python
iou_loss = loss_utils.calculate_iou_loss_centerhead(...)
iou_w = float(self.model_cfg.get('IOU_LOSS_WEIGHT', 1.0))
loss += iou_w * iou_loss

下一轮我建议先用更保守的：

yaml
IOU_LOSS_WEIGHT: 0.2

（这不是“细调”，而是避免 iou loss 抢走回归学习的主导权。）

给你一份“下一轮最少改动可跑 cfg 核心段”

你只需要替换 DENSE_HEAD.POST_PROCESSING 这块 + 注释 HM_CLASS_WEIGHTS + 改 POST_CENTER_LIMIT_RANGE：

yaml
DENSE_HEAD:
  NAME: CenterHeadX
  USE_IOU_BRANCH: True
  IOU_LOSS_WEIGHT: 0.2
  IOU_REG_LOSS: False
  # HM_CLASS_WEIGHTS: [1.0, 1.0, 2.0, 1.0, 2.0]  # 先关

  POST_PROCESSING:
    SCORE_THRESH: 0.1
    USE_IOU_TO_RECTIFY_SCORE: True
    IOU_RECTIFIER: [0.5, 0.5, 0.7, 0.5, 0.7]
    POST_CENTER_LIMIT_RANGE: [0, -20, -2, 160, 20, 6]
    MAX_OBJ_PER_SAMPLE: 500
    NMS_CONFIG:
      MULTI_CLASSES_NMS: False
      NMS_TYPE: nms_gpu
      NMS_THRESH: 0.1
      NMS_PRE_MAXSIZE: 1000
      NMS_POST_MAXSIZE: 500

如果你只想做“一个模块级改动”来追求提升（不改一堆小参数）

在你现在这套 CenterHeadX 基础上，我更推荐的“模块级改动”是：

✅ 把 `CLASS_NAMES_EACH_HEAD` 拆成 2 个 head（一个小目标组，一个大/稳定组）

这是 一行配置改动，通常对 Kite/Bird 这种小目标更友好：

yaml
CLASS_NAMES_EACH_HEAD: [
  ['Bird', 'Kite'],
  ['Drone', 'Plastic_sheet', 'Balloon']
]

它的好处是：共享卷积/分类头不需要同时兼顾“巨大 balloon”与“极小 bird”，冲突会少很多。
这比继续换 neck 稳得多，也符合你“不想改很多小参数”的要求。

你下一步怎么做（最省实验次数）

按“只改 3 处 + IOU_LOSS_WEIGHT 生效”先跑一轮（看 mAP 是否回到 54 附近、FPS 是否恢复）
如果恢复了，再做“拆 head 分组”（只动 CLASS_NAMES_EACH_HEAD 一处）

如果你把这轮 FPS=26 是怎么测的说明一下（是 test.py 推理 FPS 还是训练 it/s），我可以更准确地告诉你：速度瓶颈到底来自 NMS候选太多 还是来自 训练里每步算 3D IoU，并给你一个“几行代码就能把速度拉回去”的办法。

Pergunta

Pensamento

Resposta

1. 为什么推荐 Voxel R‑CNN 做你的主干

1.1 性能 & FPS 综合比较适合你

1.2 文献 & 改进资源非常多（中英文都有）

2. 结合你 Tele‑15 单轨场景的 Voxel R‑CNN 方案

2.1 点云 & 体素化设计（结合 Tele‑15）

建议的体素配置（OpenPCDet 式）

2.2 主网络结构：基于 Voxel R‑CNN 的整体架构

2.3 专门针对“小目标 + 不规则目标”的改法

2.3.1 BEV 多尺度 FPN，加密近轨道区域

2.3.2 针对不规则目标：增强 RoI 内部几何建模

2.3.3 小目标 / 远距离目标的正负样本与 loss

2.4 训练上的工程建议

3. 你可以参考的主流基线 & 改进论文（按表示方式划分）

3.1 体素（Voxel‑based）

3.2 PILLAR（PointPillars 及其改进）

3.3 点（Point‑based）

3.4 总览/综述类资料（看全局结构 & 常见 trick）

4. 你可以实际动手的一个“改法路线图”（总结一下）

Pergunta

Pensamento

Resposta

一句话先定基线

1. 为什么选 CenterPoint(voxel) 做单阶段体素基线

1.1 模型属性：完全符合你提的三个关键点

2. 结合 Tele‑15 单轨场景的 CenterPoint(voxel) 配置思路

2.1 点云范围 & 体素设置（按你给的参数）

2.2 单轨 + 小目标 + 不规则目标要注意的两点

3. “大家在体素模型上都改什么？”——按模块拆 + 附典型论文

3.1 体素表示层的改进点

3.1.1 密度感知 / 距离感知体素（解决长距离稀疏 & 小目标）

3.1.2 体素筛选 / 体素净化（去掉大量背景体素，提速 + 减噪）

3.1.3 时序体素编码（连续帧融合，适用于 Tele‑15）

3.2 3D 体素 Backbone / 注意力 的改进点

3.2.1 Voxel Self‑Attention / Transformer

3.2.2 结构信息融合 / 结构注意力

3.3 BEV Neck / 多尺度特征的改进点

3.3.1 CenterPoint‑SAE：空间感知增强的 CenterPoint

3.3.2 PST‑FPN：伪时空特征金字塔（VSAC）

3.3.3 Region‑aligned 单阶段体素检测

3.4 检测 Head & Loss 的改进点（IoU‑aware / 邻域投票等）

3.4.1 CIA‑SSD：IoU‑Aware 单阶段体素检测器

3.4.2 NIV‑SSD：邻域 IoU 投票（Neighbor IoU‑Voting）

3.4.3 Fully Sparse + Center‑based（FSD / FSDv2）

3.5（可选）语义 / 多模态 / 融合类改进

4. 给你一个实际可落地的“改进组合”示例

Pergunta

Pensamento

Resposta

0. 先统一一下基线：你的 VoxelNeXt 长啥样

1. 先把「Tele‑15 单轨版 VoxelNeXt」跑起来

1.1 点云范围 & 体素参数

1.2 利用“单轨场景先验”做预裁剪

2. 围绕 VoxelNeXt 的「体素改进点」怎么选？——分模块讲 + 给论文来源

2.1 Backbone：面向“长距 + 轨道障碍”的稀疏注意力（RVSA‑3D 系）

改动 2.1‑A：在 VoxelNeXt backbone 里加 SPA（子流形池化注意力）

改动 2.1‑B：在高层 stage 引入“高置信稀疏注意力”（HSA）

2.2 Voxel 选择 / 净化：减少无效背景体素 + 提升 FPS（VPSNet 系）

改动 2.2‑A：用 VPSNet 的“voxel purification”替换/增强 VoxelNeXt 的 prune

2.3 Density / Distance 感知：远距离小目标（PDV 系 + Tele‑15 特性）

改动 2.3‑A：在 VFE 里加入 Point Density & Depth 特征（PDV）

改动 2.3‑B：强度直方图增强（Intensity-Aware Voxel Encoder）

2.4 多尺度聚合 & 小目标：用 RAE3D / VoxT‑GNN 的思路改 VoxelNeXt Head

改动 2.4‑A：多尺度 voxel 聚合到 query（RAE3D 的 MVA‑PQ）

改动 2.4‑B：局部 region‑to‑region 聚合（VoxT‑GNN）

2.5 检测头 & Loss：IoU‑aware + 邻域投票

改动 2.5‑A：CIA‑SSD 风格的 IoU‑aware Head

改动 2.5‑B：NIV‑SSD 邻域 IoU 投票（Neighbor IoU Voting）

2.6 时序 + 轨道场景：充分利用 VoxelNeXt 的 tracking 扩展

改动 2.6‑A：两帧或三帧体素时间融合

改动 2.6‑B：利用 voxel association 做“轨道占用”判断

3. 一个「可逐步落地」的 VoxelNeXt 改进路线

阶段 1：基线 VoxelNeXt + Tele‑15 适配

阶段 2：长距 + 小目标增强（相对便宜的改法）

阶段 3：Backbone & 多尺度聚合（中等成本）

阶段 4：极致版（可选）

Pergunta

Pensamento

3.2 3D 体素 Backbone / 注意力的改进点

Step 2：把下面代码粘进 `pdv_mean_vfe.py`（可直接替换整个文件）

✅ A. `voxel_coords` 的索引顺序

3) 你问的重点：代码“从哪里复制到哪里”——按你现在 `MeanVFE` 的工程来做

Step 2：把 `pdv_mean_vfe.py` 内容替换成你的 `PDVMeanVFE`（用我上面建议的“兼容版 init”）

3.1 我的建议：新建一个 `PDVIntensityVFE` 类（在原文件上加功能）

3.2 在 `forward` 里加直方图