凡人多烦事01

这个屌丝很懒，什么也没留下！

热门标签

从零实现一个3D目标检测算法（1）：3D目标检测概述_从零实现一个3d目标检测算法(1):3d目标检测概述_bounding box head_自动驾驶小

作者：凡人多烦事01 | 2024-02-18 07:54:01

踩

从零实现一个3d目标检测算法(1):3d目标检测概述_bounding box head_自动驾驶小学

在这里插入图片描述
本文是根据github上的开源项目：https://github.com/open-mmlab/OpenPCDet整理而来，在此表示感谢，强烈推荐大家去关注。使用的预训练模型也为此项目中提供的模型，不过此项目已更新为v0.2版，与本文中代码略有不同。

本文实现的3D目标检测算法是PointPillars，论文地址为：https://arxiv.org/abs/1812.05784，使用的激光雷达点云数据是KITTI数据（http://www.cvlibs.net/datasets/kitti/eval_object.php?obj_benchmark=3d）。

文章目录

1. 3D目标检测

在开始写代码实现PointPillars检测算法之前，我想先介绍一些关于点云3D目标检测的背景知识。大家有时间的话可以看看下面这个报告，是OpenPCDet项目作者此前分享的报告（https://www.bilibili.com/video/av89811975?zw）。

(2021-04-11日补充)：点云3D目标检测算法库OpenPCDet解析与开发实践（Video）

基于点云场景的三维物体检测算法及应用

（2021-1-27日补充）：这是PointNet作者2021年分享的报告《3D物体检测发展与未来》，对3D物体检测感兴趣的朋友可以看看，PointNet作者对PointPillars算法进行了解读。

【PointNet作者亲述】90分钟带你了解3D物体检测算法和未来方向！

1.1 3D目标检测研究现状

毋庸置疑，在自动驾驶或辅助机器人等应用中，3D目标检测现在变得越来越重要。在这当中，激光雷达（LiDAR）是使用最为广泛的3D传感器，LiDAR可以生成稀疏，不规则的点云数据。

关于3D目标检测，根据点云表示方法大致可以分为两类：the grid-based methods 和 the point-based methods。下面简要介绍这两种方法：

3D Object Detection with Grid-based Methods：由于点云是不规则的，之前的学者通常会对点云进行投影或栅格化处理，转换成规则的grid数据格式，然后再使用2D或3DCNN处理。

MV3D（https://arxiv.org/abs/1611.07759）将点云投影到鸟瞰图或前视图上进行处理，然后使用多个预定义的3D anchors来生成3D bounding boxes。
除了将点云投影到鸟瞰图上，还可以将点云直接转换为3D Voxels格式，然后使用3DCNN来检测，这其中的代表论文有VoxelNet（https://arxiv.org/abs/1711.06396），Second（https://www.mdpi.com/1424-8220/18/10/3337）。

MV3D	VoxelNet	Second

以上方法虽然能够高效的生成3D候选方案，但是其目标检测感受野往往是有限的，点云在转换成`grid`时，不可避免的会出现信息丢失的情况。

3D Object Detection with Point-based Methods：基于Point的方法大多数都是使用PointNet（https://arxiv.org/abs/1612.00593）网络进行点云特征学习，这使得网络能有更灵活的感受野进行点云特征学习，同时也保留了点云的原始数据信息。

这其中的代表论文是PointRCNN（https://arxiv.org/abs/1812.04244），这是一个两阶段的目标检测方案，第一阶段通过PointNet++网络将点云分为前景点和背景点，然后对每一个前景点生成一个候选方案，第二阶段对前景点及其候选方案进行进一步优化，生成最终的bounding box。

PointNet	PointRCNN

1.2 点云3D目标检测开源库

这里引用PCDet作者之前分享的文章（https://zhuanlan.zhihu.com/p/152120636）。PCDet 3D目标检测框架的整体结构设计与优势为：

数据—模型分离的顶层代码框架设计思想：

与图像处理所不同，不同点云数据集中3D坐标定义与转换往往使研究者很是迷糊。因此，PCDet定义了统一的规范化3D坐标表示贯穿整个数据处理与模型计算，从而将数据模块与模型处理模块完全分离，其优势体现在：

研究者在研发不同结构模型时，使用统一标准化的3D坐标系进行各种相关处理（比如计算loss、RoI Pooling和模型后处理等），而无需理会不同数据集的坐标规定差异性；
研究者在添加新数据集时，只需写少量代码将原始数据转化到标准化坐标定义下，PCDet将自动进行数据增强并适配到各种模型中。

