diff --git a/docs/en/advanced_guides/customize_dataset.md b/docs/en/advanced_guides/customize_dataset.md
index fea9a2572..9798ae5ad 100644
--- a/docs/en/advanced_guides/customize_dataset.md
+++ b/docs/en/advanced_guides/customize_dataset.md
@@ -1,367 +1,482 @@
 # Customize Datasets
 
-## Support new data format
+In this note, you will know how to train and test predefined models with customized datasets.
 
-To support a new data format, you can either convert them to existing formats or directly convert them to the middle format. You could also choose to convert them offline (before training by a script) or online (implement a new dataset and do the conversion at training). In MMDetection3D, for the data that is inconvenient to read directly online, we recommend to convert it into KITTI format and do the conversion offline, thus you only need to modify the config's data annotation paths and classes after the conversion.
-For data sharing similar format with existing datasets, like Lyft compared to nuScenes, we recommend to directly implement data converter and dataset class. During the procedure, inheritation could be taken into consideration to reduce the implementation workload.
+The basic steps are as below:
 
-### Reorganize new data formats to existing format
+1. Prepare data
+2. Prepare a config
+3. Train, test and inference models on the customized dataset.
 
-For data that is inconvenient to read directly online, the simplest way is to convert your dataset to existing dataset formats.
+## Data Preparation
 
