自动驾驶-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 行。好处是能跑、能随意修改做实验,而且自己写过一遍才能真正理解。代价是有三处简化,要心里有数:
- 固定采样点:论文让网络自己学"往哪里偏一点去采样"(可变形注意力),这里只在固定位置采样。
- 检测头换成 CenterPoint 风格的热力图:论文用 DETR 风格的 query,在小数据上很难收敛。
- 不做时序融合:论文会把上一帧的 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,周围逐渐降到 0。
- 回归量:在中心格子上再预测 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 启动流程的思路
- 先做冒烟测试:用最小配置(BEV 64、1 层、小图)跑 1 个 epoch,2 分钟内看到 loss。目的是用最低成本发现路径错误、形状错误、数据问题,而不是挂 8 小时之后才发现第 1 步就崩了。
- 用 tmux 挂后台:SSH 断开后训练不会停。
- 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. 总结(对应课程的验收清单)
- 为什么不用官方仓库:torch 1.9/1.10 不支持 L20 的 sm_89 架构,而且这是结构性的版本冲突,不是配置问题。
- BEVFormer 的核心思想:从 BEV 格子出发"拉"取图像特征,3D→2D 的投影是确定的,因此不需要估计深度。
- 空间交叉注意力的 5 步:在柱子上取高度点 → 用 lidar2img 投影 → 用 grid_sample 采样 → 有效性掩码 → 只对有效采样求平均,再加残差。
- 热力图头:把检测变成"每个格子判断是不是中心,再回归 8 个量"。监督密集而固定,比 DETR 的匹配好训练。
- 回归目标的表示:yaw 用 sin/cos 避免 ±180° 的跳变;尺寸用 log 衡量相对误差;高斯半径随物体大小变化。
- Focal Loss:压低几万个简单负样本的权重,解决 1:3000 的样本不平衡。
- 调试原则:loss 卡住先查数据(坐标系、对齐),不要急着调超参。
- 建议正式训练前先改两处:一是第 7.1 节的
scheduler.step()位置,改到每个 batch 之后;二是第 7.2 节的--amp开关。
如果你想继续深入,下一步最有价值的实验是第 7.3 节说的:让 query 预测采样权重,把"平均"变成真正的"注意力",再和现在的版本做对比。这正好是课程说的"面试能聊出深度"的那种消融实验。
为者常成,行者常至
自由转载-非商用-非衍生-保持署名(创意共享3.0许可证)