PointPillar 所需模块

最新推荐文章于 2023-05-15 16:17:51 发布
最新推荐文章于 2023-05-15 16:17:51 发布
阅读量523 收藏 6
点赞数
分类专栏： PCDet
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W1995S/article/details/115211740
版权

Pcdet-PointPillars原始模型结构
在这里插入图片描述

 网络部分包含4部分：
（1）PillarVFE              pcdet/models/backbones_3d/vfe/pillar_vfe.py   # 3D卷积
（2）PointPillarScatter     pcdet/models/backbones_2d/map_to_bev/pointpillar_scatter.py   # 2D卷积
（3）BaseBEVBackbone        pcdet/models/backbones_2d/base_bev_backbone.py   # 2D卷积
（4）AnchorHeadSingle       pcdet/models/dense_heads/anchor_head_single.py   # 预测类别、box

定位：pcdet/models/detectors/pointpillar.py

for cur_module in self.module_list:  # 遍历所需模块
    print('遍历所需模块:','\n',str(cur_module))


遍历所需模块: 
 PillarVFE
(
  (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)
    )
  )
)


遍历所需模块: 
 PointPillarScatter()


遍历所需模块: 
for idx in range(num_levels):  # 3
    cur_layers = [
        nn.ZeroPad2d(1),
        nn.Conv2d(
            c_in_list[idx], num_filters[idx], kernel_size=3,
            stride=layer_strides[idx], padding=0, bias=False
        ),
        nn.BatchNorm2d(num_filters[idx], eps=1e-3, momentum=0.01),
        nn.ReLU()
    ]
    for k in range(layer_nums[idx]):  # 3:0-2, 5:0-4, 5:0-4
        cur_layers.extend([
            nn.Conv2d(num_filters[idx], num_filters[idx], kernel_size=3, padding=1, bias=False),
            nn.BatchNorm2d(num_filters[idx], eps=1e-3, momentum=0.01),
            nn.ReLU()
        ])
 如下：
 BaseBEVBackbone(
  (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()
    )
  )
)


遍历所需模块: 
 AnchorHeadSingle(
  (cls_loss_func): SigmoidFocalClassificationLoss()
  (reg_loss_func): WeightedSmoothL1Loss()
  (dir_loss_func): WeightedCrossEntropyLoss()
  (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))
)

pointpillar配置文件