-Typically we need a data converter to reorganize the raw data and convert the annotation format into KITTI style. Then a new dataset class inherited from existing ones is sometimes necessary for dealing with some specific differences between datasets. Finally, the users need to further modify the config files to use the dataset. An [example](https://mmdetection3d.readthedocs.io/en/latest/2_new_data_model.html) training predefined models on Waymo dataset by converting it into KITTI style can be taken for reference.
+The ideal situation is that we can reorganize the customized raw data and convert the annotation format into KITTI style. However, considering some calibration files and 3D annotations in KITTI format are difficult to obtain for customized datasets, we introduce the basic data format in the doc.
 
-### Reorganize new data format to middle format
+### Basic Data Format
 
-It is also fine if you do not want to convert the annotation format to existing formats.
-Actually, we convert all the supported datasets into pickle files, which summarize useful information for model training and inference.
+#### Point cloud Format
 
-The annotation of a dataset is a list of dict, each dict corresponds to a frame.
-A basic example (used in KITTI) is as follows. A frame consists of several keys, like `image`, `point_cloud`, `calib` and `annos`.
-As long as we could directly read data according to these information, the organization of raw data could also be different from existing ones.
-With this design, we provide an alternative choice for customizing datasets.
+Currently, we only support '.bin' format point cloud for training and inference. Before training on your own datasets, you need to convert your point cloud files with other formats to '.bin' files. The common point cloud data formats include `.pcd` and `.las`, we list some open-source tools for reference.
 
-```python
+1. Convert pcd to bin: https://github.com/leofansq/Tools_RosBag2KITTI
+2. Convert las to bin: The common conversion path is las -> pcd -> bin, and the conversion from las -> pcd can be achieved through [this tool](https://github.com/Hitachi-Automotive-And-Industry-Lab/semantic-segmentation-editor).
 
-[
-    {'image': {'image_idx': 0, 'image_path': 'training/image_2/000000.png', 'image_shape': array([ 370, 1224], dtype=int32)},
-     'point_cloud': {'num_features': 4, 'velodyne_path': 'training/velodyne/000000.bin'},
-     'calib': {'P0': array([[707.0493,   0.    , 604.0814,   0.    ],
-       [  0.    , 707.0493, 180.5066,   0.    ],
-       [  0.    ,   0.    ,   1.    ,   0.    ],
-       [  0.    ,   0.    ,   0.    ,   1.    ]]),
-       'P1': array([[ 707.0493,    0.    ,  604.0814, -379.7842],
-       [   0.    ,  707.0493,  180.5066,    0.    ],
-       [   0.    ,    0.    ,    1.    ,    0.    ],
-       [   0.    ,    0.    ,    0.    ,    1.    ]]),
-       'P2': array([[ 7.070493e+02,  0.000000e+00,  6.040814e+02,  4.575831e+01],
-       [ 0.000000e+00,  7.070493e+02,  1.805066e+02, -3.454157e-01],
-       [ 0.000000e+00,  0.000000e+00,  1.000000e+00,  4.981016e-03],
-       [ 0.000000e+00,  0.000000e+00,  0.000000e+00,  1.000000e+00]]),
-       'P3': array([[ 7.070493e+02,  0.000000e+00,  6.040814e+02, -3.341081e+02],
-       [ 0.000000e+00,  7.070493e+02,  1.805066e+02,  2.330660e+00],
-       [ 0.000000e+00,  0.000000e+00,  1.000000e+00,  3.201153e-03],
-       [ 0.000000e+00,  0.000000e+00,  0.000000e+00,  1.000000e+00]]),
-       'R0_rect': array([[ 0.9999128 ,  0.01009263, -0.00851193,  0.        ],
-       [-0.01012729,  0.9999406 , -0.00403767,  0.        ],
-       [ 0.00847068,  0.00412352,  0.9999556 ,  0.        ],
-       [ 0.        ,  0.        ,  0.        ,  1.        ]]),
-       'Tr_velo_to_cam': array([[ 0.00692796, -0.9999722 , -0.00275783, -0.02457729],
-       [-0.00116298,  0.00274984, -0.9999955 , -0.06127237],
-       [ 0.9999753 ,  0.00693114, -0.0011439 , -0.3321029 ],
-       [ 0.        ,  0.        ,  0.        ,  1.        ]]),
-       'Tr_imu_to_velo': array([[ 9.999976e-01,  7.553071e-04, -2.035826e-03, -8.086759e-01],
-       [-7.854027e-04,  9.998898e-01, -1.482298e-02,  3.195559e-01],
-       [ 2.024406e-03,  1.482454e-02,  9.998881e-01, -7.997231e-01],
-       [ 0.000000e+00,  0.000000e+00,  0.000000e+00,  1.000000e+00]])},
-     'annos': {'name': array(['Pedestrian'], dtype='<U10'), 'truncated': array([0.]), 'occluded': array([0]), 'alpha': array([-0.2]), 'bbox': array([[712.4 , 143.  , 810.73, 307.92]]), 'dimensions': array([[1.2 , 1.89, 0.48]]), 'location': array([[1.84, 1.47, 8.41]]), 'rotation_y': array([0.01]), 'score': array([0.]), 'index': array([0], dtype=int32), 'group_ids': array([0], dtype=int32), 'difficulty': array([0], dtype=int32), 'num_points_in_gt': array([377], dtype=int32)}}
-    ...
-]
+#### Label Format
+
+The most basic information: 3D bounding box and category label of each scene need to be contained in the annotation `.txt` file. Each line represents a 3D box in a certain scene as follow:
+
+```python
+# format: [x, y, z, dx, dy, dz, yaw, category_name]
+1.23 1.42 0.23 3.96 1.65 1.55 1.56 Car
+3.51 2.15 0.42 1.05 0.87 1.86 1.23 Pedestrian
+...
 ```
 
-On top of this you can write a new Dataset class inherited from `Custom3DDataset`, and overwrite related methods,
-like [KittiDataset](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/datasets/kitti_dataset.py) and [ScanNetDataset](https://github.com/open-mmlab/mmdetection3d/blob/master/mmdet3d/datasets/scannet_dataset.py).
+**Note**: Currently we only support KITTI Metric evaluation for customized datasets evaluation.
 
-### An example of customized dataset
+The 3D Box should be stored in unified 3D coordinates.
 
-Here we provide an example of customized dataset.
+#### Calibration Format
 
-Assume the annotation has been reorganized into a list of dict in pickle files like ScanNet.
-The bounding boxes annotations are stored in `annotation.pkl` as the following
+For the point cloud data collected by each lidar, they are usually fused and converted to a certain LiDAR coordinate. So typically the calibration information file should contain the intrinsic matrix of each camera and the transformation extrinsic matrix from the lidar to each camera in calibration `.txt` file, while `Px` represents the intrinsic matrix of `camera_x` and `lidar2camx` represents the transformation extrinsic matrix from the `lidar` to `camera_x`.
 
 ```
-{'point_cloud': {'num_features': 6, 'lidar_idx': 'scene0000_00'}, 'pts_path': 'points/scene0000_00.bin',
- 'pts_instance_mask_path': 'instance_mask/scene0000_00.bin', 'pts_semantic_mask_path': 'semantic_mask/scene0000_00.bin',
- 'annos': {'gt_num': 27, 'name': array(['window', 'window', 'table', 'counter', 'curtain', 'curtain',
-       'desk', 'cabinet', 'sink', 'garbagebin', 'garbagebin',
-       'garbagebin', 'sofa', 'refrigerator', 'table', 'table', 'toilet',
-       'bed', 'cabinet', 'cabinet', 'cabinet', 'cabinet', 'cabinet',
-       'cabinet', 'door', 'door', 'door'], dtype='<U12'),
-       'location': array([[ 1.48129511,  3.52074146,  1.85652947],
-       [ 2.90395617, -3.48033905,  1.52682471]]),
-       'dimensions': array([[1.74445975, 0.23195696, 0.57235193],
-       [0.66077662, 0.17072392, 0.67153597]]),
-       'gt_boxes_upright_depth': array([
-       [ 1.48129511,  3.52074146,  1.85652947,  1.74445975,  0.23195696,
-         0.57235193],
-       [ 2.90395617, -3.48033905,  1.52682471,  0.66077662,  0.17072392,
-         0.67153597]]),
-       'index': array([ 0,  1 ], dtype=int32),
-       'class': array([ 6,  6 ])}}
+P0
+P1
+P2
+P3
+P4
+...
+lidar2cam0
+lidar2cam1
+lidar2cam2
+lidar2cam3
+lidar2cam4
+...
 ```
 
-We can create a new dataset in `mmdet3d/datasets/my_dataset.py` to load the data.
+### Raw Data Structure
 
-```python
-import numpy as np
-from os import path as osp
+#### LiDAR-Based 3D Detection
 
-from mmdet3d.core import show_result
-from mmdet3d.core.bbox import DepthInstance3DBoxes
-from mmdet.datasets import DATASETS
-from .custom_3d import Custom3DDataset
+The raw data for LiDAR-based 3D object detection are typically organized as follows, where `ImageSets` contains split files indicating which files belong to training/validation set, `points` includes point cloud data which are supposed to be stored in `.bin` format and `labels` includes label files for 3D detection.
 
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│   ├── custom
+│   │   ├── ImageSets
+│   │   │   ├── train.txt
+│   │   │   ├── val.txt
+│   │   ├── points
+│   │   │   ├── 000000.bin
+│   │   │   ├── 000001.bin
+│   │   │   ├── ...
+│   │   ├── labels
+│   │   │   ├── 000000.txt
+│   │   │   ├── 000001.txt
+│   │   │   ├── ...
+```
 
-@DATASETS.register_module()
-class MyDataset(Custom3DDataset):
-    CLASSES = ('cabinet', 'bed', 'chair', 'sofa', 'table', 'door', 'window',
-               'bookshelf', 'picture', 'counter', 'desk', 'curtain',
-               'refrigerator', 'showercurtrain', 'toilet', 'sink', 'bathtub',
-               'garbagebin')
-
-    def __init__(self,
-                 data_root,
-                 ann_file,
-                 pipeline=None,
-                 classes=None,
-                 modality=None,
-                 box_type_3d='Depth',
-                 filter_empty_gt=True,
-                 test_mode=False):
-        super().__init__(
-            data_root=data_root,
-            ann_file=ann_file,
-            pipeline=pipeline,
-            classes=classes,
-            modality=modality,
-            box_type_3d=box_type_3d,
-            filter_empty_gt=filter_empty_gt,
-            test_mode=test_mode)
-
-    def get_ann_info(self, index):
-        # Use index to get the annos, thus the evalhook could also use this api
-        info = self.data_infos[index]
-        if info['annos']['gt_num'] != 0:
-            gt_bboxes_3d = info['annos']['gt_boxes_upright_depth'].astype(
-                np.float32)  # k, 6
-            gt_labels_3d = info['annos']['class'].astype(np.int64)
-        else:
-            gt_bboxes_3d = np.zeros((0, 6), dtype=np.float32)
-            gt_labels_3d = np.zeros((0, ), dtype=np.int64)
-
-        # to target box structure
-        gt_bboxes_3d = DepthInstance3DBoxes(
-            gt_bboxes_3d,
-            box_dim=gt_bboxes_3d.shape[-1],
-            with_yaw=False,
-            origin=(0.5, 0.5, 0.5)).convert_to(self.box_mode_3d)
-
-        pts_instance_mask_path = osp.join(self.data_root,
-                                          info['pts_instance_mask_path'])
-        pts_semantic_mask_path = osp.join(self.data_root,
-                                          info['pts_semantic_mask_path'])
-
-        anns_results = dict(
-            gt_bboxes_3d=gt_bboxes_3d,
-            gt_labels_3d=gt_labels_3d,
-            pts_instance_mask_path=pts_instance_mask_path,
-            pts_semantic_mask_path=pts_semantic_mask_path)
-        return anns_results
+#### Vision-Based 3D Detection
+
+The raw data for vision-based 3D object detection are typically organized as follows, where `ImageSets` contains split files indicating which files belong to training/validation set, `images` contains the images from different cameras, for example, images from `camera_x` need to be placed in `images\images_x`. `calibs` contains calibration information files which store the camera intrinsic matrix of each camera, and `labels` includes label files for 3D detection.
 
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│   ├── custom
+│   │   ├── ImageSets
+│   │   │   ├── train.txt
+│   │   │   ├── val.txt
+│   │   ├── calibs
+│   │   │   ├── 000000.txt
+│   │   │   ├── 000001.txt
+│   │   │   ├── ...
+│   │   ├── images
+│   │   │   ├── images_0
+│   │   │   │   ├── 000000.png
+│   │   │   │   ├── 000001.png
+│   │   │   │   ├── ...
+│   │   │   ├── images_1
+│   │   │   ├── images_2
+│   │   │   ├── ...
+│   │   ├── labels
+│   │   │   ├── 000000.txt
+│   │   │   ├── 000001.txt
+│   │   │   ├── ...
 ```
 
-Then in the config, to use `MyDataset` you can modify the config as the following
+#### Multi-Modality 3D Detection
+
+The raw data for multi-modality 3D object detection are typically organized as follows. Different from vision-based 3D Object detection, calibration information files in `calibs` store the camera intrinsic matrix of each camera and extrinsic matrix.
 
-```python
-dataset_A_train = dict(
-    type='MyDataset',
-    ann_file = 'annotation.pkl',
-    pipeline=train_pipeline
-)
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│   ├── custom
+│   │   ├── ImageSets
+│   │   │   ├── train.txt
+│   │   │   ├── val.txt
+│   │   ├── calibs
+│   │   │   ├── 000000.txt
+│   │   │   ├── 000001.txt
+│   │   │   ├── ...
+│   │   ├── points
+│   │   │   ├── 000000.bin
+│   │   │   ├── 000001.bin
+│   │   │   ├── ...
+│   │   ├── images
+│   │   │   ├── images_0
+│   │   │   │   ├── 000000.png
+│   │   │   │   ├── 000001.png
+│   │   │   │   ├── ...
+│   │   │   ├── images_1
+│   │   │   ├── images_2
+│   │   │   ├── ...
+│   │   ├── labels
+│   │   │   ├── 000000.txt
+│   │   │   ├── 000001.txt
+│   │   │   ├── ...
 ```
 
-## Customize datasets by dataset wrappers
+#### LiDAR-Based 3D Semantic Segmentation
 
-MMDetection3D also supports many dataset wrappers to mix the dataset or modify the dataset distribution for training like MMDetection.
-Currently it supports to three dataset wrappers as below:
+The raw data for LiDAR-Based 3D semantic segmentation are typically organized as follows, where `ImageSets` contains split files indicating which files belong to training/validation set, `points` includes point cloud data, and `semantic_mask` includes point-level label.
 
-- `RepeatDataset`: simply repeat the whole dataset.
-- `ClassBalancedDataset`: repeat dataset in a class balanced manner.
-- `ConcatDataset`: concat datasets.
+```
+mmdetection3d
+├── mmdet3d
+├── tools
+├── configs
+├── data
+│   ├── custom
+│   │   ├── ImageSets
+│   │   │   ├── train.txt
+│   │   │   ├── val.txt
+│   │   ├── points
+│   │   │   ├── 000000.bin
+│   │   │   ├── 000001.bin
+│   │   │   ├── ...
+│   │   ├── semantic_mask
+│   │   │   ├── 000000.bin
+│   │   │   ├── 000001.bin
+│   │   │   ├── ...
+```
 
-### Repeat dataset
+### Data Converter
 
-We use `RepeatDataset` as wrapper to repeat the dataset. For example, suppose the original dataset is `Dataset_A`, to repeat it, the config looks like the following
+Once you prepared the raw data following our instruction, you can directly use the following command to generate training/validation information files.
 
-```python
-dataset_A_train = dict(
-        type='RepeatDataset',
-        times=N,
-        dataset=dict(  # This is the original config of Dataset_A
-            type='Dataset_A',
-            ...
-            pipeline=train_pipeline
-        )
-    )
+```
+python tools/create_data.py base --root-path ./data/custom --out-dir ./data/custom
 ```
 
-### Class balanced dataset
+## An example of customized dataset
 
-We use `ClassBalancedDataset` as wrapper to repeat the dataset based on category
-frequency. The dataset to repeat needs to instantiate function `self.get_cat_ids(idx)`
-to support `ClassBalancedDataset`.
-For example, to repeat `Dataset_A` with `oversample_thr=1e-3`, the config looks like the following
+Once we finish data preparation, we can create a new dataset in `mmdet3d/datasets/my_dataset.py` to load the data.
 
 ```python
-dataset_A_train = dict(
-        type='ClassBalancedDataset',
-        oversample_thr=1e-3,
-        dataset=dict(  # This is the original config of Dataset_A
-            type='Dataset_A',
-            ...
-            pipeline=train_pipeline
-        )
-    )
-```
-
-You may refer to [source code](https://github.com/open-mmlab/mmdetection/blob/master/mmdet/datasets/dataset_wrappers.py) for details.
+import mmengine
 
-### Concatenate dataset
+from mmdet3d.det3d_dataset import Det3DDataset
+from mmdet3d.registry import DATASETS
 
-There are three ways to concatenate the dataset.
 
-1. If the datasets you want to concatenate are in the same type with different annotation files, you can concatenate the dataset configs like the following.
+@DATASETS.register_module()
+class MyDataset(Det3DDataset):
+
+    # replace with all the classes in customized pkl info file
+    METAINFO = {
+       'CLASSES': ('Pedestrian', 'Cyclist', 'Car')
+    }
+
+    def parse_ann_info(self, info):
+        """Get annotation info according to the given index.
+
+        Args:
+            info (dict): Data information of single data sample.
+
+        Returns:
+            dict: annotation information consists of the following keys:
+
+                - gt_bboxes_3d (:obj:`LiDARInstance3DBoxes`):
+                    3D ground truth bboxes.
+                - bbox_labels_3d (np.ndarray): Labels of ground truths.
+
+        """
+        ann_info = super().parse_ann_info(info)
+        if ann_info is None:
+            ann_info = dict()
+            # empty instance
+            ann_info['gt_bboxes_3d'] = np.zeros((0, 7), dtype=np.float32)
+            ann_info['gt_labels_3d'] = np.zeros(0, dtype=np.int64)
+
+        # filter the gt classes not used in training
+        ann_info = self._remove_dontcare(ann_info)
+        gt_bboxes_3d = LiDARInstance3DBoxes(ann_info['gt_bboxes_3d'])
+        ann_info['gt_bboxes_3d'] = gt_bboxes_3d
+        return ann_info
+```
 
-   ```python
-   dataset_A_train = dict(
-       type='Dataset_A',
-       ann_file = ['anno_file_1', 'anno_file_2'],
-       pipeline=train_pipeline
-   )
-   ```
+After the data pre-processing, there are two steps for users to train the customized new dataset:
 
-   If the concatenated dataset is used for test or evaluation, this manner supports to evaluate each dataset separately. To test the concatenated datasets as a whole, you can set `separate_eval=False` as below.
+1. Modify the config file for using the customized dataset.
+2. Check the annotations of the customized dataset.
 
-   ```python
-   dataset_A_train = dict(
-       type='Dataset_A',
-       ann_file = ['anno_file_1', 'anno_file_2'],
-       separate_eval=False,
-       pipeline=train_pipeline
-   )
-   ```
+Here we take training PointPillars on customized dataset as an example:
 
-2. In case the dataset you want to concatenate is different, you can concatenate the dataset configs like the following.
+### Prepare a config
 
-   ```python
-   dataset_A_train = dict()
-   dataset_B_train = dict()
+Here we demonstrate a config sample for pure point cloud training:
 
-   data = dict(
-       imgs_per_gpu=2,
-       workers_per_gpu=2,
-       train = [
-           dataset_A_train,
-           dataset_B_train
-       ],
-       val = dataset_A_val,
-       test = dataset_A_test
-       )
-   ```
+#### Prepare dataset config
 
-   If the concatenated dataset is used for test or evaluation, this manner also supports to evaluate each dataset separately.
+In `configs/_base_/datasets/custom.py`:
 
-3. We also support to define `ConcatDataset` explicitly as the following.
+```python
+# dataset settings
+dataset_type = 'MyDataset'
+data_root = 'data/custom/'
+class_names = ['Pedestrian', 'Cyclist', 'Car']  # replace with your dataset class
+point_cloud_range = [0, -40, -3, 70.4, 40, 1]  # adjust according to your dataset
+input_modality = dict(use_lidar=True, use_camera=False)
+metainfo = dict(CLASSES=class_names)
+
+train_pipeline = [
+    dict(
+        type='LoadPointsFromFile',
+        coord_type='LIDAR',
+        load_dim=4,  # replace with your point cloud data dimension
+        use_dim=4),  # replace with the actual dimension used in training and inference
+    dict(
+        type='LoadAnnotations3D',
+        with_bbox_3d=True,
+        with_label_3d=True),
+    dict(
+        type='ObjectNoise',
+        num_try=100,
+        translation_std=[1.0, 1.0, 0.5],
+        global_rot_range=[0.0, 0.0],
+        rot_range=[-0.78539816, 0.78539816]),
+    dict(type='RandomFlip3D', flip_ratio_bev_horizontal=0.5),
+    dict(
+        type='GlobalRotScaleTrans',
+        rot_range=[-0.78539816, 0.78539816],
+        scale_ratio_range=[0.95, 1.05]),
+    dict(type='PointsRangeFilter', point_cloud_range=point_cloud_range),
+    dict(type='ObjectRangeFilter', point_cloud_range=point_cloud_range),
+    dict(type='PointShuffle'),
+    dict(
+        type='Pack3DDetInputs',
+        keys=['points', 'gt_bboxes_3d', 'gt_labels_3d'])
+]
+test_pipeline = [
+    dict(
+        type='LoadPointsFromFile',
+        coord_type='LIDAR',
+        load_dim=4,  # replace with your point cloud data dimension
+        use_dim=4),
+    dict(type='Pack3DDetInputs', keys=['points'])
+]
+# construct a pipeline for data and gt loading in show function
+eval_pipeline = [
+    dict(type='LoadPointsFromFile', coord_type='LIDAR', load_dim=4, use_dim=4),
+    dict(type='Pack3DDetInputs', keys=['points']),
+]
+train_dataloader = dict(
+    batch_size=6,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
+        type='RepeatDataset',
+        times=2,
+        dataset=dict(
+            type=dataset_type,
+            data_root=data_root,
+            ann_file='custom_infos_train.pkl', # specify your training pkl info
+            data_prefix=dict(pts='points'),
+            pipeline=train_pipeline,
+            modality=input_modality,
+            test_mode=False,
+            metainfo=metainfo,
+            box_type_3d='LiDAR')))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=1,
+    persistent_workers=True,
+    drop_last=False,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(pts='points'),
+        ann_file='custom_infos_val.pkl', # specify your validation pkl info
+        pipeline=test_pipeline,
+        modality=input_modality,
+        test_mode=True,
+        metainfo=metainfo,
+        box_type_3d='LiDAR'))
+val_evaluator = dict(
+    type='KittiMetric',
+    ann_file=data_root + 'custom_infos_val.pkl', # specify your validation pkl info
+    metric='bbox')
+```
 
-   ```python
-   dataset_A_val = dict()
-   dataset_B_val = dict()
+#### Prepare model config
 
-   data = dict(
-       imgs_per_gpu=2,
-       workers_per_gpu=2,
-       train=dataset_A_train,
-       val=dict(
-           type='ConcatDataset',
-           datasets=[dataset_A_val, dataset_B_val],
-           separate_eval=False))
-   ```
+For voxel-based detectors such as SECOND, PointPillars and CenterPoint, the point cloud range and voxel size should be adjusted according to your dataset.
+Theoretically, `voxel_size` is linked to the setting of `point_cloud_range`. Setting a smaller `voxel_size` will increase the voxel num and the corresponding memory consumption. In addition, the following issues need to be noted:
 
-   This manner allows users to evaluate all the datasets as a single one by setting `separate_eval=False`.
+If the `point_cloud_range` and `voxel_size` are set to be `[0, -40, -3, 70.4, 40, 1]` and `[0.05, 0.05, 0.1]` respectively, then the shape of intermediate feature map should be `[(1-(-3))/0.1+1, (40-(-40))/0.05, (70.4-0)/0.05]=[41, 1600, 1408]`. When changing `point_cloud_range`, remember to change the shape of intermediate feature map in `middel_encoder` according to the `voxel_size`.
 
-**Note:**
+Regarding the setting of `anchor_range`, it is generally adjusted according to dataset. Note that `z` value needs to be adjusted accordingly to the position of the point cloud, please refer to this [issue](https://github.com/open-mmlab/mmdetection3d/issues/986).
 
-1. The option `separate_eval=False` assumes the datasets use `self.data_infos` during evaluation. Therefore, COCO datasets do not support this behavior since COCO datasets do not fully rely on `self.data_infos` for evaluation. Combining different types of datasets and evaluating them as a whole is not tested thus is not suggested.
-2. Evaluating `ClassBalancedDataset` and `RepeatDataset` is not supported thus evaluating concatenated datasets of these types is also not supported.
+Regarding the setting of `anchor_size`, it is usually necessary to count the average length, width and height of objects in the entire training dataset as `anchor_size` to obtain the best results.
 
-A more complex example that repeats `Dataset_A` and `Dataset_B` by N and M times, respectively, and then concatenates the repeated datasets is as the following.
+In `configs/_base_/models/pointpillars_hv_secfpn_custom.py`:
 
 ```python
-dataset_A_train = dict(
-    type='RepeatDataset',
-    times=N,
-    dataset=dict(
-        type='Dataset_A',
-        ...
-        pipeline=train_pipeline
-    )
-)
-dataset_A_val = dict(
-    ...
-    pipeline=test_pipeline
-)
-dataset_A_test = dict(
-    ...
-    pipeline=test_pipeline
-)
-dataset_B_train = dict(
-    type='RepeatDataset',
-    times=M,
-    dataset=dict(
-        type='Dataset_B',
-        ...
-        pipeline=train_pipeline
-    )
-)
-data = dict(
-    imgs_per_gpu=2,
-    workers_per_gpu=2,
-    train = [
-        dataset_A_train,
-        dataset_B_train
-    ],
-    val = dataset_A_val,
-    test = dataset_A_test
-)
-
+voxel_size = [0.16, 0.16, 4]  # adjust according to your dataset
+point_cloud_range = [0, -39.68, -3, 69.12, 39.68, 1]  # adjust according to your dataset
+model = dict(
+    type='VoxelNet',
+    data_preprocessor=dict(
+        type='Det3DDataPreprocessor',
+        voxel=True,
+        voxel_layer=dict(
+            max_num_points=32,
+            point_cloud_range=point_cloud_range,
+            voxel_size=voxel_size,
+            max_voxels=(16000, 40000))),
+    voxel_encoder=dict(
+        type='PillarFeatureNet',
+        in_channels=4,
+        feat_channels=[64],
+        with_distance=False,
+        voxel_size=voxel_size,
+        point_cloud_range=point_cloud_range),
+    # the `output_shape` should be adjusted according to `point_cloud_range`
+    # and `voxel_size`
+    middle_encoder=dict(
+        type='PointPillarsScatter', in_channels=64, output_shape=[496, 432]),
+    backbone=dict(
+        type='SECOND',
+        in_channels=64,
+        layer_nums=[3, 5, 5],
+        layer_strides=[2, 2, 2],
+        out_channels=[64, 128, 256]),
+    neck=dict(
+        type='SECONDFPN',
+        in_channels=[64, 128, 256],
+        upsample_strides=[1, 2, 4],
+        out_channels=[128, 128, 128]),
+    bbox_head=dict(
+        type='Anchor3DHead',
+        num_classes=3,
+        in_channels=384,
+        feat_channels=384,
+        use_direction_classifier=True,
+        assign_per_class=True,
+        # adjust the `ranges` and `sizes` according to your dataset
+        anchor_generator=dict(
+            type='AlignedAnchor3DRangeGenerator',
+            ranges=[
+                [0, -39.68, -0.6, 69.12, 39.68, -0.6],
+                [0, -39.68, -0.6, 69.12, 39.68, -0.6],
+                [0, -39.68, -1.78, 69.12, 39.68, -1.78],
+            ],
+            sizes=[[0.8, 0.6, 1.73], [1.76, 0.6, 1.73], [3.9, 1.6, 1.56]],
+            rotations=[0, 1.57],
+            reshape_out=False),
+        diff_rad_by_sin=True,
+        bbox_coder=dict(type='DeltaXYZWLHRBBoxCoder'),
+        loss_cls=dict(
+            type='mmdet.FocalLoss',
+            use_sigmoid=True,
+            gamma=2.0,
+            alpha=0.25,
+            loss_weight=1.0),
+        loss_bbox=dict(
+            type='mmdet.SmoothL1Loss', beta=1.0 / 9.0, loss_weight=2.0),
+        loss_dir=dict(
+            type='mmdet.CrossEntropyLoss', use_sigmoid=False,
+            loss_weight=0.2)),
+    # model training and testing settings
+    train_cfg=dict(
+        assigner=[
+            dict(  # for Pedestrian
+                type='Max3DIoUAssigner',
+                iou_calculator=dict(type='mmdet3d.BboxOverlapsNearest3D'),
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.35,
+                min_pos_iou=0.35,
+                ignore_iof_thr=-1),
+            dict(  # for Cyclist
+                type='Max3DIoUAssigner',
+                iou_calculator=dict(type='mmdet3d.BboxOverlapsNearest3D'),
+                pos_iou_thr=0.5,
+                neg_iou_thr=0.35,
+                min_pos_iou=0.35,
+                ignore_iof_thr=-1),
+            dict(  # for Car
+                type='Max3DIoUAssigner',
+                iou_calculator=dict(type='mmdet3d.BboxOverlapsNearest3D'),
+                pos_iou_thr=0.6,
+                neg_iou_thr=0.45,
+                min_pos_iou=0.45,
+                ignore_iof_thr=-1),
+        ],
+        allowed_border=0,
+        pos_weight=-1,
+        debug=False),
+    test_cfg=dict(
+        use_rotate_nms=True,
+        nms_across_levels=False,
+        nms_thr=0.01,
+        score_thr=0.1,
+        min_bbox_size=0,
+        nms_pre=100,
+        max_num=50))
 ```
 
-## Modify Dataset Classes
+#### Prepare overall config
 
-With existing dataset types, we can modify the class names of them to train subset of the annotations.
-For example, if you want to train only three classes of the current dataset,
-you can modify the classes of dataset.
-The dataset will filter out the ground truth boxes of other classes automatically.
+We combine all the configs above in `configs/pointpillars/pointpillars_hv_secfpn_8xb6_custom.py`:
 
 ```python
-classes = ('person', 'bicycle', 'car')
-data = dict(
-    train=dict(classes=classes),
-    val=dict(classes=classes),
-    test=dict(classes=classes))
+_base_ = [
+    '../_base_/models/pointpillars_hv_secfpn_custom.py',
+    '../_base_/datasets/custom.py',
+    '../_base_/schedules/cyclic-40e.py', '../_base_/default_runtime.py'
+]
 ```
 
-MMDetection V2.0 also supports to read the classes from a file, which is common in real applications.
-For example, assume the `classes.txt` contains the name of classes as the following.
+#### Visualize your dataset (optional)
 
-```
-person
-bicycle
-car
-```
+To valiate whether your prepared data and config are correct, it's highly recommended to use `tools/browse_dataest.py` script
+to visualize your dataset and annotations before training and validation, more details refer to the [visualization](https://github.com/open-mmlab/mmdetection3d/blob/dev-1.x/docs/en/user_guides/visualization.md/) doc.
+s
 
-Users can set the classes as a file path, the dataset will load it and convert it to a list automatically.
+## Evaluation
 
-```python
-classes = 'path/to/classes.txt'
-data = dict(
-    train=dict(classes=classes),
-    val=dict(classes=classes),
-    test=dict(classes=classes))
-```
+Once the data and config have been prepared, you can directly run the training/testing script following our doc.
 
-**Note** (related to MMDetection):
+**Note**: we only provide an implementation for KITTI style evaluation for the customized dataset. It should be included in the dataset config:
 
-- Before MMDetection v2.5.0, the dataset will filter out the empty GT images automatically if the classes are set and there is no way to disable that through config. This is an undesirable behavior and introduces confusion because if the classes are not set, the dataset only filter the empty GT images when `filter_empty_gt=True` and `test_mode=False`. After MMDetection v2.5.0, we decouple the image filtering process and the classes modification, i.e., the dataset will only filter empty GT images when `filter_empty_gt=True` and `test_mode=False`, no matter whether the classes are set. Thus, setting the classes only influences the annotations of classes used for training and users could decide whether to filter empty GT images by themselves.
-- Since the middle format only has box labels and does not contain the class names, when using `CustomDataset`, users cannot filter out the empty GT images through configs but only do this offline.
-- The features for setting dataset classes and dataset filtering will be refactored to be more user-friendly in the future (depends on the progress).
+```python
+val_evaluator = dict(
+    type='KittiMetric',
+    ann_file=data_root + 'custom_infos_val.pkl', # specify your validation pkl info
+    metric='bbox')
+```