w~视觉~3D~合集4

标签：特征 检测 物体 方法 BEV 视觉 合集 3D

我自己的原文哦~  https://blog.51cto.com/whaosoft/12715678

#3D目标检测~2

Camera or Lidar？

自动驾驶系统依赖于先进的感知、决策和控制技术，通过使用各种传感器（如相机、激光雷达、雷达等）来感知周围环境，并利用算法和模型进行实时分析和决策。这使得车辆能够识别道路标志、检测和跟踪其他车辆、预测行人行为等，从而安全地操作和适应复杂的交通环境.这项技术目前引起了广泛的关注，并认为是未来交通领域的重要发展领域之一。但是，让自动驾驶变得困难的是弄清楚如何让汽车了解周围发生的事情。这需要自动驾驶系统中的三维物体检测算法可以准确地感知和描述周围环境中的物体，包括它们的位置、形状、大小和类别。这种全面的环境意识有助于自动驾驶系统更好地了解驾驶环境，并做出更精确的决策。

我们全面评估了自动驾驶中3D物体检测算法的稳健性。确定了评估检测稳健性的三个关键因素：环境变化性、传感器噪声和误对准。这些因素至关重要，因为它们影响了检测算法在真实世界多变条件下的表现。

1. 环境变化性： 文章强调检测算法需要适应不同的环境条件，如光照、天气和季节的变化。
2. 传感器噪声： 算法必须有效处理传感器的噪声，可能包括摄像机的运动模糊等问题。
3. 误对准： 对于由校准错误或其他因素引起的误对准，算法需要考虑到这些因素，无论是外部的（如不平坦的路面）还是内部的（例如系统时钟误对准）。

还深入探讨了性能评估的三个关键领域：准确性、延迟和稳健性。

• 准确性：尽管研究通常将准确性作为关键性能指标，但在复杂和极端条件下的表现需要更深入的理解，以确保真实世界的可靠性。
• 延迟： 自动驾驶中的实时能力至关重要。检测方法的延迟影响系统及时决策的能力，特别是在紧急情况下。
• 稳健性： 呼吁对系统在不同条件下的稳定性进行更全面的评估，因为许多当前的评估可能没有完全考虑到真实世界场景的多样性。

在分析中，论文指出了多模态3D检测方法在安全感知方面的显著优势。这些方法结合了来自不同传感器的数据，为自动驾驶系统提供了更丰富、更多样化的感知能力。

1. 数据集

上述概述了自动驾驶系统中用于3D物体检测的数据集，重点在于评估不同传感器模式下的优势和局限性，以及公共数据集的特点。

首先，表格展示了camera、点云和多模态（相机和激光雷达）三种类型的传感器。对于每种类型，列出了硬件成本、优点和局限性。例如，相机数据的优点在于提供丰富的颜色和纹理信息，但局限于缺乏深度信息且易受光线和天气影响。而激光雷达则提供准确的深度信息，但成本高且没有颜色信息。

接下来，另一个表格详细列出了用于自动驾驶中3D物体检测的多个公共数据集，如KITTI、nuScenes和Waymo等。这些数据集涵盖了不同年份发布的数据，使用的传感器类型，数据规模（包括帧数和注释数量），场景的多样性（包括场景数量和类别），以及场景类型（如白天、晴天、夜晚、雨天等）。

此外，还提到了关于“干净”自动驾驶数据集的研究，并强调了在噪声场景下评估模型稳健性的重要性。一些研究关注在恶劣条件下的相机单模态方法，而其他的多模态数据集则专注于噪声问题。例如，GROUNDED数据集关注在不同天气条件下地面穿透雷达的定位，而ApolloScape开放数据集包括了激光雷达、相机和GPS数据，涵盖了多种天气和光照条件。

由于在真实世界中收集大规模噪声数据的成本过高，许多研究转向使用合成数据集。例如，ImageNet-C是在图像分类模型中对抗常见腐败和扰动的基准研究。这一研究方向随后扩展到为自动驾驶中的3D物体检测量身定制的稳健性数据集。

最后，介绍了用于评估3D物体检测的稳健性的基准工具包，如BR3D、RoboTrans和RoboBEV等。这些工具包通过在公共数据集上模拟各种场景，评估模型在不同腐败类型和严重程度下的表现。例如，Dong等人设计了27种常见腐败来评估现有检测器的腐败稳健性，并建立了KITTI-C、nuScenes-C和Waymo-C等腐败稳健基准。此外，还介绍了用于评估单模态环境中稳健性的研究，如使用物理感知仿真方法模拟在各种实际常见下退化的点云数据。

2. 基于视觉的3D目标检测

2.1 Monocular 3D object detection

在这部分内容中，讨论了单目3D物体检测的概念以及三种主要的方法：基于先验的单目3D物体检测、仅相机的单目3D物体检测和深度辅助的单目3D物体检测。

Prior-guided monocular 3D object detection

这种方法利用隐藏在图像中的物体形状和场景几何学的先验知识来解决单目3D物体检测的挑战。通过引入预训练的子网络或辅助任务，先验知识可以提供额外信息或约束来帮助精确定位3D物体，增强检测的精度和稳健性。常见的先验知识包括物体形状、几何一致性、时间约束和分割信息。例如，Mono3D算法首先假设3D物体位于固定的地面平面上，然后使用物体的先验3D形状来在3D空间中重建边界框。

Camera-only monocular 3D object detection

这种方法仅使用单个相机捕获的图像来检测和定位3D物体。它采用卷积神经网络（CNN）直接从图像中回归3D边界框参数，从而估计物体在三维空间中的尺寸和姿态。这种直接回归方法可以以端到端的方式进行训练，促进了3D物体的整体学习和推断。例如，Smoke算法摒弃了2D边界框的回归，通过结合单个关键点的估计和3D变量的回归来预测每个检测目标的3D框。

Depth-assisted monocular 3D object detection

深度估计在深度辅助的单目3D物体检测中扮演着关键角色。为了实现更准确的单目检测结果，许多研究利用预训练的辅助深度估计网络。这个过程首先通过使用预训练的深度估计器（如MonoDepth）将单目图像转换为深度图像。然后，采用两种主要方法来处理深度图像和单目图像。例如，Pseudo-LiDAR检测器使用预训练的深度估计网络生成Pseudo-LiDAR表示，但由于图像到LiDAR生成的错误，Pseudo-LiDAR与基于LiDAR的检测器之间存在巨大的性能差距。

通过这些方法的探索和应用，单目3D物体检测在计算机视觉和智能系统领域取得了显著进展，为这些领域带来了突破和机遇。

2.2 Stereo-based 3D object detection

在这部分内容中，讨论了基于立体视觉的3D物体检测技术。立体视觉3D物体检测利用一对立体图像来识别和定位3D物体。通过利用立体摄像机捕获的双重视角，这些方法在通过立体匹配和校准获取高精度深度信息方面表现出色，这是它们与单目摄像机设置不同的特点。尽管存在这些优势，与基于激光雷达的方法相比，立体视觉方法仍存在相当大的性能差距。此外，从立体图像中进行3D物体检测的领域相对较少被探索，仅有限的研究工作致力于这一领域。

1. 2D-detection based methods：传统的2D物体检测框架可以修改以解决立体检测问题。例如，Stereo R-CNN使用基于图像的2D检测器来预测2D提议，为相应的左右图像生成左右感兴趣区域（RoIs）。随后，在第二阶段，它直接估计基于之前生成的RoIs的3D物体参数。这种范式被后续的工作广泛采用。
2. Pseudo-LiDAR based methods：从立体图像预测的视差图可以转换为深度图，进一步转换为伪激光雷达点。因此，类似于单目检测方法，伪激光雷达表示也可以用于基于立体视觉的3D物体检测方法。这些方法旨在增强立体匹配中的视差估计，以实现更准确的深度预测。例如，Wang等人是引入伪激光雷达表示的先驱。这种表示是由具有深度图的图像生成的，要求模型执行深度估计任务以协助检测。随后的工作遵循了这一范式，并通过引入额外的颜色信息来增强伪点云、辅助任务（如实例分割、前景和背景分割、领域适应）和坐标变换方案进行了优化。值得注意的是，Ma等人提出的PatchNet挑战了利用伪激光雷达表示进行单目3D物体检测的传统观念。通过为每个像素编码3D坐标，PatchNet可以在没有伪激光雷达表示的情况下获得可比较的单目检测结果。这一观察表明，伪激光雷达表示的力量来源于坐标变换，而不是点云表示本身。

2.3 Multi-view 3D object detection

最近，多视图3D物体检测在精度和稳健性方面相较于前述的单目和立体视觉3D物体检测方法表现出了优越性。与基于激光雷达的3D物体检测不同，最新的全景鸟瞰视图（BEV）方法消除了对高精度地图的需求，将检测从2D提升到3D。这一进展带来了多视角3D物体检测的重大发展。在多摄像头3D物体检测中，关键挑战在于识别不同图像中的同一物体并从多视角输入中聚合物体特征。目前的方法涉及将多视角统一映射到鸟瞰视图（BEV）空间，这是一种常见的做法。

Depth-based Multi-view methods:

从2D到BEV空间的直接转换构成了一个重大挑战。LSS是首个提出基于深度的方法的，它利用3D空间作为中介。这种方法首先预测2D特征的网格深度分布，然后将这些特征提升到体素空间。这种方法为更有效地实现从2D到BEV空间的转换提供了希望。继LSS之后，CaDDN采用了类似的深度表示方法。通过将体素空间特征压缩到BEV空间，它执行最终的3D检测。值得注意的是，CaDDN并不是多视角3D物体检测的一部分，而是单视角3D物体检测，它对随后的深度研究产生了影响。LSS和CaDDN的主要区别在于CaDDN使用实际的地面真实深度值来监督其分类深度分布的预测，从而创建了一个能够更准确地从2D空间提取3D信息的出色深度网络。

