PartA2_car.yaml

CLASS_NAMES: ['Car']

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

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

    TEST:
        INFO_PATH: [
            data/kitti/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.5]
            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: 5
        VOXEL_SIZE: [0.05, 0.05, 0.1]


MODEL:
    NAME: PartA2_net
    VFE:
        NAME: MeanVoxelFeatureExtractor
        ARGS: {}

    RPN:
        PARAMS_FIXED: False  # DO NOT USE THIS
        BACKBONE:
            NAME: UNetV2
            SEG_MASK_SCORE_THRESH: 0.3
            ARGS: {}
            TARGET_CONFIG:
                GENERATED_ON: dataset  # dataset, head_cpu, head_gpu
                GT_EXTEND_WIDTH: 0.2
                MEAN_SIZE: {
                    'Car': [1.6, 3.9, 1.56],
                    'Pedestrian': [0.6, 0.8, 1.73],
                    'Cyclist': [0.6, 1.76, 1.73]
                }

        RPN_HEAD:
            NAME: RPNV2
            ARGS: {
                'use_norm': True,
                'concat_input': False,
                'num_input_features': 256,
                'layer_nums': [5, 5],
                'layer_strides': [1, 2],
                'num_filters': [128, 256],
                'upsample_strides': [1, 2],
                'num_upsample_filters': [256, 256],
                '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: 8
                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:
        NAME: SpConvRCNN
        ENABLED: True
        NUM_POINT_FEATURES: 16
        ROI_AWARE_POOL_SIZE: 14
        SHARED_FC: [256, 512, 512, 512]
        CLS_FC: [256, 256]
        REG_FC: [256, 256]
        DP_RATIO: 0.3

        TARGET_CONFIG:
            BOX_CODER: ResidualCoder
            ROI_PER_IMAGE: 128
            FG_RATIO: 0.5
            HARD_BG_RATIO: 0.8

            CLS_SCORE_TYPE: roi_iou

            CLS_FG_THRESH: 0.75
            CLS_BG_THRESH: 0.25
            CLS_BG_THRESH_LO: 0.1

            REG_FG_THRESH: 0.55

    LOSSES:
        RPN_REG_LOSS: smooth-l1
        RCNN_CLS_LOSS: BinaryCrossEntropy
        RCNN_REG_LOSS: smooth-l1
        CORNER_LOSS_REGULARIZATION: True
        LOSS_WEIGHTS: {
            'rpn_cls_weight': 1.0,
            'rpn_loc_weight': 2.0,
            'rpn_dir_weight': 0.2,

            'rcnn_cls_weight': 1.0,
            'rcnn_reg_weight': 1.0,
            'rcnn_corner_weight': 1.0,
            'code_weights': [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
        }


    TRAIN:
        SPLIT: train
        NMS_PRE_MAXSIZE: 9000
        NMS_POST_MAXSIZE: 512
        RPN_NMS_THRESH: 0.8

        RPN_NMS_TYPE: nms_gpu

        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: [40, 60, 70]
            LR_DECAY: 0.1
            LR_CLIP: 0.0000001

            LR_WARMUP: False
            WARMUP_EPOCH: 1

            GRAD_NORM_CLIP: 10

    TEST:
        SPLIT: val
        NMS_PRE_MAXSIZE: 1024
        NMS_POST_MAXSIZE: 100
        RPN_NMS_THRESH: 0.7
        RPN_NMS_TYPE: nms_gpu

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

        NMS_PRE_MAXSIZE_LAST: 1024
        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]
        }