PCDet数据—模型分离的顶层设计，使得研究者可以轻松适配各种模型到不同的点云3D目标检测数据集上，免去研发模型时迷失在3D坐标转换中的顾虑。

在这里插入图片描述 统一的3D目标检测坐标定义：
不同的点云数据集在坐标系以及3D框的定义上往往不一样（KITTI数据集中的camera和LiDAR两个坐标系经常让人混乱），因此在 PCDet 中采用了固定的统一点云坐标系，以及更规范的3D检测框定义，贯穿整个数据增强、处理、模型计算以及检测后处理过程。3D检测框的7维信息定义如下：

3D bounding box: (x, y, z, dx, dy, dz, heading)

其中，(x, y, z) 为物体3D框的几何中心位置，(dx, dy, dz)分别为物体3D框在heading角度为0时沿着x-y-z三个方向的长度，heading为物体在俯视图下的朝向角 (沿着x轴方向为0度角，逆时针x到y角度增加)。

基于 PCDet 所采用的标准化3D框定义，再也不用纠结到底是物体3D中心还是物体底部中心；再也不用纠结物体三维尺寸到底是l-w-h排列还是w-l-h排列；再也不用纠结heading 0度角到底是哪，到底是顺时针增加还是逆时针增加。

灵活全面的模块化模型拓扑设计：
基于下图所示的灵活且全面的模块化设计，在PCDet中搭建3D目标检测框架只需要写config文件将所需模块定义清楚，然后PCDet将自动根据模块间的拓扑顺序组合为3D目标检测框架，来进行训练和测试。

在这里插入图片描述 PCDet可以支持目前已有的绝大多数面向LiDAR点云的3D目标检测算法，包括voxel-based，point-based，point-voxel hybrid以及one-stage/two-stage等等3D目标检测算法。

在这里插入图片描述

2. PointPillars网络及工程概述

2.1 PointPillars工作原理

现在不妨先了解一下PointPillars是如何工作的。PointPillars整体思路是将3维的点云转成2维的伪图像，然后使用二维卷积网络进行端到端的目标检测，网络结构如下图所示。
在这里插入图片描述下面分别介绍PointPillars的三个子网络部分：

（1）Pillar Feature Net
Feature Net主要是负责把点云数据处理成类似图像的数据。首先可以将x-y平面投影为一个大小为h x w的网格。每一个小网格表示为一个Pillar，这样就划分出h x w个Pillar。

原始的点云数据有(x,y,z,r)4个维度，r代表点云反射率，论文中将其扩展为9个维度(x, y, z, r, x_c, y_c, z_c, x_p, y_p)，带c下标的是柱子中的点相对于柱子中心的偏移位置坐标，带p下标的是点相对于整个大网格中心的全局偏移位置坐标。于是就形成了维度为（D, P, N）的张量，其中D=9（不过PCDet实现与论文稍有不同，PCDet扩展成D=10）, N为每个Pillar的采样点数，P为非空的Pillar数目。

然后就是学习点云特征，用一个简化的PointNet从D维中学出C个channel来得到一个(C, P, N)的张量。在Ｎ这个维度上做max pooling operation，得到(C, P)的张量．最后得到(C,H,W)的伪图像．

（2）Backbone

包含两个子网络，一个是自上而下的下采样网络，另一个是上采样网络，具体网络结构可以看本文2.2节。

（3）Detection

检测头使用的是SSD的检测头，关于SSD算法细节可以参考《动手学深度学习》这本书（http://zh.d2l.ai/chapter_computer-vision/ssd.html）。
PointPillars工作原理就介绍这么多，下面将介绍PointPillar工程的整体结构。

2.2 PointPillar工程

参考PCDet，PointPillars各文件组织方式如下，这里暂时只需要对整个工程有个整体印象，后面将逐步完成各文件中的代码：

