mmdetection3d框架下的CenterPoint网路模型

一、准备工作

1.1,按照readme.md配置好环境

1.2,准备数据:nuscenes v1.0-mini即可,放在./data目录下即可

1.3,生成pkl

python tool/create_data.py nuscenes --root-path ../data/v1.0-mini --out-dir ../data/v1.0-mini 

create_data.py 会自动调用mmdet3d的updata_infos_to_v2.py,生成mmdet3d可用的pkl文件

1.4,config配置文件

(1)

二、nuscense数据预处理

2.1 数据加载入口

2.1.1,构建runner

runner = Runner.from_cfg(cfg)

按照cfg文件构建runner,会调用Runner的__init__()初始化函数进行构建。

Runner基本包含了训练、推理、测试的所有功能,以训练为例,在Runner的构建中,需要把训练所需要的配置参数、训练超参、优化器、模型、log等等都搭建好。

2.1.2,Runner构建model

self.model = self.build_model(model)

其中build_model调用的是下面函数:

model = MODELS.build(model)

   其中MODELS是注册Register的类实例化,build是类Register的模型构建函数,调用的是下面build_model_from_cfg函数

MODELS = Registry('model', build_model_from_cfg)
注册机制:

Examples:
    >>> from mmengine import Registry   #使用mmengine中的Registry模块
    >>> MODELS = Registry('models')    #实例化一个MODELS类
    >>> @MODELS.register_module()    # 装饰器模型注册,register_module方式搭ResNet
    >>> class ResNet:
    >>>     def __init__(self, depth, stages=4):
    >>>         self.depth = depth
    >>>         self.stages = stages
    >>> cfg = dict(type='ResNet', depth=50) #配置文件
    >>> model = MODELS.build(cfg)    #模型构建

2.1.3,数据加载入口

初始化:
#01
runner.train()

#02
class runner():
runner.train():
        self._train_loop = self.build_train_loop(self._train_loop)  

#03
class runner():
def build_train_loop()
        if by_epoch:
            loop = EpochBasedTrainLoop(
                **loop_cfg, runner=self, dataloader=self._train_dataloader)

#04
class EpochBasedTrainLoop():
    init():
        super().__init__(runner, dataloader)

#05
class BaseLoop().init():
        self.dataloader = runner.build_dataloader()

#06
class runner():
def build_dataloader()
        dataset = DATASETS.build(dataset_cfg)

#07
@DATASETS.register_module()
class NuScenesDataset(Det3DDataset):

#08
@DATASETS.register_module()
class Det3DDataset(BaseDataset):

#09
class BaseDataset(Dataset):
        self.pipeline = Compose(pipeline)

#10
class Compose()
init():
        intitransform = TRANSFORMS.build(transform)


#11
__call__():
        for t in self.transforms:
            data = t(data)


#调用
model = self.train_loop.run()  

class det3d_dataset():
prepare_data():
    ori_input_dict = self.get_data_info(index)

class BaseDataset():中的__getitem__()
data = self.prepare_data(idx)

dataset_wrapper.py中class CBGSDataset:中的__getitem__()
ori_index = self._get_ori_dataset_idx(idx)


nuscense_dataset.py的初始化直接调用父类det3d_dataset.py

det3d_dataset.py中的

prepare_data():
   example = self.pipeline(input_dict)

会调用父类:base_dataset.py 中的

self.pipeline = Compose(pipeline)
通过Compose类的_init_函数来build transformes,通过__call__函数实现transformes的各个级联操作。

for t in self.transforms:
    data = t(data)

如果要增加预处理操作,需要在transformes增加新的类,可参考loading.py,然后在__init__.py中进行报备。就可以通过Transformes=Registry() --Transformes.build()对预处理操作进行实现。

2.2 数据预处理

数据预处理包含以下pipline:

mmdetection3d框架下的CenterPoint网路模型_第1张图片

2.2.1 LoadPointsFromFile /加载关键帧点云

points 维度[n, 5],其中5=[x,y,z,i,id],id从0到n

point_class有以下种类:bev,color,coord,device,height,shape

mmdetection3d框架下的CenterPoint网路模型_第2张图片