Query-based Multi-view methods

在Transformer技术的影响下，基于query的多视角方法从3D空间检索2D空间特征。DETR3D引入了3D物体query来解决多视角特征的聚合问题。它通过从不同视角剪辑图像特征，并使用学习到的3D参考点将它们投影到2D空间，从而在鸟瞰视图（BEV）空间获得图像特征。与基于深度的多视角方法不同，基于query的多视角方法通过使用反向query技术获得稀疏BEV特征，从根本上影响了后续基于query的发展。然而，由于与显式3D参考点相关的潜在不准确性，PETR采用了隐式位置编码方法来构建BEV空间，影响了后续的工作。

2.4 Analysis: Accuracy, Latency, Robustness

当前，基于鸟瞰视图（BEV）感知的3D物体检测解决方案正在迅速发展。尽管存在许多综述文章，但对这一领域的全面回顾仍然不足。上海AI实验室和商汤研究院提供了对BEV解决方案技术路线图的深入回顾。然而，与现有的综述不同，我们考虑了自动驾驶安全感知等关键方面。在分析了基于相机解决方案的技术路线图和当前发展状态之后，我们打算基于`准确性、延迟、稳健性'的基本原则进行讨论。我们将整合安全感知的视角，以指导自动驾驶中安全感知的实际实施。

1. 准确度：大多数研究文章和综述中都非常关注准确性，这确实非常重要。虽然准确性可以通过AP（平均精度）来反映，但仅考虑AP可能无法提供全面的视角，因为不同的方法由于不同的范式可能表现出显著的差异。如图所示，我们选择了10种代表性方法进行比较，结果表明单目3D物体检测与立体视觉3D物体检测之间存在显著的度量差异。目前的情况表明，单目3D物体检测的准确性远低于立体视觉3D物体检测。立体视觉3D物体检测利用从同一场景的两个不同视角捕获的图像来获取深度信息。相机之间的基线越大，捕获的深度信息范围越广。随着时间的推移，多视角（鸟瞰视图感知）3D物体检测逐渐取代了单目方法，显著提高了mAP。传感器数量的增加对mAP产生了重大影响。
2. 延迟：在自动驾驶领域，延迟至关重要。它指的是系统对输入信号做出反应所需的时间，包括从传感器数据采集到系统决策制定和执行动作的整个过程。在自动驾驶中，对延迟的要求非常严格，因为任何形式的延迟都可能导致严重的后果。延迟在自动驾驶中的重要性体现在以下几个方面：实时响应性、安全性、用户体验、互动性和紧急响应。在3D物体检测领域，延迟（每秒帧数，FPS）和准确性是评估算法性能的关键指标。如图所示，单目和立体视觉3D物体检测的图表显示了KITTI数据集中等难度级别的平均精度（AP）与FPS的关系。对于自动驾驶的实现，3D物体检测算法必须在延迟和准确性之间取得平衡。虽然单目检测速度快，但缺乏精确度；相反，立体和多视角方法准确但速度较慢。未来的研究不仅应保持高精度，还应更加重视提高FPS和降低延迟，以满足自动驾驶中实时响应性和安全性的双重要求。
3. 稳健性：稳健性是自动驾驶安全感知的一个关键因素，代表了一个在综合回顾中以前被忽视的重要话题。在当前精心设计的干净数据集和基准测试中，如KITTI、nuScenes和Waymo，这一方面通常没有得到解决。目前，像RoboBEV、Robo3D这样的研究作品在3D物体检测中纳入了稳健性的考虑，例如传感器缺失等因素。它们采用了一种方法论，包括在与3D物体检测相关的数据集中引入干扰，以评估稳健性。这包括引入各种类型的噪声，如天气条件变化、传感器故障、运动干扰和与物体相关的扰动，旨在揭示不同噪声源对模型的不同影响。通常，大多数研究稳健性的论文通过向干净数据集的验证集（如KITTI、nuScenes和Waymo）引入噪声进行评估。另外，我们强调了参考文献中的发现，其中强调了KITTI-C和nuScenes-C作为相机仅3D物体检测方法的例子。表格提供了总体比较，显示总体上，相机仅方法的稳健性低于激光雷达仅和多模型融合方法。它们非常容易受到各种类型的噪声的影响。在KITTI-C中，三个代表性的作品——SMOKE、PGD和ImVoxelNet——显示出一致较低的整体性能和对噪声的减少稳健性。在nuScenes-C中，值得注意的方法如DETR3D和BEVFormer与FCOS3D和PGD相比表现出更大的稳健性，表明随着传感器数量的增加，整体稳健性提高。总之，未来的相机仅方法需要考虑不仅是成本因素和准确性指标（mAP、NDS等），还有与安全感知和稳健性相关的因素。我们的分析旨在为未来自动驾驶系统的安全提供有价值的见解。

3. 基于Lidar的3D目标检测

基于体素的3D物体检测方法提出了将稀疏点云分割并分配到规则体素中，从而形成密集的数据表示，这个过程称为体素化。与基于视图的方法相比，基于体素的方法利用空间卷积有效感知3D空间信息，实现更高的检测精度，这对自动驾驶中的安全感知至关重要。然而，这些方法仍面临以下挑战：

1. 高计算复杂性：与基于相机的方法相比，基于体素的方法需要大量的内存和计算资源，因为用于表示3D空间的体素数量巨大。
2. 空间信息丢失：由于体素的离散化特性，在体素化过程中细节和形状信息可能丢失或模糊，同时体素有限的分辨率使得难以准确检测小物体。
3. 尺度和密度不一致性：基于体素的方法通常需要在不同尺度和密度的体素网格上进行检测，但由于不同场景中目标的尺度和密度变化很大，选择合适的尺度和密度来适应不同目标成为挑战。

为了克服这些挑战，需要解决数据表示的局限性、提高网络特征能力和目标定位精度，并加强算法对复杂场景的理解。尽管优化策略各不相同，但通常都旨在从数据表示和模型结构方面进行优化。

3.1 Voxel-based 3D object detection

得益于PC在深度学习中的繁荣，基于点的三维对象检测继承了其许多框架，并提出在不进行预处理的情况下直接从原始点检测三维对象。与voxel-based方法相比，原始点云保留了最大量的原始信息，这有利于细粒度的特征获取，result high accuracy。同时，PointNet的一系列工作自然为基于点的方法提供了强大的基础。基于点的3D对象检测器有两个基本组成部分:点云采样和特征学习 %截至目前，Point-based方法的性能仍被两个因素所影响:上下文点的数量和特征学习中采用的上下文半径。e.g.增加上下文点的数量可以获得更细致的3D信息，但会显著增加模型的推理时间。类似地，缩小上下文半径可以获得同样地效果。因此，为这两个因素选择合适的值，可以使模型在精度和速度之间达到一个平衡。此外，由于需要对点云中每一个点进行计算，点云采样过程是限制point-based方法实时运行的主要因素。具体来说，为解决以上问题，现有的方法大多围绕基于点的3D对象检测器的两个基本组成部分进行优化：1) Point Sampling 2) feature learning

3.2 Point-based 3D object detection

基于点的3D物体检测方法继承了许多深度学习框架，并提出直接从原始点云中检测3D物体，而不进行预处理。与基于体素的方法相比，原始点云最大限度地保留了原始信息，有利于细粒度特征的获取，从而实现高精度。同时，PointNet系列工作为基于点的方法提供了强大的基础。然而，到目前为止，基于点的方法的性能仍受两个因素的影响：上下文点的数量和特征学习中使用的上下文半径。例如，增加上下文点的数量可以获得更细致的3D信息，但会显著增加模型的推理时间。类似地，缩小上下文半径可以达到同样的效果。因此，为这两个因素选择适当的值可以使模型在精度和速度之间实现平衡。此外，由于需要对点云中的每个点进行计算，点云采样过程是限制基于点方法实时运行的主要因素。为解决这些问题，现有方法主要围绕基于点的3D物体检测器的两个基本组成部分进行优化：1) 点云采样；2) 特征学习。

最远点采样（FPS）源自PointNet++，是一种在基于点的方法中广泛使用的点云采样方法。它的目标是从原始点云中选择一组具有代表性的点，使它们之间的距离最大化，以最好地覆盖整个点云的空间分布。PointRCNN是基于点的方法中的开创性的两阶段检测器，使用PointNet++作为骨干网络。在第一阶段，它以自下而上的方式从点云中生成3D提议。在第二阶段，通过结合语义特征和局部空间特征来对提议进行精炼。然而，现有基于FPS的方法仍面临一些问题：1) 与检测无关的点同样参与采样过程，带来额外的计算负担；2) 点在物体的不同部分分布不均匀，导致次优的采样策略。为了解决这些问题，后续工作采用了类似FPS的设计范式，并进行了改进，例如，通过分割引导的背景点过滤、随机采样、特征空间采样、基于体素的采样和基于光线分组的采样。

基于点的3D物体检测方法的特征学习阶段旨在从稀疏点云数据中提取具有判别性的特征表示。在特征学习阶段使用的神经网络应具备以下特性：1) 不变性，点云骨干网络应对输入点云的排列顺序不敏感；2) 具有局部感知能力，能够对局部区域进行感知和建模，提取局部特征；3) 具有整合上下文信息的能力，能够从全局和局部的上下文信息中提取特征。基于上述特性，大量的检测器被设计用于处理原始点云。大多数方法可以根据所使用的核心算子分为：1) 基于PointNet的方法；2) 基于图神经网络的方法；3) 基于Transformer的方法。

基于PointNet的方法

基于PointNet的方法主要依赖集合抽象来对原始点进行降采样，聚合局部信息，并整合上下文信息，同时保持原始点的对称不变性。Point-RCNN是基于点的方法中的第一个两阶段工作，取得了出色的性能，但仍面临高计算成本的问题。后续工作通过在检测过程中引入额外的语义分割任务来过滤掉对检测贡献最小的背景点，解决了这个问题。

基于图神经网络的方法

图神经网络（GNN）具有自适应结构、动态邻域、构建局部和全局上下文关系的能力以及对不规则采样的鲁棒性。Point-GNN是一项开创性的工作，设计了一个单阶段图神经网络，通过自动注册机制、合并和评分操作来预测对象的类别和形状，展示了使用图神经网络作为3D物体检测新方法的潜力。

基于Transformer的方法

近年来，Transformer（Transformer）在点云分析中得到了探索，并在许多任务上表现出色。例如，Pointformer引入了局部和全局注意模块来处理3D点云，局部Transformer模块用于对局部区域中的点之间的交互进行建模，而全局Transformer旨在学习场景级别的上下文感知表示。Group-free直接利用点云中的所有点来计算每个对象候选的特征，其中每个点的贡献由自动学习的注意模块决定。这些方法展示了基于Transformer的方法在处理非结构化和无序的原始点云方面的潜力。

3.3  Point-Voxel based 3D object detection

点云基础的3D物体检测方法提供高分辨率并保留了原始数据的空间结构，但它们在处理稀疏数据时面临高计算复杂性和低效率。相比之下，基于体素的方法提供了结构化的数据表示，提高了计算效率，并促进了传统卷积神经网络技术的应用。然而，由于离散化过程，它们通常会丢失细微的空间细节。为了解决这些问题，开发了点-体素（PV）基础的方法。点-体素方法旨在利用基于点的方法的细粒度信息捕获能力和基于体素的方法的计算效率。通过整合这些方法，点-体素基础的方法能够更详细地处理点云数据，捕获全局结构和微观几何细节。这对于自动驾驶中的安全感知至关重要，因为自动驾驶系统的决策精度取决于高精度的检测结果。

点-体素方法的关键目标是通过点到体素或体素到点的转换，实现体素和点之间的特征互动。许多工作已经探索了在骨干网络中利用点-体素特征融合的思想。这些方法可分为两类：1) 早期融合；2) 后期融合。

a) 早期融合：一些方法已经探索了使用新的卷积运算符来融合体素和点特征，PVCNN可能是这方向的首个工作。在这种方法中，基于体素的分支首先将点转换为低分辨率的体素网格，并通过卷积聚合邻近体素特征。然后，通过称为去体素化的过程，将体素级特征转换回点级特征，并与基于点的分支获得的特征融合。基于点的分支为每个单独的点提取特征。由于它不聚合邻近信息，该方法可以以更高的速度运行。接着，SPVCNN在PVCNN的基础上扩展到物体检测领域。其他方法试图从不同的角度进行改进，如辅助任务或多尺度特征融合。

b) 后期融合：这一系列方法主要采用两阶段检测框架。首先，使用基于体素的方法生成初步的物体提议。接着，利用点级特征对检测框进行精确划分。Shi等人提出的PV-RCNN是点-体素基础方法中的一个里程碑。它使用SECOND作为第一阶段检测器，并提出了带有RoI网格池的第二阶段精炼阶段，用于关键点特征的融合。后续工作主要遵循上述范式，专注于第二阶段检测的进展。值得注意的发展包括注意力机制、尺度感知池化和点密度感知精炼模块。

点-体素基础的方法同时具有基于体素方法的计算效率和基于点方法捕获细粒度信息的能力。然而，构建点到体素或体素到点的关系，以及体素和点的特征融合，会带来额外的计算开销。因此，与基于体素的方法相比，点-体素基础

的方法可以实现更好的检测精度，但代价是增加了推理时间。

4.多模态3D目标检测

4.1 Projection-based 3D object detection

基于投影的3D物体检测方法在特征融合阶段使用投影矩阵来实现点云和图像特征的整合。这里的关键是关注在特征融合期间的投影，而不是融合阶段的其他投影过程，如数据增强等。根据融合阶段使用的不同类型的投影，可以将投影基础的3D物体检测方法进一步细分为以下几类：

1. 基于点投影的3D物体检测：这类方法通过将图像特征投影到原始点云上来增强原始点云数据的表示能力。这些方法的第一步是使用校准矩阵建立激光雷达点和图像像素之间的强相关性。接下来，通过添加额外数据来增强点云特征。这种增强有两种形式：一种是通过合并分割分数（如PointPainting），另一种是使用来自相关像素的CNN特征（如MVP）。PointPainting通过追加分割分数来增强激光雷达点，但在有效捕获图像中的颜色和纹理细节方面存在局限性。为解决这些问题，开发了更复杂的方法，如FusionPainting。
2. 基于特征投影的3D物体检测：与基于点投影的方法不同，这类方法主要关注在点云特征提取阶段将点云特征与图像特征融合。在这个过程中，通过应用校准矩阵将体素的三维坐标系统转换为图像的像素坐标系统，从而有效地融合点云和图像模态。例如，ContFuse通过连续卷积融合多尺度卷积特征图。
3. 自动投影基础的3D物体检测：许多研究通过直接投影进行融合，但没有解决投影误差问题。一些工作（如AutoAlignV2）通过学习偏移量和邻域投影等方法来减轻这些误差。例如，HMFI、GraphAlign和GraphAlign++利用投影校准矩阵的先验知识进行图像投影，并进行局部图建模。
4. 基于决策投影的3D物体检测：这类方法使用投影矩阵来对齐感兴趣区域（RoI）或特定结果中的特征。例如，Graph-RCNN将图节点投影到摄像机图像中的位置，并通过双线性插值收集摄像机图像中该像素的特征向量。F-PointNet通过2D图像检测来确定物体的类别和定位，并通过校准的传感器参数和3D空间的转换矩阵获得相应3D空间中的点云。

这些方法展示了如何在多模态3D物体检测中使用投影技术来实现特征融合，但它们在处理不同模态间的交互和准确性方面仍存在一定的局限性。

4.2 Non-Projection-based 3D object detection

非投影式三维物体检测方法通过不依赖特征对齐来实现融合，从而产生稳健的特征表示。它们规避了相机到激光雷达投影的局限性，这种投影通常会降低相机特征的语义密度，并影响如Focals Conv和PointPainting等技术的有效性。非投影式方法通常采用交叉注意力机制或构建统一空间来解决直接特征投影中的固有不对齐问题。这些方法主要分为两类：（1）基于query学习的方法和（2）基于统一特征的方法。基于query学习的方法完全避免了融合过程中的对齐需求。相反，基于统一特征的方法虽然构建了统一的特征空间，但并没有完全避免投影；它通常发生在单一模态背景下。例如，BEVFusion利用LSS进行相机到BEV的投影。这个过程发生在融合之前，在特征不对齐的场景中显示出相当的鲁棒性。

1. 基于query学习的三维物体检测：基于query学习的三维物体检测方法，如Transfusion、DeepFusion、DeepInteraction、autoalign、CAT-Det、MixedFusion等，避免了特征融合过程中的投影需求。相反，它们通过交叉注意力机制在进行特征融合之前实现特征对齐。点云特征通常作为query，而图像特征作为键和值，通过全局特征query获得高度鲁棒的多模态特征。此外，DeepInteraction引入了多模态交互，其中点云和图像特征作为不同的query来实现更进一步的特征交互。与仅使用点云特征作为query相比，全面整合图像特征导致了更强韧的多模态特征的获得。总的来说，基于query学习的三维物体检测方法采用基于Transformer的结构进行特征query以实现特征对齐。最终，多模态特征被整合进激光雷达基础的流程中，如CenterPoint。
2. 基于统一特征的三维物体检测：基于统一特征的三维物体检测方法，如EA-BEV、BEVFusion、cai2023bevfusion4d、FocalFormer3D、FUTR3D、UniTR、Uni3D、virconv、MSMDFusion、sfd、cmt、UVTR、sparsefusion等，通常在特征融合前通过投影实现异构模态的预融合统一。在BEV融合系列中，使用LSS进行深度估计，前视特征被转换为BEV特征，然后融合BEV图像和BEV点云特征。另一方面，CMT和UniTR使用Transformer进行点云和图像的标记化，通过Transformer编码构建隐式统一空间。CMT在位置编码过程中使用投影，但在特征学习级别完全避免了对投影关系的依赖。FocalFormer3D、FUTR3D和UVTR利用Transformer的query实施类似于DETR3D的方案，通过query构建统一的稀疏BEV特征空间，从而减轻了直接投影带来的不稳定性。 

VirConv、MSMDFusion和SFD通过伪点云构建统一空间，在特征学习之前发生投影。通过后续特征学习解决了直接投影引入的问题。总之，基于统一特征的三维物体检测方法目前代表了高精度和强鲁棒性的解决方案。尽管它们包含投影矩阵，但这种投影不发生在多模态融合之间，因此被视为非投影式三维物体检测方法。与自动投影式三维物体检测方法不同，它们不直接解决投影误差问题，而是选择构建统一空间，考虑多模态三维物体检测的多个维度，从而获得高度鲁棒的多模态特征。

5. 结论

3D物体检测在自动驾驶感知中扮演着至关重要的角色。近年来，这个领域快速发展，产生了大量的研究论文。基于传感器产生的多样化数据形式，这些方法主要分为三种类型：基于图像的、基于点云的和多模态的。这些方法的主要评估指标是高准确性和低延迟。许多综述总结了这些方法，主要关注于`高准确性和低延迟'的核心原则，描述它们的技术轨迹。

