自动驾驶-M2 感知与 BEV-2.3.1 BEVFormer 训练实战代码解读

本节做一个重要的技术决策:不用官方仓库,自己实现精简版—— 理由在下面,这不是偷懒,是在你的硬件上唯一正确的选择。学习课程 端到端自动驾驶实战 | zhijia.dev

先看一下课程页面的内容,好让讲解和课程对上。

BEVFormer 训练实战:完整讲解

0. 先说清楚这节课在做什么

一句话:输入 6 个摄像头同一时刻拍的照片,输出一张俯视图(BEV,Bird's Eye View),图上标出车、行人等物体的位置、大小和朝向。

整个流程是:

6 张照片 → [ResNet 提特征] → 6 张特征图
                                  ↓
128×128 的空 BEV 网格 → [每个格子去 6 张特征图里"取"特征] → BEV 特征图
                                  ↓
                     [检测头] → 热力图(哪里有物体)+ 回归量(物体多大、朝哪)

课程一共有三份代码:

文件 作用
mini_bevformer.py 模型本身和损失函数
bev_target.py 把标注的 3D 框转换成模型能学的"答案"格式
train_bev.py 训练循环

下面按"为什么 → 是什么 → 数据怎么变"的顺序讲。


1. 背景:为什么要做 BEV,BEVFormer 的思路是什么

1.1 为什么要转成俯视图

自动驾驶下游的规划和控制模块,需要的是"车周围 50 米内,哪里有什么东西"。这本质上是一张地图,不是 6 张照片。直接在照片上检测会碰到几个问题:

  • 6 个相机各看各的:一辆车横跨前相机和右前相机,会被检测两次,还得再想办法合并。
  • 透视变形:远处的车在图上很小,近处的很大。同样一辆车,图像上的尺寸随距离变化很大。
  • 2D 结果不能直接用:图像里的框是像素坐标,规划要的是米制坐标。

转到 BEV 后,6 个相机的信息天然合并到同一张图上;一辆车无论远近,在 BEV 上都是约 4.5m × 1.8m;输出直接就是自车坐标系下的米制位置。

1.2 两种转 BEV 的思路:"推"和"拉"

难点在于:照片是 2D 的,丢掉了深度。图上一个像素对应的是空间里的一整条射线,不知道物体在这条射线上的哪个位置。

派别 代表 做法
推(push) LSS 对图像每个像素预测一个深度分布,把特征沿射线"撒"到 3D 空间,再拍扁成 BEV
拉(pull) BEVFormer 从 BEV 格子出发,问一句"我这个位置投到照片上是哪个像素?",然后去那里把特征取回来

"拉"的思路有个好处:从 3D 投影到 2D 是确定的,只要知道相机参数就能精确算出来,不需要预测深度。反过来 2D 到 3D 才有歧义。BEVFormer 绕开了"深度怎么估"这个难题。

1.3 为什么不用官方仓库(课程第一部分)

这是一条版本依赖链,最后卡在硬件上:

官方 BEVFormer → 依赖 mmcv-full 1.4 + mmdet3d 0.17
              → 这套 mmcv 只能配 torch 1.9/1.10
              → torch 1.9/1.10 编译时最高只支持到 sm_86 架构的 GPU
              → 你的 L20 是 sm_89(Ada 架构)
              → 没有原生 CUDA kernel,只能靠 PTX JIT 临时编译,又慢又容易崩

所以课程选择用 torch 2.x 自己写大约 300 行。好处是能跑、能随意修改做实验,而且自己写过一遍才能真正理解。代价是有三处简化,要心里有数:

  1. 固定采样点:论文让网络自己学"往哪里偏一点去采样"(可变形注意力),这里只在固定位置采样。
  2. 检测头换成 CenterPoint 风格的热力图:论文用 DETR 风格的 query,在小数据上很难收敛。
  3. 不做时序融合:论文会把上一帧的 BEV 拿来一起用,这里只看当前帧。

2. 完整的数据流(按推荐配置)

推荐配置是:B=4(batch)、N=6(相机数)、图像 256×448、BEV 128×128、C=256(特征维度)、Z=4(每个格子取 4 个高度)。

步骤 张量 形状 含义
输入 imgs [4, 6, 3, 256, 448] 4 个样本,每个 6 张 RGB 图
输入 lidar2img [4, 6, 4, 4] 每个相机一个投影矩阵
骨干展平 x [24, 3, 256, 448] 把 B 和 N 合并,ResNet 只认 4 维输入
ResNet 到 layer3 x [24, 1024, 16, 28] 下采样 16 倍
1×1 卷积降维 x [24, 256, 16, 28]
还原 img_feats [4, 6, 256, 16, 28]
BEV query bev_q [4, 16384, 256] 128×128=16384 个格子,每格一个 256 维向量
格子坐标 bev_coords [16384, 2] 每格中心的 (x, y),单位米
3D 参考点 ref_h [65536, 4] 16384 格 × 4 个高度,齐次坐标
投影 pts [4, 6, 65536, 4] 每个点在每个相机下的 (u·d, v·d, d, 1)
采样 sampled [4, 6, 16384, 4, 256] 每个点在每个相机上取到的特征
有效平均 out [4, 16384, 256] 每个格子融合后的特征
编码器 ×3 层 bev [4, 16384, 256]
变回图像形状 bev [4, 256, 128, 128] 变成一张"俯视特征图"
检测头 heatmap [4, 4, 128, 128] 4 类物体各一张热力图
检测头 reg [4, 8, 128, 128] 每个位置 8 个回归量

下面逐个模块拆开讲。


3. 模型逐模块讲解

3.1 ImageBackbone:图像特征提取

self.stem = nn.Sequential(net.conv1, net.bn1, net.relu, net.maxpool,
                          net.layer1, net.layer2, net.layer3)
self.proj = nn.Conv2d(1024, out_channels, 1)

做了什么:用 ImageNet 预训练的 ResNet50,只取到 layer3。

为什么只取到 layer3:ResNet 每一级把分辨率减半:conv1 是 /2,maxpool 后 /4,layer2 后 /8,layer3 后 /16,layer4 后 /32。

  • 到 /32 时,256×448 的图只剩 8×14 个特征点,太粗,远处的小物体会被压没。
  • 到 /16 时是 16×28,语义信息已经比较丰富,分辨率也还够用。这是一个折中。
  • 少一个 layer4 还能省下大量参数和显存。

为什么要 1×1 卷积把 1024 降到 256:后面 BEV 的 16384 个格子每个都是 256 维,图像特征维度要和它一致才能相加。另外,后面会采样出 [4, 6, 16384, 4, C] 这么大的张量,C 从 1024 降到 256,显存直接省 4 倍。

flatten(0,1) 的作用:ResNet 只接受 [批次, 通道, 高, 宽] 这样的 4 维输入。把"4 个样本 × 6 个相机"当成 24 张独立的图片一起送进去,6 个相机共用同一套权重,处理完再 view 回 5 维。

3.2 BEV Query 和格子坐标

self.bev_embedding = nn.Embedding(self.bev_h * self.bev_w, embed_dims)  # [16384, 256]
self.register_buffer('bev_coords', self._make_coords())                 # [16384, 2]

这里有两样东西,要分清楚:

bev_embedding bev_coords
是什么 每个格子一个 256 维向量 每个格子中心的 (x, y) 米制坐标
会不会被训练 会,是可学习参数 不会,是固定的几何量
作用 格子的"初始身份",网络能学到"我是左前方 20 米的格子" 告诉 SCA 这个格子在真实世界的哪里,用来投影

register_buffer 的意思是:这个张量会跟着 model.to(device) 一起搬到 GPU,也会存进 checkpoint,但优化器不会更新它。

坐标系约定(后面编码真值时必须严格一致):

xs = torch.linspace(51.2, -51.2, 128)   # 行:第 0 行是 x=+51.2(正前方最远)
ys = torch.linspace(-51.2, 51.2, 128)   # 列:第 0 列是 y=-51.2(最左)

画出来是这样(自车在中心):

        列 0 (y=-51.2)  ...  列 127 (y=+51.2)
行 0    (x=+51.2) ←── 车头前方最远处
 ...            🚗 (自车在中心,车头朝上)
行 127  (x=-51.2) ←── 车尾后方最远处

覆盖范围是前后左右各 51.2 米,128 格,每格 102.4/128 = 0.8 米。

meshgrid(indexing='ij') 加 flatten,得到的扁平索引是 行 × 128 + 列。这个顺序后面 reshape 回 [128, 128] 时还会用到。

3.3 SpatialCrossAttention:核心的 5 步

这是整节课的重点。先说直觉,再逐步看代码。

直觉:BEV 上一个格子,比如"前方 20 米、右边 5 米",代表地面上的一块 0.8m×0.8m 的区域。物体可能站在上面,有一定高度。于是在这个格子上方竖一根"柱子",在柱子上取 4 个点(高度 -2m、0m、2m、4m)。把这 4 个 3D 点分别投到 6 个相机上,看落在哪些照片的哪个像素,就把那里的特征取回来,最后求平均。

为什么要取多个高度:一辆车高约 1.5m,行人约 1.7m,卡车可能有 4m。如果只取地面 z=0 那一个点,投到图像上可能只落在车轮附近。取多个高度就能覆盖物体的整个竖直范围。

第 1 步:构造 3D 参考点

zs = torch.linspace(-2.0, 4.0, 4)          # [-2, 0, 2, 4]
ref = torch.zeros(16384, 4, 3)
ref[:, :, 0] = bev_coords[:, 0:1]          # x:每个格子 4 个点 x 相同
ref[:, :, 1] = bev_coords[:, 1:2]          # y:同上
ref[:, :, 2] = zs.unsqueeze(0)             # z:4 个高度
ref_h = torch.cat([ref.reshape(-1, 3), torch.ones(65536, 1)], dim=1)  # [65536, 4]

最后补了一列 1,变成齐次坐标 (x, y, z, 1)。原因是投影包含"旋转 + 平移 + 内参",平移不是线性运算,没法用一个 3×3 矩阵表示。补一个 1 之后,就能用一个 4×4 矩阵乘法一次完成全部变换。

第 2 步:投影到 6 个相机

pts = torch.einsum('bnij,pj->bnpi', lidar2img, ref_h)   # [4, 6, 65536, 4]
depth = pts[..., 2]
uv = pts[..., :2] / torch.clamp(depth.unsqueeze(-1), min=eps)

lidar2img 是什么:它是"相机内参 K × 外参(自车到相机的旋转和平移)"合成的 4×4 矩阵,由数据集(2.1、2.2 节)准备好。乘完之后,得到 (u·d, v·d, d, 1),其中 d 是这个点到相机的深度。除以 d 就得到像素坐标 (u, v),这就是小孔成像的"近大远小"。

einsum 读法:bnij,pj->bnpi 的意思是,对每个样本 b、每个相机 n、每个点 p,算"矩阵 [i,j] × 向量 [j]"。一行代码就完成了 4 × 6 × 65536 次矩阵乘法,不需要写循环。

用数字走一遍(用代码自测里的相机:焦距 f≈320,图像 448×256,光心 (224, 128)):

3D 点 (x, y, z) 相机坐标 (右, 下, 前) 深度 d 像素 (u, v) 含义
(20, 0, 0) (0, 0, 20) 20 (224, 128) 正前方 20 米,落在图像正中心
(20, 5, 1) (5, -1, 20) 20 (304, 112) 偏右、偏高,所以在图中偏右上
(-20, 0, 0) (0, 0, -20) -20 无意义 在相机背后,看不见

clamp(min=eps) 是为了防止除以 0 或负数。深度为负的点由下一步的掩码剔除。

第 3 步:有效性掩码

img_w, img_h = w * 16, h * 16      # 28*16=448, 16*16=256,还原原图尺寸
u_norm = uv[..., 0] / img_w * 2 - 1
v_norm = uv[..., 1] / img_h * 2 - 1
valid = (depth > eps) & (u_norm > -1) & (u_norm < 1) & (v_norm > -1) & (v_norm < 1)

为什么要归一化到 [-1, 1]:下一步用的 F.grid_sample 规定坐标必须是归一化的,-1 表示左边缘,+1 表示右边缘。这样做的好处是不用关心特征图实际多大。像素坐标 (u, v) 是在原图 448×256 上算的,而特征图只有 28×16,但归一化后两者对应同一个相对位置,所以不需要手动除以 16。

valid 判断的是什么:这个点必须同时满足在相机前方,并且落在图像范围内。

一个 BEV 格子通常只被 1 到 2 个相机看到。比如正前方的格子只会落在前相机里,其余 5 个相机都无效。课程里提到的"99.7% 的格子至少被一个相机覆盖,正前方的格子只被 CAM_FRONT 采到",验证的就是这一步的几何计算是正确的。

第 4 步:采样图像特征

feats = img_feats.flatten(0, 1)                 # [24, 256, 16, 28]
g = grid.flatten(0, 1).unsqueeze(2)             # [24, 65536, 1, 2]
sampled = F.grid_sample(feats, g, mode='bilinear', padding_mode='zeros', align_corners=False)
                                                # [24, 256, 65536, 1]
sampled = sampled.squeeze(-1).permute(0, 2, 1)  # [24, 65536, 256]
sampled = sampled.view(4, 6, 16384, 4, 256)

grid_sample 做什么:给定一张特征图和一组坐标,返回每个坐标处的特征值。坐标通常不在整数格点上(比如落在第 10.3 列、第 7.6 行),bilinear 会用周围 4 个格点按距离加权插值。这样做的好处是对坐标可导,结果平滑。

为什么要 unsqueeze(2):grid_sample 要求 grid 是 [N, H_out, W_out, 2],也就是输出本身也是一张"图"。这里把 65536 个点排成 65536×1 的一张图来骗过它,采完再 squeeze 掉。

最后 view 成 [B, N, 格子, 高度, C],把"哪个相机、哪个格子、哪个高度"分开,方便下一步求平均。

第 5 步:按有效性加权平均

m = valid.view(4, 6, 16384, 4, 1).float()
summed = (sampled * m).sum(dim=(1, 3))      # 对 相机 和 高度 两个维度求和 → [4, 16384, 256]
count = m.sum(dim=(1, 3)).clamp(min=1.0)    # 每个格子有几个有效采样
out = summed / count
return self.output_proj(out) + bev_query    # 线性层 + 残差

为什么不直接对 6×4=24 个采样求平均:一个格子平均只有 4 到 8 个有效采样。如果连同 16 个无效的 0 一起平均,特征会被稀释,而且稀释程度取决于格子被几个相机覆盖,比如位于两个相机重叠区的格子会显得"更亮"。只对有效采样平均,所有格子的特征量级就一致了。

clamp(min=1) 用来处理那 0.3% 一个相机都看不到的格子,避免除以 0。

残差 + bev_query:这是 Transformer 的标准做法。即使采样出来的特征一开始没什么用,也至少保留了格子原本的身份信息。梯度还可以通过这条捷径直接回传,深层网络更容易训练。

3.4 BEVEncoder:堆叠 3 层

x = layer['norm1'](layer['sca'](x, ...))     # 采样 + 残差 + LayerNorm
x = layer['norm2'](x + layer['ffn'](x))      # 前馈网络 + 残差 + LayerNorm

这是标准 Transformer 编码层的结构(Post-Norm):

  • SCA 负责从图像里取信息。
  • FFN(256→512→256 的两层全连接)负责让每个格子在自己的 256 维特征内部做非线性加工。
  • LayerNorm 把每个向量的数值拉回均值 0、方差 1,防止叠了几层之后数值越来越大或越来越小。

3.5 CenterHead:检测头

self.shared = 两层 3×3 卷积 (256→128→128)
self.hm_head = nn.Conv2d(128, 4, 1)     # 4 类各一张热力图
self.reg_head = nn.Conv2d(128, 8, 1)    # 8 个回归量
self.hm_head.bias.data.fill_(-2.19)

进入检测头之前,先把 [4, 16384, 256] 变成 [4, 256, 128, 128],这样就是一张普通的"图像",可以用卷积处理。3×3 卷积能让相邻格子交换信息。一辆车占好几个格子,需要综合周围的信息来判断。

CenterPoint 的思路:不直接预测"框",而是把检测变成两件事:

  1. 热力图:每个格子预测"这里是某类物体中心的概率"。物体中心处是峰值 1,周围逐渐降到 0。
  2. 回归量:在中心格子上再预测 8 个数,用来还原出完整的 3D 框。
通道 内容 用途
0, 1 亚像素偏移 (dx, dy) 格子是 0.8 米,真实中心可能在格子内部的某处
2 z 中心高度
3, 4, 5 log(l), log(w), log(h) 长宽高
6, 7 sin(yaw), cos(yaw) 朝向

为什么偏置初始化为 -2.19:sigmoid(-2.19) ≈ 0.1。如果用默认初始化,偏置为 0,所有格子一开始都预测概率 0.5。但实际上 99.9% 的格子都是背景,这样会在训练开始时产生巨大的负样本损失和梯度,训练容易炸掉。初始化成 0.1,意思是"先默认大部分地方没东西",起点更接近真实分布。这个值来自 CenterNet / Focal Loss 论文。

为什么比 DETR 风格的头好训练:DETR 有比如 900 个 query,每个 query 要自己"认领"一个物体,需要用匈牙利匹配来决定谁对应谁。匹配结果在训练初期很不稳定,所以收敛很慢(DETR 原版要训 500 个 epoch)。热力图是"每个格子直接对应地面上的那个位置",监督信号是固定的、密集的,几个 epoch 就能看到效果,更适合自采的小数据集。


4. 真值编码(bev_target.py)

模型输出的是热力图和回归图,但标注是一串 3D 框 (x, y, z, l, w, h, yaw)。所以要把标注"画"成和模型输出同样格式的答案,才能计算损失。

4.1 坐标转换(必须和 _make_coords 对上)

voxel = 2 * 51.2 / 128      # 0.8 米/格
col_f = (y + 51.2) / voxel  # y=-51.2 → 第 0 列;y 越大越靠右
row_f = (51.2 - x) / voxel  # x=+51.2 → 第 0 行;x 越大越靠上

举例:前方 20 米、右边 5 米的车,col_f = 56.25 / 0.8 = 70.3,row_f = 31.2 / 0.8 = 39.0。它的中心落在第 39 行第 70 列,格子内偏移是 (0.3, 0.0)。

课程的排错表里特别提到"热力图全是背景"这个问题。原因就是这里的行列方向要是和 _make_coords 不一致(比如 x 和 y 弄反,或者正负号反了),模型在 A 处看到车,答案却说车在 B 处,那就永远学不会。

4.2 画高斯

radius = max(2, int(max(l, w) / voxel / 2))
draw_gaussian(heatmap[label], (col, row), radius)

为什么不只在中心点标 1,周围全标 0:模型如果预测到了中心旁边的一格,其实已经很接近了。如果答案是"只有中心点是 1,其他全是 0",模型这个"差一点就对"的预测会和"完全错"受到同样的惩罚,学起来很困难。高斯分布的意思是"离中心越近,越像正样本",给模型一个平滑的梯度方向。

半径和物体大小相关:一辆 4.5 米的车,半径约 2.8 格,取整为 2 格;一辆 12 米的卡车,半径约 7 格;行人用最小值 2 格。大物体的中心本来就不容易精确定位,允许误差大一些。

np.maximum:两个物体的高斯有重叠时,取较大值而不是相加,保证峰值不超过 1。

4.3 回归目标的三个设计

① 朝向用 sin/cos,不直接用角度。 角度在 ±180° 处是断开的:179° 和 -179° 在数值上差 358°,实际上只差 2°。如果直接回归角度,车头朝正后方的样本会让 L1 损失产生巨大的跳变。sin 和 cos 都是连续的,(sin, cos) 对任何角度都平滑。推理时用 atan2(sin, cos) 还原角度。

② 尺寸取 log。 行人宽 0.6 米,卡车长 12 米,相差 20 倍。直接回归的话,卡车差 1 米和行人差 1 米损失一样,但对行人来说差 1 米已经错得离谱了。取 log 后衡量的是相对误差:log(12) − log(11) ≈ 0.087,log(0.6) − log(0.5) ≈ 0.18。另外,输出用 exp 还原,保证尺寸一定是正数。max(l, 0.1) 是为了防止 log(0)。

③ mask 只在中心格子上为 1。 回归量只在物体中心格子上有意义,背景格子没有"长宽高"可言。所以损失只在 mask=1 的地方计算。


5. 损失函数

5.1 热力图:CenterNet 风格的 Focal Loss

pos_loss = -log(p) * (1-p)^2                       # 只在 target == 1 的中心点
neg_loss = -log(1-p) * p^2 * (1-target)^4          # 其余所有格子
loss = (pos_loss.sum() + neg_loss.sum()) / 正样本数

要解决的问题是正负样本极度不平衡。128×128×4 = 65536 个位置,一个场景假设有 20 个物体,正负比约 1:3000。如果用普通的交叉熵,模型把所有位置都预测成 0 就能拿到很低的损失,然后就什么都不学了。

三个因子各有分工:

因子 作用
(1-p)^2(正样本) 已经预测得很准的正样本(p→1),损失权重趋近 0;没学会的,权重大
p^2(负样本) 已经正确判断为背景的大量简单负样本(p→0),权重趋近 0。这一项把几万个"简单背景"的影响压下去
(1-target)^4 高斯区域内的负样本(target 接近 1)惩罚很小。"在中心旁边预测得高一点"不算大错
除以正样本数 让损失大小不随场景里物体数量变化

5.2 回归:带掩码的 L1

loss_reg = l1_loss(pred * m, gt * m, reduction='sum') / n_pos
loss = loss_hm + 0.25 * loss_reg

乘以 mask 后,非中心位置的预测值和答案都是 0,不贡献损失。除以正样本数得到"每个物体的平均误差"。0.25 的权重用来平衡两项损失的量级,防止回归项压过热力图项。


6. 训练脚本(train_bev.py)

6.1 一个训练 step 的流程

从 DataLoader 取一个 batch
  → 图像、lidar2img 搬到 GPU
  → build_batch_targets:每个样本的 3D 框 → 热力图/回归/掩码
  → autocast(bf16) 下前向 + 计算损失
  → 反向传播 → 梯度裁剪 → 优化器更新
  → 记录到 tqdm 和 TensorBoard

6.2 每个设计的理由

代码 为什么
collate_fn=bev_collate_fn 每个样本的框数量不一样(3 个、17 个……),没法直接 stack 成一个张量,只能以列表的形式传出来,再在 build_batch_targets 里逐个编码
pin_memory=True + non_blocking=True 数据放在锁页内存,CPU→GPU 的拷贝可以和计算同时进行
drop_last=True 丢掉最后不满一个 batch 的数据,保证 BatchNorm 的统计量稳定
autocast(bfloat16) 混合精度:矩阵运算用 16 位,速度快、省显存。bf16 和 fp32 的数值范围一样,不像 fp16 那样容易溢出
.float() 后再算 loss log 和 sigmoid 对精度敏感,损失部分用 32 位计算
骨干学习率 × 0.1 ResNet 已经在 ImageNet 上学得很好,大学习率会把预训练的知识冲掉。新加的模块是从零开始的,需要大学习率
AdamW + weight_decay=0.01 Transformer 类模型的标准选择,权重衰减用来防过拟合
clip_grad_norm_(35) 训练初期热力图损失很大,偶尔会出现一个超大梯度把权重冲坏。35 是 mmdet3d 系列配置里的常用值
scaler.unscale_ 后再裁剪 梯度要先还原到真实数值,裁剪的阈值才有意义
OneCycleLR 学习率先升(预热),再降(退火)。前期稳定,后期精细收敛
保存 last.pth 和 best.pth last 用来断点续训,best 是验证损失最低的那个,用来部署和评估

6.3 启动流程的思路

  1. 先做冒烟测试:用最小配置(BEV 64、1 层、小图)跑 1 个 epoch,2 分钟内看到 loss。目的是用最低成本发现路径错误、形状错误、数据问题,而不是挂 8 小时之后才发现第 1 步就崩了。
  2. 用 tmux 挂后台:SSH 断开后训练不会停。
  3. TensorBoard 看曲线,用 nvidia-smi 看显存。GPU 是共享的,--max-gpu-gb 30 给别人留余量。

显存主要花在哪里:SCA 里 sampled 这个张量有 4×6×16384×4×256 ≈ 4 亿个数,每一层都要存下来用于反向传播。BEV 从 128 改成 200,格子数变成 2.4 倍,显存几乎跟着翻倍。这就是课程配置表里显存从 14GB 涨到 28GB 的原因。

6.4 怎么判断训练是否正常

  • 前 100 步 loss 快速下降:说明模型在学"大部分地方是背景"。
  • 出现 nan:先降学习率,检查数据里有没有异常框。
  • loss 卡在某个值不动:多半是数据问题(框和图像没对齐,或者坐标系不一致),不是模型问题。先回 2.2 节做可视化验证,不要急着调超参。这是课程强调的最重要的调试原则。
  • train loss 下降、val loss 上升:过拟合,需要加数据或加强数据增强。
  • 不要拿 loss 数值和别人比:只看自己的趋势。

7. 课程没讲、但你值得知道的事

我对照代码仔细看了一遍,下面几点会直接影响你的训练结果或理解。

⚠️ 7.1 学习率调度器的位置有 bug(影响很大)

scheduler = OneCycleLR(..., total_steps=args.epochs * len(train_dl), ...)  # 按 batch 数设总步数
...
for epoch in range(args.epochs):
    train_one_epoch(...)
    scheduler.step()      # ← 但每个 epoch 才 step 一次

total_steps 是按 batch 数算的,比如 24 × 1000 = 24000 步,但实际每个 epoch 才走一步,24 个 epoch 一共只走 24 步。OneCycleLR 的初始学习率是 max_lr / 25,所以整个训练过程学习率都停在 2e-4 / 25 = 8e-6 附近,几乎没有涨上去。表现就是 loss 下降得异常缓慢。

修法:把 scheduler.step() 从 epoch 循环里删掉,把 scheduler 传进 train_one_epoch,放在 scaler.step(optimizer) 之后,每个 batch 调用一次:

scaler.step(optimizer)
scaler.update()
scheduler.step()      # 每个 batch 一次

7.2 --amp 关不掉

ap.add_argument('--amp', action='store_true', default=True)

store_true 加上 default=True,不管传不传这个参数都是 True。课程排错表里说"如仍报错关掉 --amp",实际上做不到。可以改成 ap.add_argument('--no-amp', dest='amp', action='store_false')。

另外,用 bf16 时其实不需要 GradScaler。它是为 fp16 下溢问题设计的,在 bf16 下保留它无害,只是多余。

7.3 这个"注意力"里,query 其实没有参与采样(理解上的要点)

看第 5 步就会发现:采样位置是固定的几何投影,平均权重是 0/1 掩码。bev_query 只在最后残差相加时出现,既不决定在哪里采样,也不决定各采样点的权重。所以严格来说,这是"几何投影 + 平均池化",不是真正的注意力。

由此还会引出一个推论:3 层编码器里,每一层的 SCA 用的是同一组参考点、同一份图像特征,所以采样出来的 out 在 3 层里完全一样,区别只在各层的 output_proj 和 FFN。叠更多层带来的主要是更深的特征加工,不会带来新的图像信息。

论文原版里,query 会经过线性层预测出采样偏移量和注意力权重,所以每一层都能根据当前的理解"换个地方看、换个权重看"。这正是课程说的"精度略低"的根本原因,也是你做消融实验的绝佳切入点。比如加一个 nn.Linear(C, N*Z) 从 query 预测各采样点的权重,替代简单平均,然后对比效果。

7.4 深度歧义:为什么只靠几何会"拖影"

一条相机射线上,"近处、低处"的点和"远处、高处"的点会投到同一个像素。比如 (20m, z=0) 和 (40m, z=约 1.6m) 可能落在同一位置,于是这两个 BEV 格子会取到相同的特征。所以 BEV 特征图上,物体容易沿相机射线方向拉出一条"拖影"。

网络只能靠 bev_embedding(位置先验)和检测头里的卷积(看周围的上下文)来区分。论文用可学习的注意力权重和时序融合(不同时刻的射线方向不同,可以相互印证)来缓解这个问题。理解这一点,你就明白为什么"拉"的方法虽然绕开了深度估计,但并没有彻底消灭深度问题。

7.5 坐标有半格的微小偏差

_make_coords 用 linspace(51.2, -51.2, 128),第 0 行的坐标是 x=51.2,正好在边界上。而 encode_targets 里第 0 行代表的区域是 (50.4, 51.2],中心在 50.8。两边相差最多半格(0.4 米),越往边缘偏差越大,中间几乎没有。影响不大,但如果想严格一致,可以把坐标改成格子中心:

v = 2 * self.pc_range / self.bev_h
xs = self.pc_range - (torch.arange(self.bev_h) + 0.5) * v
ys = -self.pc_range + (torch.arange(self.bev_w) + 0.5) * v

7.6 真值编码放在主进程,可能是速度瓶颈

build_batch_targets 在训练循环里用 numpy 逐个样本计算,这时 GPU 在空等。更好的做法是把 encode_targets 移到 Dataset 的 __getitem__ 里,让 DataLoader 的多个 worker 并行算。如果训练特别慢,这是一个值得先试的优化点。


8. 补充:训练完之后怎么把输出还原成 3D 框

课程只到训练和保存 checkpoint,这里补上推理解码,帮你把整个流程闭环:

hm = torch.sigmoid(out['heatmap'])                       # [B,4,128,128] 概率
peak = (hm == F.max_pool2d(hm, 3, 1, 1)) & (hm > 0.3)    # 3×3 局部最大值,相当于免 NMS
# 对每个峰值 (cls, row, col):
dx, dy, z, ll, lw, lh, s, c = reg[:, row, col]
x   = 51.2 - (row + dy) * 0.8        # 编码公式的逆运算
y   = (col + dx) * 0.8 - 51.2
l, w, h = exp(ll), exp(lw), exp(lh)
yaw = atan2(s, c)

每一步都正好是第 4 节编码的反过程。这也说明编码和解码的公式必须严格对应。


9. 总结(对应课程的验收清单)

  1. 为什么不用官方仓库:torch 1.9/1.10 不支持 L20 的 sm_89 架构,而且这是结构性的版本冲突,不是配置问题。
  2. BEVFormer 的核心思想:从 BEV 格子出发"拉"取图像特征,3D→2D 的投影是确定的,因此不需要估计深度。
  3. 空间交叉注意力的 5 步:在柱子上取高度点 → 用 lidar2img 投影 → 用 grid_sample 采样 → 有效性掩码 → 只对有效采样求平均,再加残差。
  4. 热力图头:把检测变成"每个格子判断是不是中心,再回归 8 个量"。监督密集而固定,比 DETR 的匹配好训练。
  5. 回归目标的表示:yaw 用 sin/cos 避免 ±180° 的跳变;尺寸用 log 衡量相对误差;高斯半径随物体大小变化。
  6. Focal Loss:压低几万个简单负样本的权重,解决 1:3000 的样本不平衡。
  7. 调试原则:loss 卡住先查数据(坐标系、对齐),不要急着调超参。
  8. 建议正式训练前先改两处:一是第 7.1 节的 scheduler.step() 位置,改到每个 batch 之后;二是第 7.2 节的 --amp 开关。

如果你想继续深入,下一步最有价值的实验是第 7.3 节说的:让 query 预测采样权重,把"平均"变成真正的"注意力",再和现在的版本做对比。这正好是课程说的"面试能聊出深度"的那种消融实验。


参考文章:
端到端自动驾驶实战 | zhijia.dev

为者常成,行者常至