本文主要是介绍BEV经典之作Lift, Splat, Shoot解析，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
第一篇：LSS算法数据shape流程图 - 知乎
Lift Splat Shoot算法是一种用于自动驾驶感知的算法，它由NVIDIA提出。该算法通过将多视角相机图像转换为3D空间中的特征表示。其主要思想是将每个相机的图像通过"抬升（Lift）"的方式生成3D特征，然后将这些3D特征通过"拍扁（Splat）"的方式投射到光栅化的鸟瞰图网格中。最后，通过将模板运动轨迹"投射（Shoot）"到网络输出的BEV Cost Map中，实现可解释的端到端的运动规划。
对于感知算法而言，Lift Splat Shoot算法的关键在于对BEV（鸟瞰图）的感知范围、BEV单元格大小和深度估计范围的设置。感知范围可以决定x轴和y轴方向的感知距离，BEV单元格大小决定了BEV下的单位大小，深度估计范围则决定了Lift Splat Shoot算法需要估计的离散深度范围。
通过Lift Splat Shoot算法，可以将多个相机的2D信息转换为3D信息，并将多个摄像头的3D信息进行拼接，从而得到对整个场景的统一表示。该算法在目标分割、地图分割等任务上取得了优于基线方法和之前工作的结果。
总体流程
总体流程
获取空间位置
构造frustum
frustum是LiftSplatShoot的一个用nn.Parameter(frustum, requires_grad=False)包裹的成员，是参与梯度与更新的。
frustum是一个4维矩阵，代表了在41×8×22的伪点云中，每个点的x,y,z三个坐标
部分x坐标的实际值
部分y坐标的实际值
z坐标（深度）的实际值
将相机坐标系转换至自车坐标系
geom = self.get_geometry(rots, trans, intrins, post_rots, post_trans)
geom的shape任然为（41,8,22,3），但是转换到了自车坐标系下
获取相机特征（CamEncode）
voxel_pooling
获取BEV特征（BevEncode）
第二篇：BEV经典之作Lift, Splat, Shoot解析 - 知乎
本文的主要内容：
- BEV感知
- LSS贡献
- LSS工作流程
- Lift & Splat 原理以及相关源码解析
BEV感知
自动驾驶汽车为了感知周围的环境，会在车身周围安装多个传感器，每个传感器都有自己的坐标系。为了使得后续处理更加方便，我们通常将不同传感器的感知数据转换到一个统一的坐标系。比如目前最流行的鸟瞰图BEV（"bird's-eye-view"）感知范式，就是从来自不同传感器的数据中提取特征，然后将这些特征转换到统一的BEV坐标系下，再进行后续的感知任务，比如检测、分割等。如下图所示，上方为车上前、后、左、右4个相机拍摄到的画面，下方为转换后的BEV表示。
LSS的贡献
LSS算是BEV感知的开山之作，其主要贡献有以下几点：
- 提出了一种将图像从2d转换到3d的方法（Lift）;
- 提出了一种end-to-end模型，可以将来自多个相机的图像特征转换到统一的BEV空间；
- LSS是纯视觉模型，为后续的纯视觉BEV感知算法研究奠定了基础。
上图左边是不同相机拍摄的图像，右边是将这些不同视角的图像转换到BEV空间后，在BEV空间直接进行语义分割的结果。（左边图像中的着色点，代表将BEV空间中的预测结果反投影到了图像上）
LSS工作流程
LSS的整个工作流如上图，模型的输入是来自不同相机拍摄的 � 张图像，以及每个相机的外参矩阵 �� 和内参矩阵 �� ，其中 �∈[1,2,...,�] ；模型首先对每张图像（实际上是特征图）进行 "Lift" 操作，将图像从2d平面提升到3d空间，生成3d视锥（frustum）点云，并对点云上所有的点预测context特征，生成context特征点云；然后对视锥点云和context特征点云进行 “Splat” 操作，在BEV网格中构建BEV特征，即模型的输出；最后，得到BEV特征后，可通过“Shooting”完成特定的下游任务，比如Motion Planning。
要理清LSS的工作流程，就是要搞明白“Lift”和“Splat”这两个操作，在上图中，我列出了源码中实现"Lift"和“Splat”这两个操作的相关函数，接下来我将结合源码，来重点解析下这两个操作的原理以及它们是如何实现的。
Lift
相机将真实世界投影到图像平面，是一个3d转2d的过程，会丢失深度信息。Lift的目的就是为了恢复图像中每个像素的深度，将图像从2d平面提升到3d空间，该操作具体分为两步：
【Step1】生成3d视锥（frustum）点云：令图像大小为 [H, W] ，为每个像素生成D个离散的深度值，表示这个像素所有可能处于的深度位置，从而生成大小为 [D, H, W] 的视锥点云，然后利用相机的内参和外参，将所有的视锥点云转换到自车坐标系。论文中设置深度方向的范围是 [4m, 45m]，每间隔1m估计1个离散深度，故每个像素会生成41个深度值，即D=41。
实现该步骤的源码为models.py文件中的create_frustum()和get_geometry()这两个函数，源码解析：
def create_frustum(self):"""将图像从2d提升到3d，生成3d视锥(frustum)点云。这里实际上是在下采样后的特征图上生成点云，然后把每个点的坐标映射回原图中。"""ogfH, ogfW = self.data_aug_conf['final_dim'] # 原始图像大小 (128,352)fH, fW = ogfH // self.downsample, ogfW // self.downsample # 经backbone下采样后的特征图大小 (8,22)# 为特征图上的每个点生成一组深度位置，shape变化：(41,) -> (41,1,1) -> (41,8,22)，这里dbound=[4,45,1]ds = torch.arange(*self.grid_conf['dbound'], dtype=torch.float).view(-1, 1, 1).expand(-1, fH, fW)D, _, _ = ds.shape# 将每个点的x坐标映射回原图，shape变化：(22,) -> (1,1,22) -> (41,8,22)xs = torch.linspace(0, ogfW - 1, fW, dtype=torch.float).view(1, 1, fW).expand(D, fH, fW)# 将每个点的y坐标映射回原图，shape变化：(8,) -> (1,8,1) -> (41,8,22)ys = torch.linspace(0, ogfH - 1, fH, dtype=torch.float).view(1, fH, 1).expand(D, fH, fW)# 堆叠生成视锥点云，shape为(41,8,22,3)，3代表每个点的3d坐标(x,y,d)frustum = torch.stack((xs, ys, ds), -1)return nn.Parameter(frustum, requires_grad=False)def get_geometry(self, rots, trans, intrins, post_rots, post_trans):"""将每张图的视锥点云从图像坐标系转换到自车坐标系。rots：由相机坐标系->自车坐标系的旋转矩阵，(B, N, 3, 3)trans：由相机坐标系->自车坐标系的平移矩阵，(B, N, 3)intrins：相机内参，(B, N, 3, 3)post_rots：由图像增强引起的旋转矩阵，(B, N, 3, 3)post_trans：由图像增强引起的平移矩阵，(B, N, 3)"""B, N, _ = trans.shape # 恢复数据增强以及预处理对像素位置的变化points = self.frustum - post_trans.view(B, N, 1, 1, 1, 3)points = torch.inverse(post_rots).view(B, N, 1, 1, 1, 3, 3).matmul(points.unsqueeze(-1))# 图像坐标系 -> 相机归一化坐标系points = torch.cat((points[:, :, :, :, :, :2] * points[:, :, :, :, :, 2:3],points[:, :, :, :, :, 2:3]), 5)combine = rots.matmul(torch.inverse(intrins))# 相机归一化坐标系 -> 相机坐标系 -> 自车坐标系points = combine.view(B, N, 1, 1, 1, 3, 3).matmul(points).squeeze(-1)points += trans.view(B, N, 1, 1, 1, 3)return points # shape (B,N,41,8,22,3)【Step2】生成context特征点云：利用EfficientNet作为backbone提取图像特征，对特征图上的每个点，预测C维的特征向量�∈��以及D个离散深度的概率分布�（C等于64，D等于41），然后将特征向量和深度分布做外积，生成context特征。实际上，每个点的context特征可以看作成一个shape为(64, 41)的2维张量，其中每一列 �� 由该点在深度为d处的深度分布值 �� 乘以特征向量c上得到，即论文中的公式（1）：
��=���
如下图所示，左边为图像上某点在其深度方向上预测的D个深度分布 � ，中间为该点的特征向量c，右边为通过外积得到的context特征，可以看出，由于在第三个深度处的概率值最高，所以在外积结果中 �2� 获得的特征最丰富。
实现该步骤的源码为models.py文件中的get_cam_feats()和==get_depth_feat()这两个函数，源码解析：
def get_depth_feat(self, x):"""为特征图上的每个点生成context特征，构建context特征点云。x: 输入图像，shape为(B*N,3,128,352)，注意这里将batch和每个batch的图像数量N融合成了一个维度"""# get_eff_depth用于提取图像特征，源码中使用efficientNet作为backbone，输出的特征图shape为(B*N,512,8,22)x = self.get_eff_depth(x)# depthnet实际就是一个Conv2d，输出的特征图shape为(B*N,105,8,22)，其中105的前41项为深度值，后面64项为特征x = self.depthnet(x)# 提取前41维的深度图，通过get_depth_dist执行softmax得到概率分布，shape为(B*N,41,8,22)depth = self.get_depth_dist(x[:, :self.D])# 提取后64维的特征图，和深度分布做外积，构建context特征点云，shape为(B*N,64,41,8,22)new_x = depth.unsqueeze(1) * x[:, self.D:(self.D + self.C)].unsqueeze(2)return depth, new_xdef get_cam_feats(self, x):"""构建context特征点云。x: 输入图像，shape为(B,N,3,128,352)"""B, N, C, imH, imW = x.shape # shape(B,N,3,128,352)x = x.view(B*N, C, imH, imW) # 合并维度0和维度1，shape(B*N,3,128,352)x = self.camencode(x) # camencode内部会调用get_depth_feat得到context特征点云，shape(B*N,64,41,8,22)x = x.view(B, N, self.camC, self.D, imH//self.downsample, imW//self.downsample) # shape(B,N,64,41,8,22)x = x.permute(0, 1, 3, 4, 5, 2) # shape(B,N,41,8,22,64)return x Splat
经过Lift操作后，我们得到了两个3d点云：
- 视锥点云：shape为(B, N, 41, 8, 22, 3)，包含了每个点在自车坐标系中的位置
- context特征点云：shape为(B, N, 41, 8, 22, 64)，包含了每个点的context特征
Splat的目的就是将context特征投影到BEV网格中，构建BEV特征。具体为：首先将视锥点云从自车坐标系平移到BEV网格中，并滤除平移后落在BEV网格边界外的点；由于可能存在多个点落到同一个单元格中，所以对每个点赋一个rank值，rank值相同的点表示在同一个batch的同一个单元格里；最后对落在同一个单元格的context特征进行求和池化，得到BEV特征。
BEV网格：在以自动驾驶车辆为中心的俯视图中，沿着x轴和y轴方向划分N个单元格（有的论文中也称为"Pillar"），每个单元格有特定的大小，在车辆感知范围内的所有单元格构成了BEV网格。
论文中设置x轴方向和y轴方向的感知范围都为-50m ~ 50m，z轴方向的感知范围为-10m ~10m，单元格的长宽高为[0.5m, 0.5m, 20m]，故BEV网格大小为200x 200x1。
实现Splat操作的源码为models.py文件中的voxel_pooling()函数，源码解析：
def voxel_pooling(self, geom_feats, x):"""构建BEV特征。geom_feats: 视锥点云，shape为(B,N,41,8,22,3)x: context特征点云，shape为(B,N,41,8,22,64)"""B, N, D, H, W, C = x.shapeNprime = B*N*D*H*W# flatten x = x.reshape(Nprime, C)# 将视锥点云从自车坐标系平移到BEV网格中，BEV网格以左上角为原点geom_feats = ((geom_feats - (self.bx - self.dx / 2.)) / self.dx).long()geom_feats = geom_feats.view(Nprime, 3)# 每个点的batch索引，shape(Nprime,1)batch_ix = torch.cat([torch.full([Nprime//B, 1], ix, device=x.device, dtype=torch.long) for ix in range(B)])# 合并batch索引，shape(Nprime,4)geom_feats = torch.cat((geom_feats, batch_ix), 1)# 过滤掉在落BEV网格边界外的点，网格各维度的边界为[0,200)、[0,200)、[0,1)kept = (geom_feats[:, 0] >= 0) & (geom_feats[:, 0] < self.nx[0])\& (geom_feats[:, 1] >= 0) & (geom_feats[:, 1] < self.nx[1])\& (geom_feats[:, 2] >= 0) & (geom_feats[:, 2] < self.nx[2])x = x[kept]geom_feats = geom_feats[kept]# 给每个点赋予一个rank值，rank相同的点表明落在同一个batch的同一个格子里ranks = geom_feats[:, 0] * (self.nx[1] * self.nx[2] * B)\+ geom_feats[:, 1] * (self.nx[2] * B)\+ geom_feats[:, 2] * B\+ geom_feats[:, 3]# 对ranks排序，将rank值相同的点排在一起，这么做的目的是为了后续的cumsumsorts = ranks.argsort()x, geom_feats, ranks = x[sorts], geom_feats[sorts], ranks[sorts]# 利用cumsum trick对落在同一个格子里的context特征进行求和池化if not self.use_quickcumsum:x, geom_feats = cumsum_trick(x, geom_feats, ranks)else:x, geom_feats = QuickCumsum.apply(x, geom_feats, ranks)# 构建BEV特征图，shape(B,64,1,200,200)final = torch.zeros((B, C, self.nx[2], self.nx[0], self.nx[1]), device=x.device)final[geom_feats[:, 3], :, geom_feats[:, 2], geom_feats[:, 0], geom_feats[:, 1]] = x# 消除第2维，shape(B,64,200,200)final = torch.cat(final.unbind(dim=2), 1)return finaldef cumsum_trick(x, geom_feats, ranks):"""对落在同一个单元格的特征进行求和池化。x: 铺平的context特征，shape为(n,64)geom_feats: 铺平的视锥点，shape为(n,3)ranks：每个点的rank值，shape为(n,)"""# 求所有点的特征执行累加和x = x.cumsum(0)# 获取前后rank值不相等的索引位置kept = torch.ones(x.shape[0], device=x.device, dtype=torch.bool)kept[:-1] = (ranks[1:] != ranks[:-1])# 对于具有相同rank值的点，只保留最后一个x, geom_feats = x[kept], geom_feats[kept]# 由于前面是对所有点执行累加和，这里进行移位相减，得到具有相同rank值的点的实际特征和x = torch.cat((x[:1], x[1:] - x[:-1]))return x, geom_feats下面通过一个例子来理解一下cumsum trick，假设我们有一组包含5个点的context特征，特征维度为2，对其求累加和：
feats = np.array([[1,1], [2,2], [3,3], [4,4], [5,5]])
ft_cumsum = feats.cumsum(0)
>>> ft_cumsum: [[1,1], [3,3], [6,6], [10,10], [15,15]]假设在BEV网格中，第三个点和第四个点落在同一个单元格里，即它们具有相同的rank值：
ranks = np.array([0, 1, 2, 2, 3])
kept = np.ones(feats.shape[0], dtype=bool)
kept[:-1] = (ranks[1:] != ranks[:-1])
>>> kept: [True, True, False, True, True]对于具有相同rank值的点，只会保留最后一个，所以第三个点会被滤掉：
ft_cumsum = ft_cumsum[kept]
>>> ft_cumsum: [[1,1], [3,3], [10,10], [15,15]]移位相减，得到剩余每个点的实际特征和：
ft_cumsum = np.concatenate((ft_cumsum[:1], ft_cumsum[1:] - ft_cumsum[:-1]))
>>> ft_cumsum: [[1,1], [2,2], [7,7], [5,5]]BevEncode
为了执行语义分割任务，最后还接个BevEncode对BEV特征进一步进行编码，BevEncode由一个2d Conv、resnet18的前三层、以及两个上采样层组成，最终输出的特征图shape为(4, 1, 200, 200)。
这篇关于BEV经典之作Lift, Splat, Shoot解析的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