返回results内容包括如下,其中results[‘points'] 为关键帧的点云数据。

mmdetection3d框架下的CenterPoint网路模型_第3张图片

2.2.2 LoadPointsFromMultiSweeps /加载sweep点云

根据 results['lidar_sweeps']['lidar_points']['lidar_path'] 路径取出sweeps的点云,与关键帧点云拼接到一起,最后给到 results['points'] 。

2.2.3 LoadAnnotations3D 加载label

Annotation3d 格式:

gt_bboxes_3d:【x,y,z,l,w,h,yaw,vx,vy】共9维。

gt_bboxes_label:【1,2,3,4,5...】

2.2.4 ObjectSample /采样gt到data

  • use_ground_plane:是否使用地面平面

从gt中采样的最大数量:这个采样后总目标数有点少,可以适当增加一些。

mmdetection3d框架下的CenterPoint网路模型_第4张图片

transform():
    self.db_sampler.sample_all()

会调用基类中的dbsampler::sample_all()函数,对sample的真值目标的点云和box与本帧进行融合。

2.2.4  GlobalRotScaleTrans /将全局旋转、缩放和平移应用于一个三维场景。

  • _rot_bbox_points 旋转
  • _scale_bbox_points 缩放
  • _trans_bbox_points 平移
    

2.2.5 RandomFlip3D 随机旋转

2.2.6 PointRangeFilter /点云范围过滤

2.2.7 ObjectRangeFilter /目标范围过滤

2.2.8 ObjectNameFilter /目标类别过滤

2.2.9 PointShuffle /点云乱序

2.2.10 Pack3DDetInputs  /转换为mmdet3D默认的输入格式

三、模型训练

3.1 输入格式 example

data_samples: 里面包含了很多变量,是满足Det3DDataSample(mmdetection3D数据结构接口)的格式,其中最主要的是gt_instances_3d,3D真值框(原始labels+从gt中sample的labels)。

points:主要包括点云数据(原始点云+从gt中sample的点云)。

mmdetection3d框架下的CenterPoint网路模型_第5张图片

3.2 Det3DDataPreprocessor /点云体素化处理

对于second:体素化的最大数量最好为20000,centerpoint的最大体素数量为9000. (可以根据实际场景测试看多少个体素基本可以把场景点云覆盖得到,如下面的coors_out);调用体素化之前必须要对点云进行shuffle,因为会有很多点被扔掉。一个点云范围总共可以有1000*1000*40个体素,不会都用到,达到体素数量总数后,后面的点云会被直接抛弃。

体素化处理有两种:hard(单元voxel里点云固定数量,centerpoint为10,这个值可能小了有点)和dynamic(单元voxel里点云数量动态的,默认为35)。

体素化过程调用了外部c++的函数:这个函数的实现是在bevfusion里voxelization_cpu.cpp;

mmdetection3d框架下的CenterPoint网路模型_第6张图片

 mmdetection3d框架下的CenterPoint网路模型_第7张图片

对于体素化过程,关注两个参数就足够了:voxel数量、单voxel点云数量。根据实际场景配置好即可。最后的输出:

  • voxel的shape=[n,10,5],n个体素、每个体素10个point,每个point包括5个维度[x,y,z,i,*] 
  • coors_out的shape=[n,3];n为不为空的体素个数,值并非物理世界坐标,而是在体素空间的位置坐标,后面需要转为真实物理世界的三维坐标。可根据coors_out的维度看每帧大概多少个不为空的体素,然后设定最大的体素数量的参数。
  • num_points_per_voxel_out的shape为n,n为不为空的体素个数。里面的值为每个体素内的point数量。

voxelization模块输出:

voxel_dict['voxels'] = voxels #[n,10,5]
voxel_dict['coors'] = coors #[n,4] 补了一维0
整个数据预处理的输出:
'inputs': batch_inputs, #voxel_dict
'data_samples': data_samples #labels

3.3 HardSimpleVFE /体素特征提取、second中的体素特征encoder

体素内所有点的均值

模块输出:points_mean=[n,5]

体素特征提取:

3.4 SparseEncoder /稀疏卷积模块

输入:

voxel_features = [n,5]
SparseConvTensor = [n,5] 维度和点云范围有关

mmdetection3d框架下的CenterPoint网路模型_第8张图片

经过encoder_layer之后,点云维度变为[n,128]

然后经过dense(scatter_nd 操作) 稠密处理,点云维度变为:

N, C, D, H, W = [1,128,2,128,128]

输出维度:

spatial_features 把C*D维度合成一维:[1,256,128,128]

3.5 SECOND

输入tensor:x = [1,256,128,128]

该部分模型基本为2D conv网络层

mmdetection3d框架下的CenterPoint网路模型_第9张图片

 回顾下second网络结构

 second模块输出维度:

out1 = [1,128,128,128]

out2 = [1,256,64,64]

3.6 SECOND-FPN

mmdetection3d框架下的CenterPoint网路模型_第10张图片

 输出维度:

out1 = [1,256,128,128]

out2 =  [1,256,128,128]

最终out = out1+out2 = [1,512,128,128]

3.7 CenterHead

每个任务都有一个 task_heads,同时对应一个seperate_Head:

mmdetection3d框架下的CenterPoint网路模型_第11张图片

 每个seperate_Head,包括以下一些结果输出:

mmdetection3d框架下的CenterPoint网路模型_第12张图片

 所以最后的输出out:

mmdetection3d框架下的CenterPoint网路模型_第13张图片

其中 :

reg=[1,2,128,128]

height=[1,1,128,128]

dim=[1,3,128,128]

rot=[1,2,128,128]

vel=[1,2,128,128]

heatmap=[1,1,128,128]

3.8 loss

分类loss:GaussianFocalLoss()

mmdetection3d框架下的CenterPoint网路模型_第14张图片

------------------------------------------------------------------------------------------------------------------------------

build_model——centerpoint——mvx_two_stage——VFE/sparse-encoder/second/fpn/centerhead

build_loop——loop——EpochBasedTrainLoop——base_loop:

        build_dataloader——nuscense_dataset——det3d_dataset——base_dataset——pipline

runner.py

        train():

        model = self.train_loop.run()

loops.py中

        run()

        run_epoch():

        ##从这句开始调用pipline处理数据
        for idx, data_batch in enumerate(self.dataloader):
            self.run_iter(idx, data_batch)

det3d-dataset.py:

        prepare_data():

        example = self.pipeline(input_dict)

runner.train(): 

model = self.train_loop.run()  # type: ignore

loops.py中run():

        run_epoch():

        for idx, data_batch in enumerate(self.dataloader): 
            self.run_iter(idx, data_batch)

        run_iter():

        outputs = self.runner.model.train_step(
            data_batch, optim_wrapper=self.runner.optim_wrapper)

 base-model.py中

        train-step() 

        with optim_wrapper.optim_context(self):
            data = self.data_preprocessor(data, True)
            losses = self._run_forward(data, mode='loss')  # type: ignore

        _run_forward():

        if isinstance(data, dict):
            results = self(**data, mode=mode)

mvx_two_stage.py中

        loss():

        img_feats, pts_feats = self.extract_feat(batch_inputs_dict,
                                         batch_input_metas)

        losses_pts = self.pts_bbox_head.loss(pts_feats, batch_data_samples,
                                     **kwargs)

        extract_feat():

        pts_feats = self.extract_pts_feat(
            voxel_dict,
            points=points,
            img_feats=img_feats,
            batch_input_metas=batch_input_metas)

        extract_pts_feat():

        ##HardSimpleVFE
        voxel_features = self.pts_voxel_encoder(voxel_dict['voxels'],
                                        voxel_dict['num_points'],
                                        voxel_dict['coors'], img_feats,
                                        batch_input_metas)
        batch_size = voxel_dict['coors'][-1, 0] + 1
        
        ## sparse-encoder
        x = self.pts_middle_encoder(voxel_features, voxel_dict['coors'],
                            batch_size)
        
        ##second backbone
        x = self.pts_backbone(x)
        
        ##second-FPN
        if self.with_pts_neck:
            x = self.pts_neck(x)

     

mvx_two_stage.py中

        loss():

        img_feats, pts_feats = self.extract_feat(batch_inputs_dict,
                                         batch_input_metas)

        losses_pts = self.pts_bbox_head.loss(pts_feats, batch_data_samples,
                                     **kwargs)

center_head.py中

        loss():         

                ##计算head输出

        outs = self(pts_feats)
        ##计算loss结果
        losses = self.loss_by_feat(outs, batch_gt_instance_3d)

        loss_by_feat():

        loss_heatmap = self.loss_cls(
            preds_dict[0]['heatmap'],
            heatmaps[task_id],
            avg_factor=max(num_pos, 1))
        loss_bbox = self.loss_bbox(
            pred, target_box, bbox_weights, avg_factor=(num + 1e-4))

base_model.py中

        train_step():

        parsed_losses, log_vars = self.parse_losses(losses)  
        ##更新模型参数
        optim_wrapper.update_params(parsed_losses)

你可能感兴趣的:(mmdet3d)