PCDet
├── data
│   ├── velodyne      
│   │   │──000010.bin        
├── doc
├── output
├── pcdet
│   ├── config.py
│   ├── datasets
│   │   ├── dataset.py
│   │   ├── __init__.py
│   │   ├── kitti
│   │   │   ├── kitti_dataset.py
│   │   │   └── __pycache__
│   │   │       └── kitti_dataset.cpython-36.pyc
│   │   └── __pycache__
│   │       ├── dataset.cpython-36.pyc
│   │       └── __init__.cpython-36.pyc
│   ├── models
│   │   ├── bbox_heads
│   │   │   ├── anchor_target_assigner.py
│   │   │   ├── __pycache__
│   │   │   │   ├── anchor_target_assigner.cpython-36.pyc
│   │   │   │   └── rpn_head.cpython-36.pyc
│   │   │   └── rpn_head.py
│   │   ├── detectors
│   │   │   ├── detector3d.py
│   │   │   ├── __init__.py
│   │   │   ├── pointpillar.py
│   │   │   └── __pycache__
│   │   │       ├── detector3d.cpython-36.pyc
│   │   │       ├── __init__.cpython-36.pyc
│   │   │       └── pointpillar.cpython-36.pyc
│   │   ├── __init__.py
│   │   ├── model_utils
│   │   │   ├── __init__.py
│   │   │   ├── __pycache__
│   │   │   │   ├── __init__.cpython-36.pyc
│   │   │   │   └── pytorch_utils.cpython-36.pyc
│   │   │   └── pytorch_utils.py
│   │   ├── __pycache__
│   │   │   └── __init__.cpython-36.pyc
│   │   ├── rpn
│   │   │   ├── pillar_scatter.py
│   │   │   └── __pycache__
│   │   │       └── pillar_scatter.cpython-36.pyc
│   │   └── vfe
│   │       ├── __init__.py
│   │       ├── __pycache__
│   │       │   ├── __init__.cpython-36.pyc
│   │       │   └── vfe_utils.cpython-36.pyc
│   │       └── vfe_utils.py
│   ├── ops
│   │   ├── iou3d_nms
│   │   │   ├── build
│   │   │   │   ├── lib.linux-x86_64-3.6
│   │   │   │   │   └── iou3d_nms_cuda.cpython-36m-x86_64-linux-gnu.so
│   │   │   │   └── temp.linux-x86_64-3.6
│   │   │   │       └── src
│   │   │   │           ├── iou3d_nms_kernel.o
│   │   │   │           └── iou3d_nms.o
│   │   │   ├── iou3d_nms_cuda.cpython-36m-x86_64-linux-gnu.so
│   │   │   ├── iou3d_nms.egg-info
│   │   │   │   ├── dependency_links.txt
│   │   │   │   ├── PKG-INFO
│   │   │   │   ├── SOURCES.txt
│   │   │   │   └── top_level.txt
│   │   │   ├── iou3d_nms_utils.py
│   │   │   ├── __pycache__
│   │   │   │   └── iou3d_nms_utils.cpython-36.pyc
│   │   │   ├── setup.py
│   │   │   └── src
│   │   │       ├── iou3d_nms.cpp
│   │   │       └── iou3d_nms_kernel.cu
│   │   └── roiaware_pool3d
│   │       ├── build
│   │       │   ├── lib.linux-x86_64-3.6
│   │       │   │   └── roiaware_pool3d_cuda.cpython-36m-x86_64-linux-gnu.so
│   │       │   └── temp.linux-x86_64-3.6
│   │       │       └── src
│   │       │           ├── roiaware_pool3d_kernel.o
│   │       │           └── roiaware_pool3d.o
│   │       ├── __pycache__
│   │       │   └── roiaware_pool3d_utils.cpython-36.pyc
│   │       ├── roiaware_pool3d_cuda.cpython-36m-x86_64-linux-gnu.so
│   │       ├── roiaware_pool3d.egg-info
│   │       │   ├── dependency_links.txt
│   │       │   ├── PKG-INFO
│   │       │   ├── SOURCES.txt
│   │       │   └── top_level.txt
│   │       ├── roiaware_pool3d_utils.py
│   │       ├── setup.py
│   │       └── src
│   │           ├── roiaware_pool3d.cpp
│   │           └── roiaware_pool3d_kernel.cu
│   ├── __pycache__
│   │   └── config.cpython-36.pyc
│   └── utils
│       ├── box_coder_utils.py
│       ├── box_utils.py
│       ├── common_utils.py
│       └── __pycache__
│           ├── box_coder_utils.cpython-36.pyc
│           ├── box_utils.cpython-36.pyc
│           └── common_utils.cpython-36.pyc
└── tools
    ├── pointpillar.pth
    ├── pointpillar.yaml
    ├── test.py
    └── test.sh
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

下面给出PointPillars的网络结构，主要由3部分组成，网路结构相对也是比较简单的，这可能也是PointPillars为何是KITTI数据集上运算速度最快的原因。
在这里插入图片描述

下面是网络的具体结构：