然而，在自动驾驶技术从突破转向实际应用的过程中，现有的综述没有将安全感知作为核心关注点，未能涵盖与安全感知相关的当前技术路径。例如，最近的多模态融合方法在实验阶段通常会进行鲁棒性测试，这一方面在当前的综述中并未得到充分考虑。

因此，重新审视3D物体检测算法，以`准确性、延迟和鲁棒性'为关键方面进行重点关注。我们重新分类以前的综述，特别强调从安全感知的角度进行重新划分。希望这项工作能为未来3D物体检测的研究提供新的见解，超越仅仅探索高准确性的局限。

#Mono3DVG

Mono3DVG: 3D Visual Grounding in Monocular Images  , 首个基于单目RGB图像实现3D Visual Grounding的方法

• 单位：西北工业大学光电与智能研究院iOPEN、慕尼黑工业大学
• 论文链接：https://arxiv.org/abs/2312.08022
• 项目链接：https://github.com/ZhanYang-nwpu/Mono3DVG

 图1 ：(b) Visual Grounding在2D场景中已经取得了重大进展，但是这些方法无法捕捉到被指代对象的真实3D范围。(d) 3DVG需要激光雷达或RGB-D传感器，由于昂贵的成本和设备限制，极大地限制了其应用场景。(c) 单目三维目标检测可以获取场景中所有物体的三维坐标，且仅需要RGB图像。该方法成本低、适用性强，但它忽略了对三维空间中对象语义的理解，无法基于语言定位特定的目标。(a) 该工作提出了一种通过带有模糊的几何信息和外观信息的自然语言描述，直接在单个RGB图像中定位被指代对象的真实3D范围，称为Mono3DVG。

动机

对于智能系统和机器人而言，基于自然语言来理解真实3D场景中的物体是人机交互的一项重要能力。然而，现有的2D Visual Grounding无法捕捉指代物体的真实3D范围。3D Visual Grounding又需要激光雷达或RGB-D传感器，由于昂贵的成本和设备限制，极大地限制了其应用场景。单目3D目标检测成本低、适用性强，但无法定位特定目标。本文提出一种新的任务，用具有外观和模糊的几何信息的语言描述在单目RGB图像中实现3D Visual Grounding。

数据集

为解决Mono3DVG任务，本文创建了Mono3DRefer数据集。这是第一个在VG任务中利用ChatGPT生成自然语言描述的数据集。数据收集pipeline如下图：

本文梳理了3DVG领域中相关的数据集信息，整理如下：

方法

为了利用具有外观和几何空间信息的自然语言进行推理，本文提出一种新的基于transformer的端到端方法，即Mono3DVG-TR。具体由多模态特征编码器、双文本引导适配器、Grounding解码器和Grounding头组成。

首先，采用RoBERTa和ResNet-50提取文本和多尺度视觉特征；并利用深度预测器显式地学习几何空间特征。其次，为了细化指代对象的多尺度视觉特征和几何空间特征，本文提出一种双文本引导适配器来；它可以进行基于像素注意力的文本引导特征学习，根据文本特征细化视觉特征和几何空间特征。接下来，可学习的query令牌首先聚合几何空间特征，然后通过文本嵌入增强文本相关的几何空间特征，最后从多尺度视觉特征中收集外观信息。

通过堆叠深度-文本-视觉注意力将对象级的几何线索和视觉外观融合到query令牌中，充分实现文本引导的解码。最终将query令牌输入到多个MLP中预测目标的3D空间坐标。

实验结果

数据集整体的结果如下所示：

为了深入研究该任务的挑战，本文按照目标的距离远近程度和检测困难度划分了“近-中-远”和“易-中-难”两组子集，实验结果如下：

可视化结果如下：

针对Mono3DVG-TR方法中不同模块的可视化结果：

经过研究发现，在带有几何空间信息的Mono3DRefer数据集上训练的模型，可以直接在不带有几何空间信息的传统自然语言描述情况下使用，大大提高了该任务的适用性。详细结果见原文附件。

总结

我们相信Mono3DVG可以广泛应用，因为它不需要严格的设备条件，如RGB-D传感器，激光雷达或工业相机。可部署的应用场景广泛，比如无人机、监控系统、智能汽车、机器人等配备摄像头的设备。

#BEVDet

在算法开发中，激光雷达-相机3D目标检测遇到了过度拟合问题，这是由于违反了一些基本规则。在数据集构建的数据标注方面，本文参考了理论补充，并认为回归任务预测不应涉及来自相机分支的特征。通过采用“检测即标签”的前沿观点，本文提出了一种新的范式，称为DAL。使用最经典的初级算法，通过模仿数据标注过程构建了一个简单的预测流水线。然后，本文以最简单的方式对其进行训练，以最小化其依赖性并增强其可移植性。尽管构造和训练都很简单，但所提出的DAL范式不仅在性能上取得了重大突破，而且在所有现有方法中提供了速度和精度之间的优越权衡。凭借全面的优势，DAL会是未来工作开发和实际部署的理想基准。代码已发布，https://github.com/HuangJunJie2017/BEVDet。

尽管构造和训练简单，但提出的DAL范式不仅极大地推动了性能边界（例如，在nuScenes val集上为74.0 NDS，在nuScenes test集上为74.8 NDS），而且在所有现有方法中提供了速度和精度之间的优越权衡。本文的主要贡献可以概括如下

1. 文章提出了一个前沿的视角，即“检测作为标注”，用于3D物体检测中的LiDAR-相机融合。这是对现有方法的良好补充，也是未来工作应遵循的基本规则。
2. 文章遵循“检测作为标注”的观点，构建了一个名为DAL的鲁棒范例。DAL是第一个具有极其优雅的训练管道的LiDAR-Camera融合范例。此外，它极大地推动了该问题的性能边界，在推理延迟和准确性之间实现了优异的权衡。凭借全面的优势，DAL是未来工作发展和实际使用的理想基线。
3. 文章指出了速度分布不可避免的不平衡问题，并提出了实例级速度增益来缓解这一问题。

算法的网络设计

DAL范式的预测管道。将来自图像和点云的BEV特征融合在一起，生成密集的热图。提取前K个建议及其点云特征，用于回归任务预测。与图像特征、图像BEV特征和点云BEV特征融合的特征用于类别预测。根据每个建议的相应预测中心提取稀疏图像特征。

在稀疏感知阶段，首先根据候选对象在密集热图中的坐标收集每个候选对象的点云特征。然后使用简单的前馈网络（FFN）预测回归目标（例如中心、大小、方向和速度）。在这个过程中不涉及图像特征，以防止过拟合问题。最后，本文将图像特征、图像BEV特征和点云BEV特征融合在一起，生成用于类别预测的融合特征。图像BEV特征的部分是根据候选对象在密集热图中的坐标提取的，而图像特征的部分是根据预测的对象中心提取的。

除了进行一些关键修改外，DAL的预测管道从BEVFusion继承了大部分结构设计。首先，点云BEV特征和图像BEV特征在密集BEV编码器之后进行融合，而BEVFusion在之前进行融合。本文推迟融合，以最大限度地保留LiDAR分支的回归能力。然后，由于发现没有必要，去除了稀疏实例和BEV特征之间的注意力。最后，回归任务仅使用点云特征进行预测，而BEVFusion使用融合特征。

由于本文在构建预测管道时分配了适当的方式，只需要像大多数经典视觉任务一样加载在 ImageNet 上预训练的图像骨干的参数。然后本文以端到端的方式训练 DAL，只有一个阶段。只使用来自目标数据集 nuScenes的数据。通过这种方式，本文以最优雅的方式训练 DAL 模型，这在文献中很少见。

例如，DAL与TransFusion和BEVFusion共享目标和损失的设计。除此之外，本文在图像特征上添加了一个辅助分类头，以加强图像分支在搜索候选对象和区分不同类别方面的能力。这对于DAL来说非常重要，因为3D目标检测头中密集感知阶段和稀疏感知阶段的监督都有缺陷。具体来说，在密集感知阶段，图像特征会根据视图转换中的预测深度得分进行调整。反向传播中的梯度也是如此。预测深度得分有缺陷是不可避免的，监督也是如此。在稀疏感知阶段，损失计算中只涉及预测实例的图像特征，而不是所有注释目标的图像特征。具有所有注释目标监督的辅助分类头可以解决上述问题，并在一定程度上加强图像分支。在实践中，使用注释目标的重心来提取每个注释目标的稀疏特征。然后，使用另一个FFN对稀疏特征进行分类，损失计算与3D目标检测头中的分类任务相同。不进行重新加权，本文直接将辅助损失添加到现有的损失中：

在回归任务预测中弃用图像特征不仅可以防止不可避免的性能退化，而且可以在图像空间中进行更广泛的数据增强。本文以调整大小增强为例进行解释。基于相机的3D物体检测根据其在图像视图中的大小预测目标的大小。当图像随机调整大小时，为了保持图像特征与预测目标之间的一致性，需要对预测目标进行相应的调整。然后是LiDAR-相机融合的3D物体检测中的连锁反应中的点云。因此，现有的方法总是在图像空间中使用小范围的数据增强。结果，它们远离了大多数图像2D任务（例如分类，检测，分割）中图像空间大规模数据增强的好处。

最后，本文观察到训练数据中速度分布极不平衡。如图3所示，nuScenes训练集中汽车类别的多数实例是静态的。为了调整分布，随机选择了一些静态物体，并根据预定义的速度调整其点云，如图4所示。本文仅对静态物体进行速度增强，因为可以从其带注释的边界框中轻松地识别来自多个LiDAR帧的全套点。

相关实验结果

数据集

本文在大规模基准nuScenes上进行全面的实验。NuScenes是验证许多室外任务的最新流行基准，如3D物体检测、占用率预测、BEV语义分割、端到端自动驾驶。它包括1000个场景，其中包含来自6个相机的图像和来自具有32束光束的LiDAR的点云。相机组具有与LiDAR一致的360度视野。这使其成为评估LiDAR-相机融合算法的首选数据集。这些场景被正式分为700/150/150个场景，用于训练/验证/测试。有10个类别的140万个注释的3D边界框：汽车、卡车、公共汽车、拖车、工程车辆、行人、摩托车、自行车、障碍物和交通锥。

评估指标

对于3D对象检测，本文报告了官方预定义的度量标准：平均精确度（mAP）、平均平移误差（ATE）、平均缩放误差（ASE）、平均方向误差（AOE）、平均速度误差（AVE）、平均属性误差（AAE）和NuScenes检测评分（NDS）。mAP类似于2D对象检测中的mAP，用于衡量精度和召回率，但基于地面上2D中心距离的匹配，而不是交集比（IOU）。NDS是其他指标的组合，用于综合判断检测能力。其余指标用于计算相应方面的阳性结果精度（例如，平移、缩放、方向、速度和属性）。

预测管道

如表2所示，本文遵循两种经典的3D对象检测范式BEVDet-R50 和CenterPoint ，分别构建图像分支和LiDAR分支，用于消融研究。此外，本文还提供了一些推荐的配置，在推理延迟和准确性之间实现了出色的权衡。

训练和评估

DAL模型在16个3090 GPU上以64个批处理大小进行训练。如表1所示， 与大多数需要多个预训练阶段和复杂学习率策略的现有方法不同，DAL仅从ImageNet分类任务中加载预训练权重，并使用CBGS对整个流水线进行20个epoch的训练。DAL与CenterPoint共享相同的学习率策略。具体来说，学习率通过遵循循环学习率策略进行调整，初始值为2.0×10-4。在评估过程中，本文报告了单个模型在无测试时间增广情况下的性能。默认情况下，推理速度都在单个3090 GPU上测试。BEVPoolV2 用于加速视图变换算法LSS。 

nuScenes val set的结果。如表4所示和图1所示，提出的DAL范式不仅极大地推动了性能边界，而且还提供了速度和精度之间的更好权衡。配置DAL-Large的分数为71.5 mAP和74.0 NDS，大大超过了现有的最佳记录，分别增加了+1.0 mAP和+0.7 NDS。在如此高的准确度下，DAL-Large仍然以6.10 FPS的推理速度运行。另一个推荐的配置DAL-Base以与最快的方法CMT-R50 类似的推理速度运行。其准确度大大超过了CMT-R50，分别为2.1 mAP和2.6 NDS。与CMT-R50具有相似的准确度，DAL-Tiny的加速率为54%。

nuScenes测试集的结果。本文报告了DAL-Large配置在nuScenes测试集上的性能，没有模型集成和测试时间扩展。DAL在NDS 74.8方面优于所有其他方法。

总结

本文提出了一个前沿的视角“检测作为标注”，用于激光雷达-摄像头融合的3D物体检测。DAL是按照这个视角开发的模板。DAL是一个非常优雅的范例，具有简洁的预测管道和易于训练的过程。尽管在这些方面很简单，但它极大地推动了激光雷达-摄像头融合的3D物体检测的性能边界，并在速度和精度之间实现了最佳的平衡。因此，它对未来的工作和实际应用来说都是一个很好的里程碑。

DAL中没有考虑超出激光雷达范围的对象。本文尝试过通过仅使用点云特征预测密集的热图，并将其与使用融合特征预测的热图进行比较，来区分这种情况。然后，使用另一个FFN在融合特征上预测这些实例的回归目标。然而，这种修改对最终准确性的贡献较小。这是因为 nuScenes 中只注释了具有 1 个以上激光雷达点的目标。此外，在 nuScenes 评估中，范围足够小，确保了足够的激光雷达点用于预测回归方面。

此外，nuScenes数据集中的简单分类任务限制了DAL应用SwinTransformer、DCN 和EfficientNet等高级图像骨干。开放世界分类任务要复杂得多，因此也更加困难。因此，图像分支在实践中可以利用高级图像骨干。

虽然DAL有一个无注意力的预测管道，但它只是一个揭示“检测作为标记”价值的模板。因此，本文使用最经典的算法，而不应用注意力。然而，本文并没有有意将其排除在DAL之外。相反，本文认为注意力是一种吸引人的机制，可以在许多方面进一步发展DAL。例如，本文可以应用像UniTR 这样的高级DSVT主干，应用基于注意力的LiDAR-相机融合，如CMT，以及应用基于注意力的稀疏检测范式，如DETR。

#Flash-Occ

相较于目前的基于BEV空间的3D感知算法，Occupancy Network算法可以更好的克服感知任务中存在的长尾问题以及更加准确表达物体的几何形状信息而受到来自工业界和学术界越来越广泛的关注。

Occupancy Network算法本质上是一个3D分割任务，通过将想要感知的3D空间划分成固定大小的体素网格，并让算法去预测每个体素网格被占用的概率以及可能包含的目标类别从而实现对全场景的感知。因其是对空间中的所有体素进行分类，所以对于数据集中未被标注的物体（比如土堆、石块等目标也可以预测为General Objects，从而实现开放集的目标检测，即更好的克服检测中的长尾问题）；同时与直接输出一个物体粗糙3D框的算法相比，由于是直接对空间中的每个体素进行预测，所以对于不规则形状的目标，Occupancy Network算法可以给出更加细粒度的形状表示，从而得到每个物体更加丰富的细节结构信息。

尽管目前Occupancy Network相比于之前的基于BEV的3D感知算法有更好的感知优势，但因其将所要感知的环境空间利用3D体素特征进行中间表示，避免不了的会引入3D卷积等算子进行特征提取，无疑会大大增加模型的运算量和内存开销，从而为模型的上车部署造成不小的困难，严重影响了Occupancy Network算法的落地。

所以，本篇将要介绍的Flash-Occ算法（算法流程图见图一）则抛弃了长耗时、难部署的3D卷积模块，继续使用2D卷积模块来完成特征的提取任务。同时，为了减少模型的计算量，Flash-Occ不再使用Voxel体素特征，而是继续使用BEV特征来建模需要感知的3D空间。但为了完成Occupancy Network在3D空间的预测，Flash-Occ算法设计了一个通道-高度转换模块实现将BEV空间的输出结果提升到3D体素空间，完成最终的结果预测。

图一：Flash-Occ算法整体

Flash-Occ算法的论文链接如下：

​​https://arxiv.org/abs/2311.12058​​ arxiv.org/abs/2311.12058

算法流程详解

Flash-Occ算法是在BEVDet-Occupancy的codebase上进行改进的，下面是Flash-Occ算法的开源仓库链接

​​https://github.com/Yzichen/FlashOCC​​ github.com/Yzichen/FlashOCC

由于Flash-Occ的开源代码当中有很多的配置文件，为了方便大家的理解，本文是基于flashocc-r50-4d-stereo.py配置文件来进行梳理的，我们先看一下Flash-Occ算法的整体流程图，然后再根据源码部分进行细致的讲解～

 图二：Flash-Occ算法详细流程图

整体来看，Flash-Occ的网络结构包括2D主干网络、Neck网络、深度估计模块、视角转换模块、2D BEV Encoder、Occupancy Head模块、通道高度转换模块、训练过程的Loss计算等部分组成。

在介绍各个网络模块具体实现细节之前，先定义一下输入到网络中的环视图像的张量大小Tensor([bs, frame, num_cam, 3, H, W])。其中，bs代表batch size大小，frame代表输入到模型中的帧数（该算法模型的输入还包括历史帧的数据），num_cam代表环视图像中相机的个数，H、W分别代表输入图像的高和宽。

2D主干网络

2D主干网络的作用就是对输入的环视图像进行多尺度的特征提取，针对上述提到的配置文件，2D主干网络采用的是ResNet-50。

需要注意的是，由于当前的config配置是将时序上连续的三帧环视图像一起输入到网络模型当中，所以模型对于不同帧的处理方式是不同的。

• 如果当前时刻标记为t，那么对于t-2时刻的环视图像，2D主干网络只会输出降采样四倍的特征图用于后续进行双目立体的深度估计，代码中定义降采样4倍的特征为Stereo Feature。
• 但是对于t和t-1时刻，2D主干网络在输出降采样4倍Stereo Feature的同时，还会输出降采样16倍和32倍的特征图，用于后续完成多尺度特征的信息融合。

相应的伪代码展示如下，伪代码中的self.extract_stereo_ref_feat()和self.image_encoder()函数均是ResNet-50网络，只是对应的输出特征的降采样步长不同。

# image即当前`t - 2`时刻的环视输入图像
if extra_ref_frame:  # `t - 2`时刻被定义为extra_ref_frame
    stereo_feat = self.extract_stereo_ref_feat(image)  # stereo_feat's downsample ratio = 4.
    return None, None, stereo_feat  # stereo_feat = Tensor([bs * num_cam, 256, H / 4, W / 4])

# 针对`t - 1`以及`t`时刻，网络会同时输出降采样16倍和32倍的Feature List，记作`x`；以及降采样4倍的特征stereo_feat
x, stereo_feat = self.image_encoder(image, stereo=True)

# x = [Tensor([bs * num_cam, 1024, H / 16, W / 16]), Tensor([bs * num_cam, 2048, H / 32, W / 32])]

Neck网络

Neck网络的主要作用是对2D主干网络输出的多尺度特征进行融合，从而实现多尺度语义信息的汇聚。需要注意的是，只有对t和t-1时刻处理后的多尺度环视特征送入到Neck网络进行语义特征的汇聚。

Neck部分的处理逻辑可以总结为以下几个部分

• 输入多尺度特征：[​​Tensor([bs * num_cam, 1024, H / 16, W / 16]), Tensor([bs * num_cam, 2048, H / 32, W / 32])​​]
• 第一步：采用Conv1x1卷积降低2D主干网络输出的环视图像多尺度特征的通道数
• 第二步：将32倍降采样的特征图进行双线性差值得到降采样16倍的特征图
• 第三步：将融合后的特征过一遍Conv3x3卷积进一步拟合融合后的特征图
• 输出融合后的特征：​​Tensor([bs * num_cam, 256, H / 16, W / 16])​​

相应的伪代码展示如下

第一步：采用Conv1x1卷积降低通道数
laterals = [
    lateral_conv(inputs[i + self.start_level])
    for i, lateral_conv in enumerate(self.lateral_convs)
]

第二步：将32倍降采样的特征图进行双线性差值得到降采样16倍的特征图
prev_shape = laterals[i - 1].shape[2:]
laterals[i - 1] += F.interpolate(laterals[i], size=prev_shape, **self.upsample_cfg)

第三步：将融合后的特征过一遍Conv3x3卷积进一步拟合融合后的特征图
outs = [self.fpn_convs[i](laterals[i]) for i in self.out_ids]



>>> self.lateral_convs
>>> ModuleList(
  (0): ConvModule(
    (conv): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))
  )
  (1): ConvModule(
    (conv): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))
  )
)

>>> self.fpn_convs
>>> ModuleList(
  (0): ConvModule(
    (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  )
)

深度估计模块

根据配置文件中的Stereo关键词可以看出，该算法模型是借鉴了BEVStereo论文中的思路，采用双目深度估计的思路，利用两个连续的时序帧的特征对深度信息进行估计。生成的深度信息同时考虑了深度特征和语义特征，其具体的生成逻辑可以总结为以下几个部分

• 第一步：为了更好的对深度信息进行估计，代码中将相机的内外参数、bda增强矩阵等参数也喂入到深度估计模块当中，并过了一个BN层，该部分记作mlp_input参数（参考BEVStereo论文中的做法）
• 第二步：将Neck网络输出的特征图过一层3x3的卷积，该卷积层记作reduce_conv层
• 第三步：利用包含两层的MLP网络对mlp_input进行编码，该MLP网络记作context_mlp层
• 第四步：利用通道注意力模块SENet和context_mlp层编码后的mlp_input对reduce_conv层输出的语义特征进行调整得到更加合理的上下文特征context
• 第五步：将第四步得到的context上下文特征过一层Conv1x1卷积调整特征图的通道数
• 第六步：利用包含两层的MLP网络对mlp_input进行编码，该网络与第三步的MLP网络并不共享参数，记作depth_mlp层
• 第七步：利用通道注意力模块SENet和depth_mlp层编码后的mlp_input对第六步输出的深度信息进行调整，得到更加准确的深度信息depth
• 第八步：同时该深度估计模块还利用了两帧之间的双目立体信息来估计Cost Volumn，从而提高网络对于深度信息的估计能力
• 第九步：利用两组级连的步长为2的3x3卷积对Cost Volumn特征图进行下采样运算，最后和第七步得到的depth信息concat到一起
• 第十步：将concat到一起的depth信息利用ASPP模块进行不同感受野分支的特征提取，从而实现多尺度信息的聚合       
• 最终，深度估计模块的输出如下
• 深度特征为Tensor([bs * num_cam , 88, H / 16, W / 16])
• 语义特征为Tensor([bs * num_cam, 80, H / 16, W / 16])

相应的伪代码展示如下

# 第一步：将mlp_input过一遍BN层，其中mlp_input包含相机内外参、bda增强等信息
mlp_input = self.bn(mlp_input.reshape(-1, mlp_input.shape[-1]))

# 第二步：对Neck网络输出的`x`特征过一层Conv3x3卷积
x = self.reduce_conv(x)

# 第三步：利用两层MLP网络对mlp_input进行编码
context_se = self.context_mlp(mlp_input)[..., None, None]

# 第四步：将语义特征`x`和`mlp_input`编码后的特征喂入到SENet通道注意力模块，得到修正后的上下文特征`context`
context = self.context_se(x, context_se)

# 第五步：利用Conv1x1卷积调整`context`特征的通道数
context = self.context_conv(context)

# 第六步：利用两层MLP网络对mlp_input进行编码
depth_se = self.depth_mlp(mlp_input)[..., None, None]

# 第七步：将语义特征`x`和`mlp_input`编码后的特征喂入到SENet通道注意力模块，得到修正后的深度信息`depth`
depth = self.depth_se(x, depth_se)

# 第八步：利用两帧之间的Stereo Feature计算Cost Volumn视差
with torch.no_grad():
    cost_volumn = self.cost_volumn_net(cost_volumn)

# 第九步：利用两组级连的步长为2的3x3卷积对Cost Volumn特征图进行下采样运算
cost_volumn = self.cost_volumn_net(cost_volumn)

# 第十步：将得到的Cost Volumn和depth预测信息Concat到一起喂入到ASPP模块中，得到更加精准的结果
depth = torch.cat([depth, cost_volumn], dim=1)
depth = self.depth_conv(depth)


>>> self.bn
>>> BatchNorm1d(27, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

>>> self.reduce_conv
>>> Sequential(
  (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
  (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): ReLU(inplace=True)
)

>>> self.context_mlp / self.depth_mlp
>>> Mlp(
  (fc1): Linear(in_features=27, out_features=256, bias=True)
  (act): ReLU()
  (drop1): Dropout(p=0.0, inplace=False)
  (fc2): Linear(in_features=256, out_features=256, bias=True)
  (drop2): Dropout(p=0.0, inplace=False)
)

>>> self.context_se / self.depth_se
>>> SELayer(
  (conv_reduce): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))
  (act1): ReLU()
  (conv_expand): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))
  (gate): Sigmoid()
)

>>> self.context_conv
>>> Conv2d(256, 80, kernel_size=(1, 1), stride=(1, 1))

>>> self.cost_volumn_net
>>> Sequential(
  (0): Conv2d(88, 88, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
  (1): BatchNorm2d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): Conv2d(88, 88, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1))
  (3): BatchNorm2d(88, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
)

>>> self.depth_conv <=> 3 * Res blocks + ASPP/DCN + Conv
Sequential(                                                                                                                                                                                                                                             
(0): BasicBlock(                                                                                                                                                                                                                                                    
     (conv1): Conv2d(344, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)                                                                                                                                                                          
     (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)                                                                                                                                                                           
     (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)                                                                                                                                                                          
     (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)                                                                                                                                                                           
     (relu): ReLU(inplace=True)                                                                                                                                                                                                                                        
     (downsample): Conv2d(344, 256, kernel_size=(1, 1), stride=(1, 1))                                                                                                                                                                                                 )                                                                                                                                                                                                                                                                   
(1): BasicBlock(                                                                                                                                                                                                                                                    
     (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)                                                                                                                                                                          
     (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)                                                                                                                                                                           
     (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)                                                                                                                                                                          
     (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)                                                                                                                                                                           
     (relu): ReLU(inplace=True))                                                                                                                                                                                                                                    
(2): BasicBlock(
     (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
     (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
     (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (relu): ReLU(inplace=True))
(3): ASPP(
     (aspp1): _ASPPModule(
     (atrous_conv): Conv2d(256, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
     (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (relu): ReLU())

     (aspp2): _ASPPModule(
     (atrous_conv): Conv2d(256, 96, kernel_size=(3, 3), stride=(1, 1), padding=(6, 6), dilation=(6, 6), bias=False)
     (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (relu): ReLU())

     (aspp3): _ASPPModule(
     (atrous_conv): Conv2d(256, 96, kernel_size=(3, 3), stride=(1, 1), padding=(12, 12), dilation=(12, 12), bias=False)
     (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (relu): ReLU())

     (aspp4): _ASPPModule(
     (atrous_conv): Conv2d(256, 96, kernel_size=(3, 3), stride=(1, 1), padding=(18, 18), dilation=(18, 18), bias=False)
     (bn): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (relu): ReLU())

     (global_avg_pool): Sequential(
     (0): AdaptiveAvgPool2d(output_size=(1, 1))
     (1): Conv2d(256, 96, kernel_size=(1, 1), stride=(1, 1), bias=False)
     (2): BatchNorm2d(96, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (3): ReLU())

     (conv1): Conv2d(480, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
     (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
     (relu): ReLU()
     (dropout): Dropout(p=0.5, inplace=False)

(4): Conv2d(256, 88, kernel_size=(1, 1), stride=(1, 1))
)

视角转换模块

由于深度估计模块已经得到了丰富的语义特征context以及深度信息depth，作者这里是直接利用了原BEVDet生成BEV特征的模块Voxel Pooling v2，从而获得BEV空间特征：Tensor([bs, 80, BEV_H, BEV_W])。

Voxel Pooling v2模块的代码如下

def voxel_pooling_v2(self, coor, depth, feat):
    ranks_bev, ranks_depth, ranks_feat, \
    interval_starts, interval_lengths = \
    self.voxel_pooling_prepare_v2(coor)
    if ranks_feat is None:
        print('warning ---> no points within the predefined '
              'bev receptive field')
        dummy = torch.zeros(size=[
            feat.shape[0], feat.shape[2],
            int(self.grid_size[2]),
            int(self.grid_size[0]),
            int(self.grid_size[1])
        ]).to(feat)
        dummy = torch.cat(dummy.unbind(dim=2), 1)
        return dummy
    feat = feat.permute(0, 1, 3, 4, 2)
    bev_feat_shape = (depth.shape[0], int(self.grid_size[2]),
                      int(self.grid_size[1]), int(self.grid_size[0]),
                      feat.shape[-1])  # (B, Z, Y, X, C)
    bev_feat = bev_pool_v2(depth, feat, ranks_depth, ranks_feat, ranks_bev,
                           bev_feat_shape, interval_starts,
                           interval_lengths)
    # collapse Z
    if self.collapse_z:  # self.collapse_z = True
        bev_feat = torch.cat(bev_feat.unbind(dim=2), 1)
    return bev_feat

再得到BEV特征之后，继续使用2D卷积层进行特征提取，该2D卷积层记作self.pre_process_net()，从而获得某一帧对应的BEV Feature = Tensor([bs, 80, BEV_H, BEV_W])

对应的代码如下

bev_feat = self.pre_process_net(bev_feat)[0]


>>> self.pre_process_net
>>> CustomResNet(
  (layers): Sequential(
    (0): Sequential(
      (0): BasicBlock(
        (conv1): Conv2d(80, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(80, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(80, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Conv2d(80, 80, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      )
    )
  )
)

2D BEV Encoder模块

上文有提到，当前梳理的代码同时用到了历史帧的信息，所以对于2D BEV Encoder模块的输入BEV Feature实际上是一组BEV Feature沿着通道concat的结果，即t时刻和t-1时刻的BEV Feature沿着通道维度concat的结果。

针对2D BEV Encoder模块而言，其包括img_bev_encoder_backbone()和img_bev_encoder_neck()两个子模块，分别完成多尺度的2D特征的提取以及多尺度2D特征的融合。

• img_bev_encoder_backcone

该模块用于实现对视角转换模块输出的BEV特征进行多尺度的特征提取。输入特征Tensor([bs, 160, BEV_H, BEV_W])

对应的伪代码如下

x = self.img_bev_encoder_backbone(x)

# 输出多尺度的BEV特征
- Tensor([bs, 160, BEV_H / 2, BEV_W / 2]) = f0
- Tensor([bs, 320, BEV_H / 4, BEV_W / 4]) = f1
- Tensor([bs, 640, BEV_H / 8, BEV_W / 8]) = f2
img_bev_encoder_neck

该模块用于实现对img_bev_encoder_backbone模块输出的多尺度特征进行融合，首先将降采样8倍的BEV特征f2上采样4倍大小，然后与f1特征图沿着通道concat到一起，利用卷积操作进行通道上的特征融合。最后输出的特征继续上采样2倍差值以及2D卷积层，获得输出特征Tensor([bs, 256, 200, 200])

对应的伪代码如下

f2, f1 = feats[self.input_feature_index[0]], feats[self.input_feature_index[1]]

f2 = self.up(f2)    
f1 = torch.cat([f2, f1], dim=1)     
x = self.conv(f1)  
x = self.up2(x)     

>>> self.up
>>> Upsample(scale_factor=4.0, mode=bilinear)

>>> self.conv
>>>  Sequential(
  (0): Conv2d(800, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (2): ReLU(inplace=True)
  (3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (5): ReLU(inplace=True)
)

>>> self.up2
>>> Sequential(
  (0): Upsample(scale_factor=2.0, mode=bilinear)
  (1): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (3): ReLU(inplace=True)
  (4): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1)))

Occupancy Head模块

对于Occupancy Head，用于去预测空间中的每个体素是否被占据，如果没有被占据就是预测为free类别，如果被占据则预测对应的所属类别。

在进行最终的类别预测之前，首先会将2D BEV Encoder模块的输出过下2D卷积层，然后去联合预测BEV空间每个网格的高度和语义特征，输出Tensor([bs, 200, 200, 288 = num_classes * height])。

对应的伪代码如下

occ_pred = self.final_conv(img_feats).permute(0, 3, 2, 1)        
occ_pred = self.predicter(occ_pred)

>>> self.final_conv
>>> (final_conv): ConvModule(
    (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
    (activate): ReLU(inplace=True))

>>> self.predicter
>>> Sequential(
    (0): Linear(in_features=256, out_features=512, bias=True)
    (1): Softplus(beta=1, threshold=20)
    (2): Linear(in_features=512, out_features=288, bias=True))

通道高度转换模块

通道高度转换模块也是本文所提出的核心插件，可以理解成Occupancy Head的预测头类似YOLO中的思路，将语义特征和高度联合在一起进行预测，最后通过Tensor的view操作实现2D特征转换为3D的体素预测结果。

occ_pred = occ_pred.view(bs, Dx, Dy, Dz, num_classes)
# Tensor([bs, 200, 200, 288]) -> Tensor([bs, 200, 200, 16, 18])

>>> bs = batch size; 
>>> Dx = BEV空间的大小; Dy = BEV空间的大小; Dz = 体素高度; num_classes = 类别数目

Loss的计算

代码当中主要对模型预测的深度depth信息以及最终的3D分割结果进行了监督学习（计算Loss，更新模型的参数）

• 针对depth预测的监督，代码当中只对当前帧预测出来的depth信息计算了损失，对于前几帧估计的depth信息不会进行损失的计算。
• 针对3D体素分割预测的监督，代码对于Occupancy Head输出的结果会利用Cross Entropy计算相应的loss，从而更新模型的参数。

实验部分

下面放一下Flash-Occ的实验效果

不同Occupancy Network算法对比

训练、推理时间，内存占用对比

结论

目前，Occupancy Network由于可以天然的缓解3D感知中的长尾问题，并且还能更加细粒度的描述目标的几何形状信息，所以受到了来自自动驾驶社区非常广泛的关注。但由于对于3D体素的特征表示以及后续的特征提取过程非常占用内存，且3D卷积模块无法部署，严重阻碍了Occupancy Network的上车部署。

本文介绍的Flash-Occ算法提出了一个通道高度转换模块，使得所有操作均和之前的BEV感知操作类似，极大提高了模型的推理速度，降低了模型的运算量，对上车部署更加友好。

#TimePillars

基于LiDAR点云点3D Object Detection一哥是一个很经典的问题，学术界和工业界都提出了各种各样的模型来提高精度、速度和鲁棒性。但因为室外的复杂环境，所以室外点云的Object Detection的性能都还不是太好。而激光雷达点云本质上比较稀疏，如何针对性得解决这一问题呢？论文给出了自己的答案：依照时序信息的聚合来完成信息的提取。

时序递归TimePillars：直接干到200m！

这篇论文主要讨论了自动驾驶中的一个关键挑战：如何准确地创建周围环境的三维表示。这对于自动驾驶汽车的可靠性和安全性至关重要。特别是，自动驾驶车辆需要能够识别其周围的物体，如车辆和行人，并准确确定它们的位置、大小和方向。通常情况下，人们会使用深度神经网络处理激光雷达（LiDAR）数据来执行此任务。

大部分现有文献集中在单帧方法上，即一次使用一个传感器扫描的数据。这种方法在经典基准测试中表现良好，这些测试的物体距离可达75米。然而，激光雷达点云本质上是稀疏的，特别是在远距离范围内。因此，论文声称仅使用单个扫描进行长距离检测（例如，达到200米）是不够的。

为了解决这个问题，一种方法是使用点云聚合，即将一系列激光雷达扫描数据连续起来，从而获得更密集的输入。然而，这种方式在计算上代价高昂，并且无法充分利用在网络内部进行聚合所带来的优势。一个明显的替代方案是使用递归方法，这些方法可以随时间积累信息。

文章还提到，增加检测范围的其他技术包括使用先进的操作，如稀疏卷积、注意力模块和3D卷积。但是，这些方法通常忽略了目标硬件的兼容性问题。部署和训练神经网络所用的硬件往往在支持的操作和延迟方面有显著差异。例如，稀疏卷积或注意力这样的操作通常不被现有的目标硬件支持，比如Nvidia Orin DLA。此外，3D卷积等层由于实时延迟要求往往不可行。这就强调了使用简单操作，如2D卷积的必要性。

论文中提出了一个新型的时序递归模型，TimePillars，该模型尊重常见目标硬件上支持的操作集，依赖于2D卷积，基于点柱（Pillar）输入表示和一个卷积递归单元。通过单个卷积和辅助学习的帮助，对递归单元的隐藏状态应用了自车Motion Compensation。通过消融研究表明，使用辅助任务来确保这种操作的正确性是恰当的。论文还研究了递归模块在管道中的最佳位置，并清楚地表明，将其放置在网络的骨干和检测头之间可以获得最佳性能。在新发布的Zenseact开放数据集（ZOD）上，论文展示了TimePillars方法的有效性。与单帧和多帧点柱基线相比，TimePillars取得了显著的评估性能提升，特别是在重要的自行车手和行人类别中，在远距离（长达200米）的检测上表现尤为突出。最后，TimePillars的延迟显著低于多帧点柱，使其适合实时系统。

这篇论文的主要贡献包括提出了一个新的时序递归模型TimePillars，用于解决3D激光雷达物体检测任务，同时尊重常见目标硬件支持的操作集；展示了TimePillars在长距离检测上相比单帧和多帧点柱基线取得了显著更好的性能；并且首次在新的Zenseact开放数据集上对3D激光雷达物体检测模型进行了基准测试。不过，该论文的限制在于，它仅关注激光雷达数据，没有考虑其他传感器输入，并且其方法基于单一的最新基线。尽管如此，作者认为他们的框架是通用的，即未来对基线的改进将转化为整体性能的提升。

详解TimePillars

Input preprocessing

在这篇论文的“输入预处理”部分，作者采用了“柱化”（Pillarisation）技术来处理输入的点云数据。这种方法不同于常规的体素化，它将点云分割成垂直的柱状结构，仅在水平方向（x和y轴）上分割，而在垂直方向（z轴）上保持固定高度。这样做可以保持网络输入尺寸的一致性，并允许使用2D卷积进行有效处理。

然而，Pillarisation处理的一个问题是产生了许多空的柱子，导致数据非常稀疏。为解决这个问题，论文中提出了使用动态体素化技术。这种技术避免了为每个柱子设置预定义点数的需求，从而不需要对每个柱子进行截断或填充操作。相反，整个点云数据被整体处理，以匹配到所需的总点数，这里设置为20万个点。这种预处理方法的好处是，它最大程度地减少了信息的损失，并且使得生成的数据表示更加稳定和一致。

Model architecture

然后对于Model architecture，作者详细介绍了一个由柱特征编码器（Pillar Feature Encoder）、2D卷积神经网络（CNN）骨干和检测头组成的神经网络架构。

3. Memory Unit：将系统的记忆建模为一个递归神经网络（RNN），具体采用卷积GRU（convGRU），这是Gated Recurrent Unit的卷积版本。卷积GRU的优势在于避免了梯度消失问题，并且在保持空间数据特性的同时提高了效率。与其他选择，如LSTM相比，GRU由于门的数量更少，因此具有更少的可训练参数，可以视为一种记忆正则化技术（降低隐藏状态的复杂性）。通过合并类似性质的操作，减少了所需卷积层的数量，从而使单元更高效。

4. Detection Head：对SSD（Single Shot MultiBox Detector）进行了简单的修改。保留了SSD的核心理念，即单次通过且无需区域提议，但取消了锚盒（anchor boxes）的使用。直接为网格中的每个单元格输出预测，虽然失去了单元格多对象检测能力，但避免了繁琐且常常不精确的锚盒参数调整，并简化了推理过程。线性层处理分类和定位（位置、大小和角度）回归的各自输出。只有大小使用激活函数（ReLU），以防止取负值。此外，不同于相关文献，论文通过独立预测车辆行驶方向的正弦和余弦分量，并从中提取角度，避免了直接角度回归的问题。

Feature Ego-Motion Compensation

在论文这一部分，作者讨论了如何处理由卷积GRU输出的隐藏状态特征，这些特征是以前一帧的坐标系表示的。如果直接存储并用于计算下一个预测，由于自我运动（ego-motion）会发生空间不匹配。

为了进行转换，可以应用不同的技术。理想情况下，已经校正的数据将被输入网络，而不是在网络内部进行转换。然而，这不是论文提出的方法，因为它需要在推理过程中的每一步重置隐藏状态，转换之前的点云，并将它们传播到整个网络。这不仅效率低下，而且违背了使用RNN的目的。因此，在循环上下文中，补偿需要在特征级别进行。这使得假设的解决方案更高效，但也使问题变得更复杂。传统的插值方法可以用来获取变换坐标系中的特征。

与此相反，论文中受到Chen等人工作的启发，提出使用卷积操作和辅助任务来执行变换。考虑到前述工作的细节有限，论文提出了针对该问题的定制解决方案。

论文采取的方法是通过一个额外的卷积层，为网络提供执行特征转换所需的信息。首先计算两个连续帧之间的相对变换矩阵，即成功变换特征所需执行的操作。然后，从中提取2D信息（旋转和平移部分）：

最后，隐藏状态特征被输入到一个2D卷积层中，该层适合变换过程。需要注意的一个关键方面是：卷积的执行并不保证变换的进行。通道串联只是为网络提供了关于如何可能执行变换的额外信息。在这种情况下，使用辅助学习是合适的。在训练过程中，添加了一个额外的学习目标（坐标变换）与主要目标（物体检测）并行。设计一个辅助任务，其目的是在监督下引导网络通过变换过程，以确保补偿的正确性辅助任务仅限于训练过程。一旦网络学会了正确地变换特征，它就失去了适用性。因此，在推理时不考虑该任务。下一节中将进一步实验，对比其影响。

实验

实验结果表明，TimePillars模型在处理Zenseact Open Dataset（ZOD）帧数据集时表现出色，特别是在处理长达120米的范围时。这些结果凸显了TimePillars在不同运动转换方法下的性能差异，并与其他方法进行了比较。

在对比基准模型PointPillars和多帧（MF）PointPillars后，可以看出TimePillars在多个关键性能指标上取得了显著提升。尤其是在NuScenes Detection Score（NDS）上，TimePillars展示了更高的综合评分，反映了其在检测性能和定位精度方面的优势。此外，TimePillars在平均转换误差（mATE）、平均尺度误差（mASE）和平均方向误差（mAOE）上也取得了更低的数值，表明其在定位准确性和方向估计上更为精准。特别值得注意的是，TimePillars在运动转换方面的不同实现方法对性能有显著影响。当采用卷积基的运动转换（Conv-based）时，TimePillars在NDS、mATE、mASE和mAOE上的表现尤为突出，证明了这种方法在Motion Compensation和提高检测精度方面的有效性。相比之下，使用插值方法的TimePillars虽然也优于基准模型，但在某些指标上不如卷积方法。平均精度（mAP）的结果显示，TimePillars在车辆、骑行者和行人类别的检测上均表现良好，特别是在处理骑行者和行人这些更为挑战性的类别时，其性能提升更为显著。从处理频率（f (Hz））的角度来看，TimePillars虽然不如单帧PointPillars那样快，但与多帧PointPillars相比，其处理速度更快，同时保持了较高的检测性能。这表明TimePillars在保持实时处理的同时，能够有效地进行长距离检测和Motion Compensation。也就是说TimePillars模型在长距离检测、Motion Compensation以及处理速度方面展现出显著优势，尤其是在处理多帧数据和采用卷积基运动转换技术时。这些结果强调了TimePillars在自动驾驶车辆的3D激光雷达物体检测领域的应用潜力。

上述实验结果表明，TimePillars模型在不同距离范围内的物体检测性能上表现卓越，尤其是与基准模型PointPillars相比。这些结果分为三个主要的检测范围：0至50米、50至100米和100米以上。

首先，NuScenes Detection Score（NDS）和平均精度（mAP）为整体性能指标。TimePillars在这两项指标上均优于PointPillars，显示出整体上更高的检测能力和定位精度。具体来说，TimePillars的NDS为0.723，远高于PointPillars的0.657；而在mAP方面，TimePillars也以0.570显著超越了PointPillars的0.475。

在不同距离范围内的性能对比中，可以看到TimePillars在各个范围内均有更好的表现。对于车辆类别，TimePillars在0至50米、50至100米和100米以上的范围内的检测精度分别为0.884、0.776和0.591，均高于PointPillars在相同范围内的性能。这表明TimePillars在车辆检测方面，无论是近距离还是远距离，都具有更高的准确性。在处理易受伤害的交通工具（如摩托车、轮椅、电动滑板车等）时，TimePillars同样展现了更好的检测性能。特别是在100米以上的范围内，TimePillars的检测精度为0.178，而PointPillars仅为0.036，显示出在远距离检测方面的显著优势。对于行人检测，TimePillars也呈现出更好的性能，尤其是在50至100米的范围内，其检测精度达到了0.350，而PointPillars仅为0.211。即便在更远的距离（100米以上），TimePillars仍能实现一定程度的检测（0.032的精度），而PointPillars在这一范围内的表现为零。  

这些实验结果强调了TimePillars在处理不同距离范围内的物体检测任务上的优越性能。无论是在近距离还是在更具挑战性的远距离范围内，TimePillars均能提供更准确和可靠的检测结果，这对于自动驾驶车辆的安全和效率至关重要。

讨论

首先，TimePillars模型的主要优点在于其对长距离物体检测的有效性。通过采用动态体素化和卷积GRU结构，模型能够更好地处理稀疏的激光雷达数据，尤其是在远距离物体检测方面。这对于自动驾驶车辆在复杂和变化的道路环境中的安全运行至关重要。此外，模型在处理速度上也显示出了较好的性能，这对于实时应用是必不可少的。另一方面，TimePillars在Motion Compensation方面采用了基于卷积的方法，这是对传统方法的一大改进。这种方法在训练过程中通过辅助任务确保了转换的正确性，提高了模型在处理运动对象时的精确度。

然而，论文的研究也存在一些局限。首先，虽然TimePillars在处理远距离物体检测方面表现出色，但这种性能的提升可能以牺牲一定的处理速度为代价。虽然模型的速度仍适用于实时应用，但与单帧方法相比，仍有所下降。此外，论文主要关注于LiDAR数据，没有考虑其他传感器输入，如相机或雷达，这可能限制了模型在更复杂多传感器环境中的应用。

也就是说TimePillars在自动驾驶车辆的3D激光雷达物体检测方面展现出了显著的优势，特别是在长距离检测和Motion Compensation方面。尽管存在处理速度的轻微折衷和对多传感器数据处理的局限性，TimePillars仍然代表了在这一领域中的一个重要进步。

结论

这项工作表明，考虑过去的传感器数据比仅利用当前的信息更为优越。访问先前的驾驶环境信息，可以应对激光雷达点云的稀疏性质，并导致更准确的预测。我们证明了递归网络作为实现后者的手段是合适的。与通过大量处理创建更密集数据表示的点云聚合方法相比，赋予系统记忆力带来了更加稳健的解决方案。我们提出的方法TimePillars，实现了解决递归问题的一种方式。仅通过在推理过程中增加三个额外的卷积层，我们证明了基本的网络构建模块足以取得显著成果，并保证了现有的效率和硬件集成规范得以满足。据我们所知，这项工作为新引入的Zenseact开放数据集上的3D物体检测任务提供了首个基准结果。我们希望我们的工作能为未来更安全、更可持续的道路做出贡献。

标签：特征,检测,物体,方法,BEV,视觉,合集,3D
From： https://blog.csdn.net/weixin_49587977/article/details/144185191