PointPillar
(
  (vfe): PillarVFE(
    (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)
      )
    )
  )
  
  (backbone_3d): None  # 不使用3D卷积
  (map_to_bev_module): PointPillarScatter()
  (pfe): None  # 不使用pfe   pcdet/models/backbones_3d/pfe
  
  (backbone_2d): BaseBEVBackbone(
    (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()
      )
    )
  )
  
  (dense_head): AnchorHeadSingle(
    (cls_loss_func): SigmoidFocalClassificationLoss()
    (reg_loss_func): WeightedSmoothL1Loss()
    (dir_loss_func): WeightedCrossEntropyLoss()
    (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))
  )
  
  (point_head): None  # 不使用
  
  (roi_head): None  # 不使用
)
THE@JOKER
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Point-Pillar
03-29
PyTorch中PointPillars架构的简洁实现
pointpillars----nuscene多分类篇
有所为，有所成长
09-29 4716
1.数据预处理 先采用Mini_trainal数据集。 数据分割： python create_data.py nuscenes_data_prep --data_path=NUSCENES_TRAINVAL_DATASET_ROOT --version="v1.0-trainval" --max_sweeps=10 --dataset_name="NuScenesDataset" pytho...
【3D 目标检测模型部署】全链条打通！PointPillars 从模型到部署
qq_39967751的博客
07-14 7114
近几年点云目标检测一直是计算机视觉领域中很火的任务，各种方法也是层出不穷，从基于点云的PointNet、PointNet++，到使用体素方法的VoxelNet。这些网络取得了不错的检测性能，但同时也存在一些问题。PointNet系列的Point-based模型直接对点云进行处理，可以减少位置信息的损失，但同时也带来了巨大的计算资源消耗，使其很难做到实时。我们来看一下PointPillars中的PillarFeatureNet模块的具体操作，如下图所示。outshttps。......
PointPillar 3D目标检测模型详解
IT菜鸟
02-17 5662
3D检测论文阅读简记自动驾驶中基于Lidar的object检测，简单的说，就是从3D点云数据中定位到object的框和类别。具体地，输入是点云 $X∈R^{N×c}一般c4，输出是n个检测框bboxes以第i个检测框bbox为例它包括∗∗位姿信息∗∗(一般 c=4 )，输出是 n 个检测框bboxes, 以第 i 个检测框bbox为例, 它==包括**位姿信息**一般c4，输出是n个检测框bboxes以第i个检测框bb。
点云检测算法之PointPillar深度解读
victor_manches的博客
04-01 2862
介绍损失函数前这里介绍下PP的Anchor的设计，由于PP是基于点云数据的俯视图的表示，所以这里初始化的矛框有着不同于图像的矛框的设计，不同于图像的远小近大的特点，点云数据拥有者几何不变性的特点，所以在这里我们可以直接利用不同类别的先验知识来初始化矛框，下面是车辆和行人的矛框的初始化。PS：虽然矛框是3D的，但是再与GT匹配的时候，只采用2D的信息。现在在目标检测的领域的基本上是标配，主要解决的问题就是多尺度变换的不足，高层的特征虽然包含了丰富的语义信息，但是由于低分辨率，很难准确地保存物体的位置信息。
PointPillars理解
qq_40719268的博客
06-09 3897
PointPillar网络是工业界中速度较快、性能较优的点云目标检测算法，它主要有三个子网络组成，将三维点云转化的伪图像，然后按照图像处理思路来处理点云。
【玩转PointPillars】PillarScatter操作
07-18 2553
ing....
Pointpillar目标检测部署模型
10-17
pointpillar目标检测部署模型
OpenPCDet权重文件pointpillar_7728.pth
01-17
OpenPCDet权重文件pointpillar_7728.pth
点云数据当中点的绘制顺序代码
05-13
点云数据当中点的绘制顺序代码。3w多个点的点云数据。程序可以根据顺序。把每个点一个个的绘制出来。对研究点云点的顺序有较大的借鉴意义。opengl的代码。vs2010打开。
PointCloudDet3D：利用PyTorch从点云中检测3D对象的通用代码库-python
06-18
支持一阶段和二阶段 3D 对象检测框架 多 GPU 多机器分布式训练，在 KITTI 上实现 SoTA 结果大约需要 5 小时GPU 版本 3D IoU 计算和旋转 NMS 模型 Zoo KITTI 3D Object Detection Baselines 支持的方法如下表所示。...
自动驾驶激光点云 3D 目标检测 PointPillar 论文简述
frank 的专栏
04-11 5178
之前有针对 VoxelNet 这篇论文做过简述，今天的主题是 PointPillar。 PointPillar 是 2019 年提出来的模型，相比于之前的点云处理模型，它有 3 个要点： 提出 Pillar 这个概念，将类 PointNets 模型能够以 Pillar 为基础单位学习点云特征 运用标准化的 2D 卷积进行后续处理 快，满足实时要求，最快的版本到达 105 Hz PointPillar 和前辈 处理点云最先需要大量的手工作业，后来 VoxelNet 第一次引入了真正的端到端的特征学习。 但
OpenPCDet系列 | 5.2 PointPillars算法——PointPillarScatter伪图像BEV特征构建模块
Clichong
05-15 1090
那么，由于coord存储了voxel的具体网格，可以对其构造出在一维空间中的索引，然后根据索引在空矩阵的相应对位置上填充voxel特征。PointPillarScatter模块的初始化部分比较简单，只是简单的保存了相关的yaml配置，以及保存了点云场景的平面网络的grid size。在进行了PillarVFE编码后，此时的batch_dict更新如下所示，追加了pillar_features字段，表示每个voxel的特征，随后进行Map_to_BEV模块处理。
PointPillars解读
leo0308的博客
04-07 7372
论文： PointPillars: Fast Encoders for Object Detection from Point Clouds 0 简介 介绍PointPillar之前， 先简要介绍一下voxel-based检测方法的发展历程。VoxelNet是第一个将点云转换为体素（voxel）进行3D目标检测的， 但是由于3D卷积的使用， 性能非常低。 SECOND主要把3D卷积换成了更高效的稀疏卷积， 并且增加了一些数据增强， 在性能上有比较大的提升。 虽然使用了稀疏卷积， 但3D的卷积依然比较耗费资源
复现PointPillar目标检测网络里的PointPillarScatter
我欲乘风归去
01-09 2070
背景知识 PointPillar 3D点云目标检测模型，提出时间比较久了，模型不做过多介绍，给个参考链接，可自行了解。PointPillar：利用伪图像高效实现3D目标检测-技术圈 在网络模型里，使用pointnet提取点的特征后，会将pillars（C P）映射成pseudo images（C H W），这里介绍使用pytorch的tensor.scatter函数实现此操作。 模型输入有两个，一个是point（D P N），一个是point对应的indices（P 2）。point经过pointne
无人驾驶中的激光雷达（四）Pointpillar+CenterNet实现的3D点云目标检测网络
Wangxu的博客
04-02 6295
简要介绍引言基本思路一一说明未完成的东西 引言 好久没总结过新东西了，这次就把最近自己通过拼凑代码实现的一个点云目标检测网络现在这做个总结吧。 不过我的网络还没来得及改进，大思想就和别人的撞车了，人家已经发了CVPR，对于自己这个半成品网络也没什么兴趣继续改进了。 CVPR2021的论文是： Center-based 3D Object Detection and Tracking 代码：https://github.com/tianweiy/CenterPoint 我搭的网络目前叫CenterPillar
Pointpillars（一）模型结构
u013952812的专栏
07-15 1415
pointpillars模型结构解析
PointPillars：工业界大量部署落地的点云目标检测算法，精度与速度上实现SOTA！
weixin_43980550的博客
10-02 1795
PointPillar将三维点云分为一些柱体pillars，利用PointNet提取柱体pilars特征，将特征映射为2D伪图像，对2D图像使用SSD提取目标检测框和类别，速度与精度实现SOTA！工业界已大量部署！
PointPillar：利用伪图像高效实现3D目标检测
3D视觉工坊
08-21 2622
点击上方“3D视觉工坊”，选择“星标”干货第一时间送达文章导读计算机视觉任务中，2D卷积神经网络得益于极其出色的性能不断刷新着各大视觉任务的榜单，可谓是YYDS。随着人工智能算法的不断推进...
pointpillar
最新发布
11-12
PointPillar是一种用于目标检测的3D深度学习架构。它是针对自动驾驶系统的研究而开发的, 旨在通过分析点云数据来实时检测周围环境中的车辆、行人和其他物体。 PointPillar通过将点云数据转换为利用空间体素化来表示...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值