PointPillar(
  (vfe): PillarFeatureNetOld2(
    (pfn_layers): ModuleList(
      (0): PFNLayer(
        (linear): Linear(in_features=10, out_features=64, bias=False)
        (norm): BatchNorm1d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
      )
    )
  )
  (rpn_net): PointPillarsScatter()
  (rpn_head): RPNV2(
    (blocks): ModuleList(
      (0): Sequential(
        (0): ZeroPad2d(padding=(1, 1, 1, 1), value=0.0)
        (1): Conv2d(64, 64, kernel_size=(3, 3), stride=(2, 2), bias=False)
        (2): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (3): ReLU()
        (4): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (5): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (6): ReLU()
        (7): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (8): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (9): ReLU()
        (10): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (11): BatchNorm2d(64, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (12): ReLU()
      )
      (1): Sequential(
        (0): ZeroPad2d(padding=(1, 1, 1, 1), value=0.0)
        (1): Conv2d(64, 128, kernel_size=(3, 3), stride=(2, 2), bias=False)
        (2): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (3): ReLU()
        (4): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (5): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (6): ReLU()
        (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (8): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (9): ReLU()
        (10): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (11): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (12): ReLU()
        (13): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (14): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (15): ReLU()
        (16): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (17): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (18): ReLU()
      )
      (2): Sequential(
        (0): ZeroPad2d(padding=(1, 1, 1, 1), value=0.0)
        (1): Conv2d(128, 256, kernel_size=(3, 3), stride=(2, 2), bias=False)
        (2): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (3): ReLU()
        (4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (5): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (6): ReLU()
        (7): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (8): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (9): ReLU()
        (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (11): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (12): ReLU()
        (13): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (14): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (15): ReLU()
        (16): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (17): BatchNorm2d(256, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (18): ReLU()
      )
    )
    (deblocks): ModuleList(
      (0): Sequential(
        (0): ConvTranspose2d(64, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (2): ReLU()
      )
      (1): Sequential(
        (0): ConvTranspose2d(128, 128, kernel_size=(2, 2), stride=(2, 2), bias=False)
        (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (2): ReLU()
      )
      (2): Sequential(
        (0): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(4, 4), bias=False)
        (1): BatchNorm2d(128, eps=0.001, momentum=0.01, affine=True, track_running_stats=True)
        (2): ReLU()
      )
    )
    (conv_cls): Conv2d(384, 18, kernel_size=(1, 1), stride=(1, 1))
    (conv_box): Conv2d(384, 42, kernel_size=(1, 1), stride=(1, 1))
    (conv_dir_cls): Conv2d(384, 12, kernel_size=(1, 1), stride=(1, 1))
  )
)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

最后，我们看一下PointPillar.yaml配置文件，配置文件存储着网络具体参数，以及训练和测试参数，这在后面的代码编写时会多次用到：

CLASS_NAMES: ['Car', 'Pedestrian', 'Cyclist']

DATA_CONFIG:
    DATASET: 'KittiDataset'
    DATA_DIR: 'data'
    FOV_POINTS_ONLY: True
    NUM_POINT_FEATURES: {
        'total': 4,
        'use': 4
    }
    POINT_CLOUD_RANGE: [0, -39.68, -3, 69.12, 39.68, 1]
    MASK_POINTS_BY_RANGE: True

    TRAIN:
        INFO_PATH: [
            data/kitti_infos_train.pkl
        ]
        SHUFFLE_POINTS: True
        MAX_NUMBER_OF_VOXELS: 16000

    TEST:
        INFO_PATH: [
            data/kitti_infos_val.pkl
        ]
        SHUFFLE_POINTS: False
        MAX_NUMBER_OF_VOXELS: 40000            

    AUGMENTATION:
        NOISE_PER_OBJECT:
            ENABLED: True
            GT_LOC_NOISE_STD: [1.0, 1.0, 0.1]
            GT_ROT_UNIFORM_NOISE: [-0.78539816, 0.78539816]
        NOISE_GLOBAL_SCENE:
            ENABLED: True
            GLOBAL_ROT_UNIFORM_NOISE: [-0.78539816, 0.78539816]
            GLOBAL_SCALING_UNIFORM_NOISE: [0.95, 1.05]
        DB_SAMPLER:
            ENABLED: True
            DB_INFO_PATH: [
                data/kitti/kitti_dbinfos_train.pkl
            ]
            PREPARE:
                filter_by_difficulty: [-1]
                filter_by_min_points: ['Car:5', 'Pedestrian:5', 'Cyclist:5']
            RATE: 1.0
            SAMPLE_GROUPS: ['Car:15','Pedestrian:10', 'Cyclist:10']
            USE_ROAD_PLANE: True

    VOXEL_GENERATOR:
        MAX_POINTS_PER_VOXEL: 32   
        VOXEL_SIZE: [0.16, 0.16, 4] 


MODEL:
    NAME: PointPillar 
    VFE:
        NAME: PillarFeatureNetOld2
        ARGS: {
            'use_norm': True,
            'num_filters': [64],
            'with_distance': False,
        }

    RPN:
        PARAMS_FIXED: False  # DO NOT USE THIS
        BACKBONE:
            NAME: PointPillarsScatter
            ARGS: {}

        RPN_HEAD:
            NAME: RPNV2
            DOWNSAMPLE_FACTOR: 8
            ARGS: {
                'use_norm': True,
                'concat_input': False,
                'num_input_features': 64,
                'layer_nums': [3, 5, 5],
                'layer_strides': [2, 2, 2],
                'num_filters': [64, 128, 256], 
                'upsample_strides': [1, 2, 4],
                'num_upsample_filters': [128, 128, 128],
                'encode_background_as_zeros': True,

                'use_direction_classifier': True,
                'num_direction_bins': 2,
                'dir_offset': 0.78539,      
                'dir_limit_offset': 0.0,
                'use_binary_dir_classifier': False
            }
            TARGET_CONFIG:
                DOWNSAMPLED_FACTOR: 2 
                BOX_CODER: ResidualCoder

                REGION_SIMILARITY_FN: nearest_iou_similarity
                SAMPLE_POS_FRACTION: -1.0
                SAMPLE_SIZE: 512         

                ANCHOR_GENERATOR: [
                    {'anchor_range': [0, -40.0, -1.78, 70.4, 40.0, -1.78], 
                     'sizes': [[1.6, 3.9, 1.56]],
                     'rotations': [0, 1.57],
                     'matched_threshold': 0.6,
                     'unmatched_threshold': 0.45,
                     'class_name': 'Car'},
                    {'anchor_range': [0, -40, -0.6, 70.4, 40, -0.6],
                     'sizes': [[0.6, 0.8, 1.73]],
                     'rotations': [0, 1.57],
                     'matched_threshold': 0.5,
                     'unmatched_threshold': 0.35,
                     'class_name': 'Pedestrian'},
                    {'anchor_range': [0, -40, -0.6, 70.4, 40, -0.6],
                     'sizes': [[0.6, 1.76, 1.73]],
                     'rotations': [0, 1.57],
                     'matched_threshold': 0.5,
                     'unmatched_threshold': 0.35,
                     'class_name': 'Cyclist'},
                ]

    RCNN:
        ENABLED: False

    LOSSES:
        RPN_REG_LOSS: smooth-l1
        LOSS_WEIGHTS: {
            'rpn_cls_weight': 1.0,
            'rpn_loc_weight': 2.0,
            'rpn_dir_weight': 0.2,
            'code_weights': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
        }

    TRAIN:
        SPLIT: train

        OPTIMIZATION:
            OPTIMIZER: adam_onecycle
            LR: 0.003
            WEIGHT_DECAY: 0.01
            MOMENTUM: 0.9

            MOMS: [0.95, 0.85]
            PCT_START: 0.4
            DIV_FACTOR: 10
            DECAY_STEP_LIST: [35, 45]
            LR_DECAY: 0.1
            LR_CLIP: 0.0000001

            LR_WARMUP: False
            WARMUP_EPOCH: 1

            GRAD_NORM_CLIP: 10

    TEST:
        SPLIT: val

        NMS_TYPE: nms_gpu
        MULTI_CLASSES_NMS: False
        NMS_THRESH: 0.01
        SCORE_THRESH: 0.1       
        USE_RAW_SCORE: True      

        NMS_PRE_MAXSIZE_LAST: 4096
        NMS_POST_MAXSIZE_LAST: 500

        RECALL_THRESH_LIST: [0.5, 0.7]

        EVAL_METRIC: kitti

        BOX_FILTER: {
            'USE_IMAGE_AREA_FILTER': True,
            'LIMIT_RANGE': [0, -40, -3.0, 70.4, 40, 3.0]
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172

我们也可以看看本工程的代码量，总共有2280行代码，其中对于CUDA和C++部分，我们使用PCDet工程中提供的代码，将重点放在Python代码的编写部分。

-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
Python                          22            399            875           1183
CUDA                             2            156             72            525
C++                              2             92             47            226
Markdown                         1             34              0            199
YAML                             1             26              0            146
Bourne Shell                     1              0              0              1
-------------------------------------------------------------------------------
SUM:                            29            707            994           2280
-------------------------------------------------------------------------------
1
2
3
4
5
6
7
8
9
10
11
12

总结：本文首先对3D目标检测研究现状进行了概述，然后介绍了PCDet3D目标检测库，最后对要实现的PointPillars工作原理及其工程进行了介绍。在下一篇文章中我们将开始从头编写代码，一步一步实现3D检测模型。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/凡人多烦事01/article/detail/106275