GenAD/with_hlc/20260205_035946.log

2026-02-05 03:59:46,513 - mmdet - INFO - Environment info:
------------------------------------------------------------
MMCV: 0.0.1
------------------------------------------------------------

2026-02-05 03:59:47,507 - mmdet - INFO - Distributed training: True
2026-02-05 03:59:48,516 - mmdet - INFO - Config:
point_cloud_range = [-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]
class_names = [
    'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
    'traffic_light', 'pedestrian', 'others'
]
dataset_type = 'B2D_VAD_Dataset'
data_root = 'data/bench2drive'
input_modality = dict(
    use_lidar=False,
    use_camera=True,
    use_radar=False,
    use_map=False,
    use_external=True)
file_client_args = dict(backend='disk')
train_pipeline = [
    dict(type='LoadMultiViewImageFromFiles', to_float32=True),
    dict(type='PhotoMetricDistortionMultiViewImage'),
    dict(
        type='LoadAnnotations3D',
        with_bbox_3d=True,
        with_label_3d=True,
        with_attr_label=True),
    dict(
        type='VADObjectRangeFilter',
        point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]),
    dict(
        type='VADObjectNameFilter',
        classes=[
            'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
            'traffic_light', 'pedestrian', 'others'
        ]),
    dict(
        type='NormalizeMultiviewImage',
        mean=[123.675, 116.28, 103.53],
        std=[58.395, 57.12, 57.375],
        to_rgb=True),
    dict(type='RandomScaleImageMultiViewImage', scales=[0.8]),
    dict(type='PadMultiViewImage', size_divisor=32),
    dict(
        type='VADFormatBundle3D',
        class_names=[
            'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
            'traffic_light', 'pedestrian', 'others'
        ],
        with_ego=True),
    dict(
        type='CustomCollect3D',
        keys=[
            'gt_bboxes_3d', 'gt_labels_3d', 'img', 'ego_his_trajs',
            'gt_attr_labels', 'ego_fut_trajs', 'ego_fut_masks', 'ego_fut_cmd',
            'ego_lcf_feat'
        ])
]
test_pipeline = [
    dict(type='LoadMultiViewImageFromFiles', to_float32=True),
    dict(
        type='LoadAnnotations3D',
        with_bbox_3d=True,
        with_label_3d=True,
        with_attr_label=True),
    dict(
        type='VADObjectRangeFilter',
        point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]),
    dict(
        type='VADObjectNameFilter',
        classes=[
            'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
            'traffic_light', 'pedestrian', 'others'
        ]),
    dict(
        type='NormalizeMultiviewImage',
        mean=[123.675, 116.28, 103.53],
        std=[58.395, 57.12, 57.375],
        to_rgb=True),
    dict(
        type='MultiScaleFlipAug3D',
        img_scale=(1600, 900),
        pts_scale_ratio=1,
        flip=False,
        transforms=[
            dict(type='RandomScaleImageMultiViewImage', scales=[0.8]),
            dict(type='PadMultiViewImage', size_divisor=32),
            dict(
                type='VADFormatBundle3D',
                class_names=[
                    'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                    'traffic_cone', 'traffic_light', 'pedestrian', 'others'
                ],
                with_label=False,
                with_ego=True),
            dict(
                type='CustomCollect3D',
                keys=[
                    'gt_bboxes_3d', 'gt_labels_3d', 'img', 'fut_valid_flag',
                    'ego_his_trajs', 'ego_fut_trajs', 'ego_fut_masks',
                    'ego_fut_cmd', 'ego_lcf_feat', 'gt_attr_labels'
                ])
        ])
]
eval_pipeline = [
    dict(
        type='LoadPointsFromFile',
        coord_type='LIDAR',
        load_dim=5,
        use_dim=5,
        file_client_args=dict(backend='disk')),
    dict(
        type='LoadPointsFromMultiSweeps',
        sweeps_num=10,
        file_client_args=dict(backend='disk')),
    dict(
        type='DefaultFormatBundle3D',
        class_names=[
            'car', 'truck', 'trailer', 'bus', 'construction_vehicle',
            'bicycle', 'motorcycle', 'pedestrian', 'traffic_cone', 'barrier'
        ],
        with_label=False),
    dict(type='Collect3D', keys=['points'])
]
data = dict(
    samples_per_gpu=1,
    workers_per_gpu=4,
    train=dict(
        type='B2D_VAD_Dataset',
        data_root='data/bench2drive',
        ann_file='data/infos/b2d_infos_train.pkl',
        pipeline=[
            dict(type='LoadMultiViewImageFromFiles', to_float32=True),
            dict(type='PhotoMetricDistortionMultiViewImage'),
            dict(
                type='LoadAnnotations3D',
                with_bbox_3d=True,
                with_label_3d=True,
                with_attr_label=True),
            dict(
                type='VADObjectRangeFilter',
                point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]),
            dict(
                type='VADObjectNameFilter',
                classes=[
                    'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                    'traffic_cone', 'traffic_light', 'pedestrian', 'others'
                ]),
            dict(
                type='NormalizeMultiviewImage',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(type='RandomScaleImageMultiViewImage', scales=[0.8]),
            dict(type='PadMultiViewImage', size_divisor=32),
            dict(
                type='VADFormatBundle3D',
                class_names=[
                    'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                    'traffic_cone', 'traffic_light', 'pedestrian', 'others'
                ],
                with_ego=True),
            dict(
                type='CustomCollect3D',
                keys=[
                    'gt_bboxes_3d', 'gt_labels_3d', 'img', 'ego_his_trajs',
                    'gt_attr_labels', 'ego_fut_trajs', 'ego_fut_masks',
                    'ego_fut_cmd', 'ego_lcf_feat'
                ])
        ],
        classes=[
            'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
            'traffic_light', 'pedestrian', 'others'
        ],
        modality=dict(
            use_lidar=False,
            use_camera=True,
            use_radar=False,
            use_map=False,
            use_external=True),
        test_mode=False,
        box_type_3d='LiDAR',
        name_mapping=dict({
            'vehicle.bh.crossbike':
            'bicycle',
            'vehicle.diamondback.century':
            'bicycle',
            'vehicle.gazelle.omafiets':
            'bicycle',
            'vehicle.chevrolet.impala':
            'car',
            'vehicle.dodge.charger_2020':
            'car',
            'vehicle.dodge.charger_police':
            'car',
            'vehicle.dodge.charger_police_2020':
            'car',
            'vehicle.lincoln.mkz_2017':
            'car',
            'vehicle.lincoln.mkz_2020':
            'car',
            'vehicle.mini.cooper_s_2021':
            'car',
            'vehicle.mercedes.coupe_2020':
            'car',
            'vehicle.ford.mustang':
            'car',
            'vehicle.nissan.patrol_2021':
            'car',
            'vehicle.audi.tt':
            'car',
            'vehicle.audi.etron':
            'car',
            'vehicle.ford.crown':
            'car',
            'vehicle.tesla.model3':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/FordCrown/SM_FordCrown_parked.SM_FordCrown_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Charger/SM_ChargerParked.SM_ChargerParked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Lincoln/SM_LincolnParked.SM_LincolnParked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/MercedesCCC/SM_MercedesCCC_Parked.SM_MercedesCCC_Parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Mini2021/SM_Mini2021_parked.SM_Mini2021_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/NissanPatrol2021/SM_NissanPatrol2021_parked.SM_NissanPatrol2021_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/TeslaM3/SM_TeslaM3_parked.SM_TeslaM3_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/VolkswagenT2/SM_VolkswagenT2_2021_Parked.SM_VolkswagenT2_2021_Parked':
            'van',
            'vehicle.ford.ambulance':
            'van',
            'vehicle.carlamotors.firetruck':
            'truck',
            'traffic.speed_limit.30':
            'traffic_sign',
            'traffic.speed_limit.40':
            'traffic_sign',
            'traffic.speed_limit.50':
            'traffic_sign',
            'traffic.speed_limit.60':
            'traffic_sign',
            'traffic.speed_limit.90':
            'traffic_sign',
            'traffic.speed_limit.120':
            'traffic_sign',
            'traffic.stop':
            'traffic_sign',
            'traffic.yield':
            'traffic_sign',
            'traffic.traffic_light':
            'traffic_light',
            'static.prop.warningconstruction':
            'traffic_cone',
            'static.prop.warningaccident':
            'traffic_cone',
            'static.prop.trafficwarning':
            'traffic_cone',
            'static.prop.constructioncone':
            'traffic_cone',
            'walker.pedestrian.0001':
            'pedestrian',
            'walker.pedestrian.0004':
            'pedestrian',
            'walker.pedestrian.0005':
            'pedestrian',
            'walker.pedestrian.0007':
            'pedestrian',
            'walker.pedestrian.0013':
            'pedestrian',
            'walker.pedestrian.0014':
            'pedestrian',
            'walker.pedestrian.0017':
            'pedestrian',
            'walker.pedestrian.0018':
            'pedestrian',
            'walker.pedestrian.0019':
            'pedestrian',
            'walker.pedestrian.0020':
            'pedestrian',
            'walker.pedestrian.0022':
            'pedestrian',
            'walker.pedestrian.0025':
            'pedestrian',
            'walker.pedestrian.0035':
            'pedestrian',
            'walker.pedestrian.0041':
            'pedestrian',
            'walker.pedestrian.0046':
            'pedestrian',
            'walker.pedestrian.0047':
            'pedestrian',
            'static.prop.dirtdebris01':
            'others',
            'static.prop.dirtdebris02':
            'others'
        }),
        map_root='data/bench2drive/maps',
        map_file='data/infos/b2d_map_infos.pkl',
        bev_size=(100, 100),
        queue_length=3,
        past_frames=2,
        future_frames=6,
        point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
        polyline_points_num=20),
    val=dict(
        type='B2D_VAD_Dataset',
        ann_file='data/infos/b2d_infos_val.pkl',
        pipeline=[
            dict(type='LoadMultiViewImageFromFiles', to_float32=True),
            dict(
                type='LoadAnnotations3D',
                with_bbox_3d=True,
                with_label_3d=True,
                with_attr_label=True),
            dict(
                type='VADObjectRangeFilter',
                point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]),
            dict(
                type='VADObjectNameFilter',
                classes=[
                    'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                    'traffic_cone', 'traffic_light', 'pedestrian', 'others'
                ]),
            dict(
                type='NormalizeMultiviewImage',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(
                type='MultiScaleFlipAug3D',
                img_scale=(1600, 900),
                pts_scale_ratio=1,
                flip=False,
                transforms=[
                    dict(type='RandomScaleImageMultiViewImage', scales=[0.8]),
                    dict(type='PadMultiViewImage', size_divisor=32),
                    dict(
                        type='VADFormatBundle3D',
                        class_names=[
                            'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                            'traffic_cone', 'traffic_light', 'pedestrian',
                            'others'
                        ],
                        with_label=False,
                        with_ego=True),
                    dict(
                        type='CustomCollect3D',
                        keys=[
                            'gt_bboxes_3d', 'gt_labels_3d', 'img',
                            'fut_valid_flag', 'ego_his_trajs', 'ego_fut_trajs',
                            'ego_fut_masks', 'ego_fut_cmd', 'ego_lcf_feat',
                            'gt_attr_labels'
                        ])
                ])
        ],
        classes=[
            'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
            'traffic_light', 'pedestrian', 'others'
        ],
        modality=dict(
            use_lidar=False,
            use_camera=True,
            use_radar=False,
            use_map=False,
            use_external=True),
        test_mode=True,
        box_type_3d='LiDAR',
        data_root='data/bench2drive',
        name_mapping=dict({
            'vehicle.bh.crossbike':
            'bicycle',
            'vehicle.diamondback.century':
            'bicycle',
            'vehicle.gazelle.omafiets':
            'bicycle',
            'vehicle.chevrolet.impala':
            'car',
            'vehicle.dodge.charger_2020':
            'car',
            'vehicle.dodge.charger_police':
            'car',
            'vehicle.dodge.charger_police_2020':
            'car',
            'vehicle.lincoln.mkz_2017':
            'car',
            'vehicle.lincoln.mkz_2020':
            'car',
            'vehicle.mini.cooper_s_2021':
            'car',
            'vehicle.mercedes.coupe_2020':
            'car',
            'vehicle.ford.mustang':
            'car',
            'vehicle.nissan.patrol_2021':
            'car',
            'vehicle.audi.tt':
            'car',
            'vehicle.audi.etron':
            'car',
            'vehicle.ford.crown':
            'car',
            'vehicle.tesla.model3':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/FordCrown/SM_FordCrown_parked.SM_FordCrown_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Charger/SM_ChargerParked.SM_ChargerParked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Lincoln/SM_LincolnParked.SM_LincolnParked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/MercedesCCC/SM_MercedesCCC_Parked.SM_MercedesCCC_Parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Mini2021/SM_Mini2021_parked.SM_Mini2021_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/NissanPatrol2021/SM_NissanPatrol2021_parked.SM_NissanPatrol2021_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/TeslaM3/SM_TeslaM3_parked.SM_TeslaM3_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/VolkswagenT2/SM_VolkswagenT2_2021_Parked.SM_VolkswagenT2_2021_Parked':
            'van',
            'vehicle.ford.ambulance':
            'van',
            'vehicle.carlamotors.firetruck':
            'truck',
            'traffic.speed_limit.30':
            'traffic_sign',
            'traffic.speed_limit.40':
            'traffic_sign',
            'traffic.speed_limit.50':
            'traffic_sign',
            'traffic.speed_limit.60':
            'traffic_sign',
            'traffic.speed_limit.90':
            'traffic_sign',
            'traffic.speed_limit.120':
            'traffic_sign',
            'traffic.stop':
            'traffic_sign',
            'traffic.yield':
            'traffic_sign',
            'traffic.traffic_light':
            'traffic_light',
            'static.prop.warningconstruction':
            'traffic_cone',
            'static.prop.warningaccident':
            'traffic_cone',
            'static.prop.trafficwarning':
            'traffic_cone',
            'static.prop.constructioncone':
            'traffic_cone',
            'walker.pedestrian.0001':
            'pedestrian',
            'walker.pedestrian.0004':
            'pedestrian',
            'walker.pedestrian.0005':
            'pedestrian',
            'walker.pedestrian.0007':
            'pedestrian',
            'walker.pedestrian.0013':
            'pedestrian',
            'walker.pedestrian.0014':
            'pedestrian',
            'walker.pedestrian.0017':
            'pedestrian',
            'walker.pedestrian.0018':
            'pedestrian',
            'walker.pedestrian.0019':
            'pedestrian',
            'walker.pedestrian.0020':
            'pedestrian',
            'walker.pedestrian.0022':
            'pedestrian',
            'walker.pedestrian.0025':
            'pedestrian',
            'walker.pedestrian.0035':
            'pedestrian',
            'walker.pedestrian.0041':
            'pedestrian',
            'walker.pedestrian.0046':
            'pedestrian',
            'walker.pedestrian.0047':
            'pedestrian',
            'static.prop.dirtdebris01':
            'others',
            'static.prop.dirtdebris02':
            'others'
        }),
        map_root='data/bench2drive/maps',
        map_file='data/infos/b2d_map_infos.pkl',
        bev_size=(100, 100),
        queue_length=3,
        past_frames=2,
        future_frames=6,
        point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
        polyline_points_num=20,
        eval_cfg=dict(
            dist_ths=[0.5, 1.0, 2.0, 4.0],
            dist_th_tp=2.0,
            min_recall=0.1,
            min_precision=0.1,
            mean_ap_weight=5,
            class_names=[
                'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                'traffic_cone', 'traffic_light', 'pedestrian'
            ],
            tp_metrics=['trans_err', 'scale_err', 'orient_err', 'vel_err'],
            err_name_maping=dict(
                trans_err='mATE',
                scale_err='mASE',
                orient_err='mAOE',
                vel_err='mAVE',
                attr_err='mAAE'),
            class_range=dict(
                car=(50, 50),
                van=(50, 50),
                truck=(50, 50),
                bicycle=(40, 40),
                traffic_sign=(30, 30),
                traffic_cone=(30, 30),
                traffic_light=(30, 30),
                pedestrian=(40, 40)))),
    test=dict(
        type='B2D_VAD_Dataset',
        data_root='data/bench2drive',
        ann_file='data/infos/b2d_infos_val.pkl',
        pipeline=[
            dict(type='LoadMultiViewImageFromFiles', to_float32=True),
            dict(
                type='LoadAnnotations3D',
                with_bbox_3d=True,
                with_label_3d=True,
                with_attr_label=True),
            dict(
                type='VADObjectRangeFilter',
                point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]),
            dict(
                type='VADObjectNameFilter',
                classes=[
                    'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                    'traffic_cone', 'traffic_light', 'pedestrian', 'others'
                ]),
            dict(
                type='NormalizeMultiviewImage',
                mean=[123.675, 116.28, 103.53],
                std=[58.395, 57.12, 57.375],
                to_rgb=True),
            dict(
                type='MultiScaleFlipAug3D',
                img_scale=(1600, 900),
                pts_scale_ratio=1,
                flip=False,
                transforms=[
                    dict(type='RandomScaleImageMultiViewImage', scales=[0.8]),
                    dict(type='PadMultiViewImage', size_divisor=32),
                    dict(
                        type='VADFormatBundle3D',
                        class_names=[
                            'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                            'traffic_cone', 'traffic_light', 'pedestrian',
                            'others'
                        ],
                        with_label=False,
                        with_ego=True),
                    dict(
                        type='CustomCollect3D',
                        keys=[
                            'gt_bboxes_3d', 'gt_labels_3d', 'img',
                            'fut_valid_flag', 'ego_his_trajs', 'ego_fut_trajs',
                            'ego_fut_masks', 'ego_fut_cmd', 'ego_lcf_feat',
                            'gt_attr_labels'
                        ])
                ])
        ],
        classes=[
            'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
            'traffic_light', 'pedestrian', 'others'
        ],
        modality=dict(
            use_lidar=False,
            use_camera=True,
            use_radar=False,
            use_map=False,
            use_external=True),
        test_mode=True,
        box_type_3d='LiDAR',
        name_mapping=dict({
            'vehicle.bh.crossbike':
            'bicycle',
            'vehicle.diamondback.century':
            'bicycle',
            'vehicle.gazelle.omafiets':
            'bicycle',
            'vehicle.chevrolet.impala':
            'car',
            'vehicle.dodge.charger_2020':
            'car',
            'vehicle.dodge.charger_police':
            'car',
            'vehicle.dodge.charger_police_2020':
            'car',
            'vehicle.lincoln.mkz_2017':
            'car',
            'vehicle.lincoln.mkz_2020':
            'car',
            'vehicle.mini.cooper_s_2021':
            'car',
            'vehicle.mercedes.coupe_2020':
            'car',
            'vehicle.ford.mustang':
            'car',
            'vehicle.nissan.patrol_2021':
            'car',
            'vehicle.audi.tt':
            'car',
            'vehicle.audi.etron':
            'car',
            'vehicle.ford.crown':
            'car',
            'vehicle.tesla.model3':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/FordCrown/SM_FordCrown_parked.SM_FordCrown_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Charger/SM_ChargerParked.SM_ChargerParked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Lincoln/SM_LincolnParked.SM_LincolnParked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/MercedesCCC/SM_MercedesCCC_Parked.SM_MercedesCCC_Parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Mini2021/SM_Mini2021_parked.SM_Mini2021_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/NissanPatrol2021/SM_NissanPatrol2021_parked.SM_NissanPatrol2021_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/TeslaM3/SM_TeslaM3_parked.SM_TeslaM3_parked':
            'car',
            '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/VolkswagenT2/SM_VolkswagenT2_2021_Parked.SM_VolkswagenT2_2021_Parked':
            'van',
            'vehicle.ford.ambulance':
            'van',
            'vehicle.carlamotors.firetruck':
            'truck',
            'traffic.speed_limit.30':
            'traffic_sign',
            'traffic.speed_limit.40':
            'traffic_sign',
            'traffic.speed_limit.50':
            'traffic_sign',
            'traffic.speed_limit.60':
            'traffic_sign',
            'traffic.speed_limit.90':
            'traffic_sign',
            'traffic.speed_limit.120':
            'traffic_sign',
            'traffic.stop':
            'traffic_sign',
            'traffic.yield':
            'traffic_sign',
            'traffic.traffic_light':
            'traffic_light',
            'static.prop.warningconstruction':
            'traffic_cone',
            'static.prop.warningaccident':
            'traffic_cone',
            'static.prop.trafficwarning':
            'traffic_cone',
            'static.prop.constructioncone':
            'traffic_cone',
            'walker.pedestrian.0001':
            'pedestrian',
            'walker.pedestrian.0004':
            'pedestrian',
            'walker.pedestrian.0005':
            'pedestrian',
            'walker.pedestrian.0007':
            'pedestrian',
            'walker.pedestrian.0013':
            'pedestrian',
            'walker.pedestrian.0014':
            'pedestrian',
            'walker.pedestrian.0017':
            'pedestrian',
            'walker.pedestrian.0018':
            'pedestrian',
            'walker.pedestrian.0019':
            'pedestrian',
            'walker.pedestrian.0020':
            'pedestrian',
            'walker.pedestrian.0022':
            'pedestrian',
            'walker.pedestrian.0025':
            'pedestrian',
            'walker.pedestrian.0035':
            'pedestrian',
            'walker.pedestrian.0041':
            'pedestrian',
            'walker.pedestrian.0046':
            'pedestrian',
            'walker.pedestrian.0047':
            'pedestrian',
            'static.prop.dirtdebris01':
            'others',
            'static.prop.dirtdebris02':
            'others'
        }),
        map_root='data/bench2drive/maps',
        map_file='data/infos/b2d_map_infos.pkl',
        bev_size=(100, 100),
        queue_length=3,
        past_frames=2,
        future_frames=6,
        point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
        polyline_points_num=20,
        eval_cfg=dict(
            dist_ths=[0.5, 1.0, 2.0, 4.0],
            dist_th_tp=2.0,
            min_recall=0.1,
            min_precision=0.1,
            mean_ap_weight=5,
            class_names=[
                'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                'traffic_cone', 'traffic_light', 'pedestrian'
            ],
            tp_metrics=['trans_err', 'scale_err', 'orient_err', 'vel_err'],
            err_name_maping=dict(
                trans_err='mATE',
                scale_err='mASE',
                orient_err='mAOE',
                vel_err='mAVE',
                attr_err='mAAE'),
            class_range=dict(
                car=(50, 50),
                van=(50, 50),
                truck=(50, 50),
                bicycle=(40, 40),
                traffic_sign=(30, 30),
                traffic_cone=(30, 30),
                traffic_light=(30, 30),
                pedestrian=(40, 40)))),
    shuffler_sampler=dict(type='DistributedGroupSampler'),
    nonshuffler_sampler=dict(type='DistributedSampler'))
evaluation = dict(
    interval=6,
    pipeline=[
        dict(type='LoadMultiViewImageFromFiles', to_float32=True),
        dict(
            type='LoadAnnotations3D',
            with_bbox_3d=True,
            with_label_3d=True,
            with_attr_label=True),
        dict(
            type='VADObjectRangeFilter',
            point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]),
        dict(
            type='VADObjectNameFilter',
            classes=[
                'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                'traffic_cone', 'traffic_light', 'pedestrian', 'others'
            ]),
        dict(
            type='NormalizeMultiviewImage',
            mean=[123.675, 116.28, 103.53],
            std=[58.395, 57.12, 57.375],
            to_rgb=True),
        dict(
            type='MultiScaleFlipAug3D',
            img_scale=(1600, 900),
            pts_scale_ratio=1,
            flip=False,
            transforms=[
                dict(type='RandomScaleImageMultiViewImage', scales=[0.8]),
                dict(type='PadMultiViewImage', size_divisor=32),
                dict(
                    type='VADFormatBundle3D',
                    class_names=[
                        'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                        'traffic_cone', 'traffic_light', 'pedestrian', 'others'
                    ],
                    with_label=False,
                    with_ego=True),
                dict(
                    type='CustomCollect3D',
                    keys=[
                        'gt_bboxes_3d', 'gt_labels_3d', 'img',
                        'fut_valid_flag', 'ego_his_trajs', 'ego_fut_trajs',
                        'ego_fut_masks', 'ego_fut_cmd', 'ego_lcf_feat',
                        'gt_attr_labels'
                    ])
            ])
    ],
    metric='bbox',
    map_metric='chamfer')
checkpoint_config = dict(interval=1, max_keep_ckpts=6)
log_config = dict(
    interval=50,
    hooks=[dict(type='TextLoggerHook'),
           dict(type='TensorboardLoggerHook')])
dist_params = dict(backend='nccl')
log_level = 'INFO'
work_dir = './work_dirs/GenAD_config_b2d'
load_from = None
resume_from = None
workflow = [('train', 1)]
voxel_size = [0.15, 0.15, 4]
img_norm_cfg = dict(
    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
NameMapping = dict({
    'vehicle.bh.crossbike':
    'bicycle',
    'vehicle.diamondback.century':
    'bicycle',
    'vehicle.gazelle.omafiets':
    'bicycle',
    'vehicle.chevrolet.impala':
    'car',
    'vehicle.dodge.charger_2020':
    'car',
    'vehicle.dodge.charger_police':
    'car',
    'vehicle.dodge.charger_police_2020':
    'car',
    'vehicle.lincoln.mkz_2017':
    'car',
    'vehicle.lincoln.mkz_2020':
    'car',
    'vehicle.mini.cooper_s_2021':
    'car',
    'vehicle.mercedes.coupe_2020':
    'car',
    'vehicle.ford.mustang':
    'car',
    'vehicle.nissan.patrol_2021':
    'car',
    'vehicle.audi.tt':
    'car',
    'vehicle.audi.etron':
    'car',
    'vehicle.ford.crown':
    'car',
    'vehicle.tesla.model3':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/FordCrown/SM_FordCrown_parked.SM_FordCrown_parked':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Charger/SM_ChargerParked.SM_ChargerParked':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Lincoln/SM_LincolnParked.SM_LincolnParked':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/MercedesCCC/SM_MercedesCCC_Parked.SM_MercedesCCC_Parked':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/Mini2021/SM_Mini2021_parked.SM_Mini2021_parked':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/NissanPatrol2021/SM_NissanPatrol2021_parked.SM_NissanPatrol2021_parked':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/TeslaM3/SM_TeslaM3_parked.SM_TeslaM3_parked':
    'car',
    '/Game/Carla/Static/Car/4Wheeled/ParkedVehicles/VolkswagenT2/SM_VolkswagenT2_2021_Parked.SM_VolkswagenT2_2021_Parked':
    'van',
    'vehicle.ford.ambulance':
    'van',
    'vehicle.carlamotors.firetruck':
    'truck',
    'traffic.speed_limit.30':
    'traffic_sign',
    'traffic.speed_limit.40':
    'traffic_sign',
    'traffic.speed_limit.50':
    'traffic_sign',
    'traffic.speed_limit.60':
    'traffic_sign',
    'traffic.speed_limit.90':
    'traffic_sign',
    'traffic.speed_limit.120':
    'traffic_sign',
    'traffic.stop':
    'traffic_sign',
    'traffic.yield':
    'traffic_sign',
    'traffic.traffic_light':
    'traffic_light',
    'static.prop.warningconstruction':
    'traffic_cone',
    'static.prop.warningaccident':
    'traffic_cone',
    'static.prop.trafficwarning':
    'traffic_cone',
    'static.prop.constructioncone':
    'traffic_cone',
    'walker.pedestrian.0001':
    'pedestrian',
    'walker.pedestrian.0004':
    'pedestrian',
    'walker.pedestrian.0005':
    'pedestrian',
    'walker.pedestrian.0007':
    'pedestrian',
    'walker.pedestrian.0013':
    'pedestrian',
    'walker.pedestrian.0014':
    'pedestrian',
    'walker.pedestrian.0017':
    'pedestrian',
    'walker.pedestrian.0018':
    'pedestrian',
    'walker.pedestrian.0019':
    'pedestrian',
    'walker.pedestrian.0020':
    'pedestrian',
    'walker.pedestrian.0022':
    'pedestrian',
    'walker.pedestrian.0025':
    'pedestrian',
    'walker.pedestrian.0035':
    'pedestrian',
    'walker.pedestrian.0041':
    'pedestrian',
    'walker.pedestrian.0046':
    'pedestrian',
    'walker.pedestrian.0047':
    'pedestrian',
    'static.prop.dirtdebris01':
    'others',
    'static.prop.dirtdebris02':
    'others'
})
eval_cfg = dict(
    dist_ths=[0.5, 1.0, 2.0, 4.0],
    dist_th_tp=2.0,
    min_recall=0.1,
    min_precision=0.1,
    mean_ap_weight=5,
    class_names=[
        'car', 'van', 'truck', 'bicycle', 'traffic_sign', 'traffic_cone',
        'traffic_light', 'pedestrian'
    ],
    tp_metrics=['trans_err', 'scale_err', 'orient_err', 'vel_err'],
    err_name_maping=dict(
        trans_err='mATE',
        scale_err='mASE',
        orient_err='mAOE',
        vel_err='mAVE',
        attr_err='mAAE'),
    class_range=dict(
        car=(50, 50),
        van=(50, 50),
        truck=(50, 50),
        bicycle=(40, 40),
        traffic_sign=(30, 30),
        traffic_cone=(30, 30),
        traffic_light=(30, 30),
        pedestrian=(40, 40)))
num_classes = 9
map_classes = [
    'Broken', 'Solid', 'SolidSolid', 'Center', 'TrafficLight', 'StopSign'
]
map_num_vec = 100
map_fixed_ptsnum_per_gt_line = 20
map_fixed_ptsnum_per_pred_line = 20
map_eval_use_same_gt_sample_num_flag = True
map_num_classes = 6
past_frames = 2
future_frames = 6
_dim_ = 256
_pos_dim_ = 128
_ffn_dim_ = 512
_num_levels_ = 1
bev_h_ = 100
bev_w_ = 100
queue_length = 3
total_epochs = 6
model = dict(
    type='GenAD',
    use_grid_mask=True,
    video_test_mode=True,
    pretrained=dict(img='ckpts/resnet50-19c8e357.pth'),
    img_backbone=dict(
        type='ResNet',
        depth=50,
        num_stages=4,
        out_indices=(3, ),
        frozen_stages=1,
        norm_cfg=dict(type='BN', requires_grad=False),
        norm_eval=True,
        style='pytorch'),
    img_neck=dict(
        type='FPN',
        in_channels=[2048],
        out_channels=256,
        start_level=0,
        add_extra_convs='on_output',
        num_outs=1,
        relu_before_extra_convs=True),
    pts_bbox_head=dict(
        type='GenADHead',
        map_thresh=0.5,
        dis_thresh=0.2,
        pe_normalization=True,
        tot_epoch=6,
        use_traj_lr_warmup=False,
        query_thresh=0.0,
        query_use_fix_pad=False,
        ego_his_encoder=None,
        ego_lcf_feat_idx=None,
        valid_fut_ts=6,
        ego_fut_mode=6,
        agent_dim=300,
        ego_agent_decoder=dict(
            type='CustomTransformerDecoder',
            num_layers=1,
            return_intermediate=False,
            transformerlayers=dict(
                type='BaseTransformerLayer',
                attn_cfgs=[
                    dict(
                        type='MultiheadAttention',
                        embed_dims=256,
                        num_heads=8,
                        dropout=0.0)
                ],
                feedforward_channels=512,
                ffn_dropout=0.0,
                operation_order=('cross_attn', 'norm', 'ffn', 'norm'))),
        ego_map_decoder=dict(
            type='CustomTransformerDecoder',
            num_layers=1,
            return_intermediate=False,
            transformerlayers=dict(
                type='BaseTransformerLayer',
                attn_cfgs=[
                    dict(
                        type='MultiheadAttention',
                        embed_dims=256,
                        num_heads=8,
                        dropout=0.0)
                ],
                feedforward_channels=512,
                ffn_dropout=0.0,
                operation_order=('cross_attn', 'norm', 'ffn', 'norm'))),
        motion_decoder=dict(
            type='CustomTransformerDecoder',
            num_layers=1,
            return_intermediate=False,
            transformerlayers=dict(
                type='BaseTransformerLayer',
                attn_cfgs=[
                    dict(
                        type='MultiheadAttention',
                        embed_dims=256,
                        num_heads=8,
                        dropout=0.0)
                ],
                feedforward_channels=512,
                ffn_dropout=0.0,
                operation_order=('cross_attn', 'norm', 'ffn', 'norm'))),
        motion_map_decoder=dict(
            type='CustomTransformerDecoder',
            num_layers=1,
            return_intermediate=False,
            transformerlayers=dict(
                type='BaseTransformerLayer',
                attn_cfgs=[
                    dict(
                        type='MultiheadAttention',
                        embed_dims=256,
                        num_heads=8,
                        dropout=0.0)
                ],
                feedforward_channels=512,
                ffn_dropout=0.0,
                operation_order=('cross_attn', 'norm', 'ffn', 'norm'))),
        use_pe=True,
        bev_h=100,
        bev_w=100,
        num_query=300,
        num_classes=9,
        in_channels=256,
        sync_cls_avg_factor=True,
        with_box_refine=True,
        as_two_stage=False,
        map_num_vec=100,
        map_num_classes=6,
        map_num_pts_per_vec=20,
        map_num_pts_per_gt_vec=20,
        map_query_embed_type='instance_pts',
        map_transform_method='minmax',
        map_gt_shift_pts_pattern='v2',
        map_dir_interval=1,
        map_code_size=2,
        map_code_weights=[1.0, 1.0, 1.0, 1.0],
        transformer=dict(
            type='VADPerceptionTransformer',
            map_num_vec=100,
            map_num_pts_per_vec=20,
            rotate_prev_bev=True,
            use_shift=True,
            use_can_bus=True,
            embed_dims=256,
            encoder=dict(
                type='BEVFormerEncoder',
                num_layers=3,
                pc_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
                num_points_in_pillar=4,
                return_intermediate=False,
                transformerlayers=dict(
                    type='BEVFormerLayer',
                    attn_cfgs=[
                        dict(
                            type='TemporalSelfAttention',
                            embed_dims=256,
                            num_levels=1),
                        dict(
                            type='SpatialCrossAttention',
                            pc_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
                            deformable_attention=dict(
                                type='MSDeformableAttention3D',
                                embed_dims=256,
                                num_points=8,
                                num_levels=1),
                            embed_dims=256)
                    ],
                    feedforward_channels=512,
                    ffn_dropout=0.0,
                    operation_order=('self_attn', 'norm', 'cross_attn', 'norm',
                                     'ffn', 'norm'))),
            decoder=dict(
                type='DetectionTransformerDecoder',
                num_layers=3,
                return_intermediate=True,
                transformerlayers=dict(
                    type='DetrTransformerDecoderLayer',
                    attn_cfgs=[
                        dict(
                            type='MultiheadAttention',
                            embed_dims=256,
                            num_heads=8,
                            dropout=0.0),
                        dict(
                            type='CustomMSDeformableAttention',
                            embed_dims=256,
                            num_levels=1)
                    ],
                    feedforward_channels=512,
                    ffn_dropout=0.0,
                    operation_order=('self_attn', 'norm', 'cross_attn', 'norm',
                                     'ffn', 'norm'))),
            map_decoder=dict(
                type='MapDetectionTransformerDecoder',
                num_layers=3,
                return_intermediate=True,
                transformerlayers=dict(
                    type='DetrTransformerDecoderLayer',
                    attn_cfgs=[
                        dict(
                            type='MultiheadAttention',
                            embed_dims=256,
                            num_heads=8,
                            dropout=0.0),
                        dict(
                            type='CustomMSDeformableAttention',
                            embed_dims=256,
                            num_levels=1)
                    ],
                    feedforward_channels=512,
                    ffn_dropout=0.0,
                    operation_order=('self_attn', 'norm', 'cross_attn', 'norm',
                                     'ffn', 'norm')))),
        bbox_coder=dict(
            type='CustomNMSFreeCoder',
            post_center_range=[-20, -35, -10.0, 20, 35, 10.0],
            pc_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
            max_num=100,
            voxel_size=[0.15, 0.15, 4],
            num_classes=9),
        map_bbox_coder=dict(
            type='MapNMSFreeCoder',
            post_center_range=[-20, -35, -20, -35, 20, 35, 20, 35],
            pc_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
            max_num=50,
            voxel_size=[0.15, 0.15, 4],
            num_classes=6),
        positional_encoding=dict(
            type='LearnedPositionalEncoding',
            num_feats=128,
            row_num_embed=100,
            col_num_embed=100),
        loss_cls=dict(
            type='FocalLoss',
            use_sigmoid=True,
            gamma=2.0,
            alpha=0.25,
            loss_weight=2.0),
        loss_bbox=dict(type='L1Loss', loss_weight=0.25),
        loss_traj=dict(type='L1Loss', loss_weight=0.2),
        loss_traj_cls=dict(
            type='FocalLoss',
            use_sigmoid=True,
            gamma=2.0,
            alpha=0.25,
            loss_weight=0.2),
        loss_iou=dict(type='GIoULoss', loss_weight=0.0),
        loss_map_cls=dict(
            type='FocalLoss',
            use_sigmoid=True,
            gamma=2.0,
            alpha=0.25,
            loss_weight=2.0),
        loss_map_bbox=dict(type='L1Loss', loss_weight=0.0),
        loss_map_iou=dict(type='GIoULoss', loss_weight=0.0),
        loss_map_pts=dict(type='PtsL1Loss', loss_weight=1.0),
        loss_map_dir=dict(type='PtsDirCosLoss', loss_weight=0.005),
        loss_plan_reg=dict(type='L1Loss', loss_weight=1.0),
        loss_plan_bound=dict(
            type='PlanMapBoundLoss', loss_weight=1.0, dis_thresh=1.0),
        loss_plan_col=dict(type='PlanCollisionLoss', loss_weight=1.0),
        loss_plan_dir=dict(type='PlanMapDirectionLoss', loss_weight=0.5),
        loss_vae_gen=dict(type='ProbabilisticLoss', loss_weight=1.0)),
    train_cfg=dict(
        pts=dict(
            grid_size=[512, 512, 1],
            voxel_size=[0.15, 0.15, 4],
            point_cloud_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0],
            out_size_factor=4,
            assigner=dict(
                type='HungarianAssigner3D',
                cls_cost=dict(type='FocalLossCost', weight=2.0),
                reg_cost=dict(type='BBox3DL1Cost', weight=0.25),
                iou_cost=dict(type='IoUCost', weight=0.0),
                pc_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]),
            map_assigner=dict(
                type='MapHungarianAssigner3D',
                cls_cost=dict(type='FocalLossCost', weight=2.0),
                reg_cost=dict(
                    type='BBoxL1Cost', weight=0.0, box_format='xywh'),
                iou_cost=dict(type='IoUCost', iou_mode='giou', weight=0.0),
                pts_cost=dict(type='OrderedPtsL1Cost', weight=1.0),
                pc_range=[-15.0, -30.0, -2.0, 15.0, 30.0, 2.0]))))
info_root = 'data/infos'
map_root = 'data/bench2drive/maps'
map_file = 'data/infos/b2d_map_infos.pkl'
ann_file_train = 'data/infos/b2d_infos_train.pkl'
ann_file_val = 'data/infos/b2d_infos_val.pkl'
ann_file_test = 'data/infos/b2d_infos_val.pkl'
inference_only_pipeline = [
    dict(type='LoadMultiViewImageFromFiles', to_float32=True),
    dict(
        type='NormalizeMultiviewImage',
        mean=[123.675, 116.28, 103.53],
        std=[58.395, 57.12, 57.375],
        to_rgb=True),
    dict(type='PadMultiViewImage', size_divisor=32),
    dict(
        type='MultiScaleFlipAug3D',
        img_scale=(1600, 900),
        pts_scale_ratio=1,
        flip=False,
        transforms=[
            dict(type='RandomScaleImageMultiViewImage', scales=[0.8]),
            dict(type='PadMultiViewImage', size_divisor=32),
            dict(
                type='VADFormatBundle3D',
                class_names=[
                    'car', 'van', 'truck', 'bicycle', 'traffic_sign',
                    'traffic_cone', 'traffic_light', 'pedestrian', 'others'
                ],
                with_label=False,
                with_ego=True),
            dict(type='CustomCollect3D', keys=['img', 'ego_fut_cmd'])
        ])
]
optimizer = dict(
    type='AdamW',
    lr=0.0002,
    paramwise_cfg=dict(custom_keys=dict(img_backbone=dict(lr_mult=0.1))),
    weight_decay=0.01)
optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2))
lr_config = dict(
    by_epoch=False,
    policy='CosineAnnealing',
    warmup='linear',
    warmup_iters=500,
    warmup_ratio=0.3333333333333333,
    min_lr_ratio=0.001)
runner = dict(type='EpochBasedRunner', max_epochs=6)
find_unused_parameters = True
custom_hooks = [dict(type='CustomSetEpochInfoHook')]
gpu_ids = range(0, 1)

2026-02-05 03:59:48,517 - mmdet - INFO - Set random seed to 0, deterministic: True
2026-02-05 03:59:49,019 - mmdet - INFO - initialize ResNet with init_cfg {'type': 'Pretrained', 'checkpoint': 'ckpts/resnet50-19c8e357.pth'}
2026-02-05 03:59:49,236 - mmdet - INFO - initialize FPN with init_cfg {'type': 'Xavier', 'layer': 'Conv2d', 'distribution': 'uniform'}
Name of parameter - Initialization information

pts_bbox_head.code_weights - torch.Size([10]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_code_weights - torch.Size([4]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.positional_encoding.row_embed.weight - torch.Size([100, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.positional_encoding.col_embed.weight - torch.Size([100, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.level_embeds - torch.Size([4, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.cams_embeds - torch.Size([6, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.sampling_offsets.weight - torch.Size([128, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.sampling_offsets.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.attention_weights.weight - torch.Size([64, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.attention_weights.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.0.attentions.0.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.deformable_attention.sampling_offsets.weight - torch.Size([128, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.deformable_attention.sampling_offsets.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.deformable_attention.attention_weights.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.deformable_attention.attention_weights.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.deformable_attention.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.deformable_attention.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.0.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.0.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.0.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.0.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.sampling_offsets.weight - torch.Size([128, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.sampling_offsets.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.attention_weights.weight - torch.Size([64, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.attention_weights.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.1.attentions.0.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.deformable_attention.sampling_offsets.weight - torch.Size([128, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.deformable_attention.sampling_offsets.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.deformable_attention.attention_weights.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.deformable_attention.attention_weights.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.deformable_attention.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.deformable_attention.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.1.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.1.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.1.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.1.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.sampling_offsets.weight - torch.Size([128, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.sampling_offsets.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.attention_weights.weight - torch.Size([64, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.attention_weights.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.2.attentions.0.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.deformable_attention.sampling_offsets.weight - torch.Size([128, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.deformable_attention.sampling_offsets.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.deformable_attention.attention_weights.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.deformable_attention.attention_weights.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.deformable_attention.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.deformable_attention.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.2.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.2.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.encoder.layers.2.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.encoder.layers.2.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.0.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.0.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.sampling_offsets.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.sampling_offsets.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.attention_weights.weight - torch.Size([32, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.attention_weights.bias - torch.Size([32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.0.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.0.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.0.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.0.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.1.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.1.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.sampling_offsets.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.sampling_offsets.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.attention_weights.weight - torch.Size([32, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.attention_weights.bias - torch.Size([32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.1.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.1.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.1.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.1.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.2.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.2.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.sampling_offsets.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.sampling_offsets.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.attention_weights.weight - torch.Size([32, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.attention_weights.bias - torch.Size([32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.2.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.2.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.decoder.layers.2.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.decoder.layers.2.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.sampling_offsets.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.sampling_offsets.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.attention_weights.weight - torch.Size([32, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.attention_weights.bias - torch.Size([32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.0.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.0.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.0.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.0.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.sampling_offsets.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.sampling_offsets.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.attention_weights.weight - torch.Size([32, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.attention_weights.bias - torch.Size([32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.1.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.1.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.1.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.1.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.sampling_offsets.weight - torch.Size([64, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.sampling_offsets.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.attention_weights.weight - torch.Size([32, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.attention_weights.bias - torch.Size([32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.value_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.value_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.output_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.2.attentions.1.output_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.2.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_decoder.layers.2.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.norms.2.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.map_decoder.layers.2.norms.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.reference_points.weight - torch.Size([3, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.reference_points.bias - torch.Size([3]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_reference_points.weight - torch.Size([2, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.map_reference_points.bias - torch.Size([2]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.can_bus_mlp.0.weight - torch.Size([128, 18]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.can_bus_mlp.0.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.can_bus_mlp.2.weight - torch.Size([256, 128]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.transformer.can_bus_mlp.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.can_bus_mlp.norm.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.transformer.can_bus_mlp.norm.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.3.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.4.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.4.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.6.weight - torch.Size([9, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.0.6.bias - torch.Size([9]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.cls_branches.1.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.3.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.4.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.4.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.6.weight - torch.Size([9, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.1.6.bias - torch.Size([9]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.cls_branches.2.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.3.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.4.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.4.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.6.weight - torch.Size([9, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.cls_branches.2.6.bias - torch.Size([9]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.reg_branches.0.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.0.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.0.2.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.0.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.0.4.weight - torch.Size([10, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.0.4.bias - torch.Size([10]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.1.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.1.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.1.2.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.1.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.1.4.weight - torch.Size([10, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.1.4.bias - torch.Size([10]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.2.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.2.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.2.2.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.2.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.2.4.weight - torch.Size([10, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.reg_branches.2.4.bias - torch.Size([10]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches.0.0.weight - torch.Size([1024, 1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches.0.0.bias - torch.Size([1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches.0.2.weight - torch.Size([1024, 1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches.0.2.bias - torch.Size([1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches.0.4.weight - torch.Size([2, 1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches.0.4.bias - torch.Size([2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.0.weight - torch.Size([512, 3584]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.1.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.1.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.3.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.3.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.4.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.4.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.6.weight - torch.Size([1, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches.0.6.bias - torch.Size([1]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.map_cls_branches.0.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.3.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.4.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.4.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.6.weight - torch.Size([6, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.0.6.bias - torch.Size([6]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.map_cls_branches.1.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.3.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.4.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.4.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.6.weight - torch.Size([6, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.1.6.bias - torch.Size([6]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.map_cls_branches.2.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.3.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.4.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.4.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.6.weight - torch.Size([6, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_cls_branches.2.6.bias - torch.Size([6]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.map_reg_branches.0.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.0.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.0.2.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.0.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.0.4.weight - torch.Size([2, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.0.4.bias - torch.Size([2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.1.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.1.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.1.2.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.1.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.1.4.weight - torch.Size([2, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.1.4.bias - torch.Size([2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.2.0.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.2.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.2.2.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.2.2.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.2.4.weight - torch.Size([2, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_reg_branches.2.4.bias - torch.Size([2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.bev_embedding.weight - torch.Size([10000, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.query_embedding.weight - torch.Size([300, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_instance_embedding.weight - torch.Size([100, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.map_pts_embedding.weight - torch.Size([20, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_decoder.layers.0.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_decoder.layers.0.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_decoder.layers.0.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_decoder.layers.0.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_decoder.layers.0.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_mode_query.weight - torch.Size([6, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.pos_mlp_sa.weight - torch.Size([256, 2]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.pos_mlp_sa.bias - torch.Size([256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.lane_encoder.layer_seq.lmlp_0.mlp.0.weight - torch.Size([128, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.lane_encoder.layer_seq.lmlp_0.mlp.0.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_0.mlp.1.weight - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_0.mlp.1.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_1.mlp.0.weight - torch.Size([128, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.lane_encoder.layer_seq.lmlp_1.mlp.0.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_1.mlp.1.weight - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_1.mlp.1.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_2.mlp.0.weight - torch.Size([128, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.lane_encoder.layer_seq.lmlp_2.mlp.0.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_2.mlp.1.weight - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.lane_encoder.layer_seq.lmlp_2.mlp.1.bias - torch.Size([128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_map_decoder.layers.0.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_map_decoder.layers.0.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_map_decoder.layers.0.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.motion_map_decoder.layers.0.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_map_decoder.layers.0.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.pos_mlp.weight - torch.Size([256, 2]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.pos_mlp.bias - torch.Size([256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_query.weight - torch.Size([1, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_agent_decoder.layers.0.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_agent_decoder.layers.0.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_agent_decoder.layers.0.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_agent_decoder.layers.0.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_decoder.layers.0.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_pos_mlp.weight - torch.Size([256, 2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_agent_pos_mlp.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.attentions.0.attn.in_proj_weight - torch.Size([768, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_map_decoder.layers.0.attentions.0.attn.in_proj_bias - torch.Size([768]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.attentions.0.attn.out_proj.weight - torch.Size([256, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_map_decoder.layers.0.attentions.0.attn.out_proj.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.ffns.0.layers.0.0.weight - torch.Size([512, 256]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_map_decoder.layers.0.ffns.0.layers.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.ffns.0.layers.1.weight - torch.Size([256, 512]): 
Initialized by user-defined `init_weights` in GenADHead  

pts_bbox_head.ego_map_decoder.layers.0.ffns.0.layers.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.norms.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.norms.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.norms.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_decoder.layers.0.norms.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_pos_mlp.weight - torch.Size([256, 2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_map_pos_mlp.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder.0.weight - torch.Size([1024, 1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder.0.bias - torch.Size([1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder.2.weight - torch.Size([1024, 1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder.2.bias - torch.Size([1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder.4.weight - torch.Size([12, 1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder.4.bias - torch.Size([12]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.agent_fus_mlp.0.weight - torch.Size([256, 3072]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.agent_fus_mlp.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.agent_fus_mlp.1.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.agent_fus_mlp.1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.agent_fus_mlp.3.weight - torch.Size([256, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.agent_fus_mlp.3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_coord_mlp.weight - torch.Size([2, 2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_coord_mlp.bias - torch.Size([2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_ih_l0 - torch.Size([1536, 32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_hh_l0 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_ih_l0 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_hh_l0 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_ih_l1 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_hh_l1 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_ih_l1 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_hh_l1 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_ih_l2 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_hh_l2 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_ih_l2 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_hh_l2 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_ih_l3 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.weight_hh_l3 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_ih_l3 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.state_gru.bias_hh_l3 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_ih_l0 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_hh_l0 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_ih_l0 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_hh_l0 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_ih_l1 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_hh_l1 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_ih_l1 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_hh_l1 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_ih_l2 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_hh_l2 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_ih_l2 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_hh_l2 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_ih_l3 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.weight_hh_l3 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_ih_l3 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_gru.bias_hh_l3 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_ih_l0 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_hh_l0 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_ih_l0 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_hh_l0 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_ih_l1 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_hh_l1 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_ih_l1 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_hh_l1 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_ih_l2 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_hh_l2 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_ih_l2 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_hh_l2 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_ih_l3 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.weight_hh_l3 - torch.Size([1536, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_ih_l3 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.motion_gru.bias_hh_l3 - torch.Size([1536]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches_ar.0.0.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches_ar.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches_ar.0.2.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches_ar.0.2.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches_ar.0.4.weight - torch.Size([2, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_branches_ar.0.4.bias - torch.Size([2]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.0.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.1.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.1.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.3.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.3.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.4.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.4.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.6.weight - torch.Size([1, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.traj_cls_branches_ar.0.6.bias - torch.Size([1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder_ar.0.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder_ar.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder_ar.2.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder_ar.2.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder_ar.4.weight - torch.Size([12, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.ego_fut_decoder_ar.4.bias - torch.Size([12]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.encoder.conv1.weight - torch.Size([1024, 512, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.encoder.conv1.bias - torch.Size([1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.encoder.conv2.weight - torch.Size([1024, 1024, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.encoder.conv2.bias - torch.Size([1024]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.encoder.conv3.weight - torch.Size([256, 1024, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.encoder.conv3.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.last_conv.1.weight - torch.Size([64, 256, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.present_distribution.last_conv.1.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.encoder.conv1.weight - torch.Size([1048, 524, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.encoder.conv1.bias - torch.Size([1048]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.encoder.conv2.weight - torch.Size([1048, 1048, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.encoder.conv2.bias - torch.Size([1048]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.encoder.conv3.weight - torch.Size([262, 1048, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.encoder.conv3.bias - torch.Size([262]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.last_conv.1.weight - torch.Size([64, 262, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_distribution.last_conv.1.bias - torch.Size([64]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.0.conv_update.weight - torch.Size([512, 544, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.0.conv_update.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.0.conv_reset.weight - torch.Size([512, 544, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.0.conv_reset.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.0.conv_state_tilde.conv.weight - torch.Size([512, 544, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.0.conv_state_tilde.norm.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.0.conv_state_tilde.norm.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.1.conv_update.weight - torch.Size([512, 1024, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.1.conv_update.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.1.conv_reset.weight - torch.Size([512, 1024, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.1.conv_reset.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.1.conv_state_tilde.conv.weight - torch.Size([512, 1024, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.1.conv_state_tilde.norm.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.1.conv_state_tilde.norm.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.2.conv_update.weight - torch.Size([512, 1024, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.2.conv_update.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.2.conv_reset.weight - torch.Size([512, 1024, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.2.conv_reset.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.2.conv_state_tilde.conv.weight - torch.Size([512, 1024, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.2.conv_state_tilde.norm.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.spatial_grus.2.conv_state_tilde.norm.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.0.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.1.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.0.2.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.0.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.1.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.1.2.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.0.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.1.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.conv_down_project.weight - torch.Size([256, 512, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.abn_down_project.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.abn_down_project.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.conv.weight - torch.Size([256, 256, 3, 3]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.abn.0.weight - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.abn.0.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.conv_up_project.weight - torch.Size([512, 256, 1, 1]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.abn_up_project.0.weight - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.future_prediction.res_blocks.2.2.layers.abn_up_project.0.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_ih_l0 - torch.Size([384, 32]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_hh_l0 - torch.Size([384, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_ih_l0 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_hh_l0 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_ih_l1 - torch.Size([384, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_hh_l1 - torch.Size([384, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_ih_l1 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_hh_l1 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_ih_l2 - torch.Size([384, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_hh_l2 - torch.Size([384, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_ih_l2 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_hh_l2 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_ih_l3 - torch.Size([384, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.weight_hh_l3 - torch.Size([384, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_ih_l3 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.gru.bias_hh_l3 - torch.Size([384]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.linear1.weight - torch.Size([256, 128]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.linear1.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.linear2.weight - torch.Size([512, 256]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.linear2.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.linear3.weight - torch.Size([512, 512]): 
The value is the same before and after calling `init_weights` of GenAD  

pts_bbox_head.predict_model.linear3.bias - torch.Size([512]): 
The value is the same before and after calling `init_weights` of GenAD  

img_backbone.conv1.weight - torch.Size([64, 3, 7, 7]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.bn1.weight - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.bn1.bias - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.conv1.weight - torch.Size([64, 64, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.bn1.weight - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.bn1.bias - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.conv2.weight - torch.Size([64, 64, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.bn2.weight - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.bn2.bias - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.conv3.weight - torch.Size([256, 64, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.bn3.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.bn3.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.downsample.0.weight - torch.Size([256, 64, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.downsample.1.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.0.downsample.1.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.conv1.weight - torch.Size([64, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.bn1.weight - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.bn1.bias - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.conv2.weight - torch.Size([64, 64, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.bn2.weight - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.bn2.bias - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.conv3.weight - torch.Size([256, 64, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.bn3.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.1.bn3.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.conv1.weight - torch.Size([64, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.bn1.weight - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.bn1.bias - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.conv2.weight - torch.Size([64, 64, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.bn2.weight - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.bn2.bias - torch.Size([64]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.conv3.weight - torch.Size([256, 64, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.bn3.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer1.2.bn3.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.conv1.weight - torch.Size([128, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.bn1.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.bn1.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.conv2.weight - torch.Size([128, 128, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.bn2.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.bn2.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.conv3.weight - torch.Size([512, 128, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.bn3.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.bn3.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.downsample.0.weight - torch.Size([512, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.downsample.1.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.0.downsample.1.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.conv1.weight - torch.Size([128, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.bn1.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.bn1.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.conv2.weight - torch.Size([128, 128, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.bn2.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.bn2.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.conv3.weight - torch.Size([512, 128, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.bn3.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.1.bn3.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.conv1.weight - torch.Size([128, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.bn1.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.bn1.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.conv2.weight - torch.Size([128, 128, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.bn2.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.bn2.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.conv3.weight - torch.Size([512, 128, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.bn3.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.2.bn3.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.conv1.weight - torch.Size([128, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.bn1.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.bn1.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.conv2.weight - torch.Size([128, 128, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.bn2.weight - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.bn2.bias - torch.Size([128]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.conv3.weight - torch.Size([512, 128, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.bn3.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer2.3.bn3.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.conv1.weight - torch.Size([256, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.bn1.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.bn1.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.conv2.weight - torch.Size([256, 256, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.bn2.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.bn2.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.conv3.weight - torch.Size([1024, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.bn3.weight - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.bn3.bias - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.downsample.0.weight - torch.Size([1024, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.downsample.1.weight - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.0.downsample.1.bias - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.conv1.weight - torch.Size([256, 1024, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.bn1.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.bn1.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.conv2.weight - torch.Size([256, 256, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.bn2.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.bn2.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.conv3.weight - torch.Size([1024, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.bn3.weight - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.1.bn3.bias - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.conv1.weight - torch.Size([256, 1024, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.bn1.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.bn1.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.conv2.weight - torch.Size([256, 256, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.bn2.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.bn2.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.conv3.weight - torch.Size([1024, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.bn3.weight - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.2.bn3.bias - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.conv1.weight - torch.Size([256, 1024, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.bn1.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.bn1.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.conv2.weight - torch.Size([256, 256, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.bn2.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.bn2.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.conv3.weight - torch.Size([1024, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.bn3.weight - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.3.bn3.bias - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.conv1.weight - torch.Size([256, 1024, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.bn1.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.bn1.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.conv2.weight - torch.Size([256, 256, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.bn2.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.bn2.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.conv3.weight - torch.Size([1024, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.bn3.weight - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.4.bn3.bias - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.conv1.weight - torch.Size([256, 1024, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.bn1.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.bn1.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.conv2.weight - torch.Size([256, 256, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.bn2.weight - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.bn2.bias - torch.Size([256]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.conv3.weight - torch.Size([1024, 256, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.bn3.weight - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer3.5.bn3.bias - torch.Size([1024]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.conv1.weight - torch.Size([512, 1024, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.bn1.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.bn1.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.conv2.weight - torch.Size([512, 512, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.bn2.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.bn2.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.conv3.weight - torch.Size([2048, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.bn3.weight - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.bn3.bias - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.downsample.0.weight - torch.Size([2048, 1024, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.downsample.1.weight - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.0.downsample.1.bias - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.conv1.weight - torch.Size([512, 2048, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.bn1.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.bn1.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.conv2.weight - torch.Size([512, 512, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.bn2.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.bn2.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.conv3.weight - torch.Size([2048, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.bn3.weight - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.1.bn3.bias - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.conv1.weight - torch.Size([512, 2048, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.bn1.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.bn1.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.conv2.weight - torch.Size([512, 512, 3, 3]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.bn2.weight - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.bn2.bias - torch.Size([512]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.conv3.weight - torch.Size([2048, 512, 1, 1]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.bn3.weight - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_backbone.layer4.2.bn3.bias - torch.Size([2048]): 
PretrainedInit: load from ckpts/resnet50-19c8e357.pth 

img_neck.lateral_convs.0.conv.weight - torch.Size([256, 2048, 1, 1]): 
XavierInit: gain=1, distribution=uniform, bias=0 

img_neck.lateral_convs.0.conv.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  

img_neck.fpn_convs.0.conv.weight - torch.Size([256, 256, 3, 3]): 
XavierInit: gain=1, distribution=uniform, bias=0 

img_neck.fpn_convs.0.conv.bias - torch.Size([256]): 
The value is the same before and after calling `init_weights` of GenAD  
2026-02-05 03:59:49,245 - mmdet - INFO - Model:
GenAD(
  (pts_bbox_head): GenADHead(
    (loss_cls): FocalLoss()
    (loss_bbox): L1Loss()
    (loss_iou): GIoULoss()
    (activate): ReLU(inplace=True)
    (positional_encoding): LearnedPositionalEncoding(num_feats=128, row_num_embed=100, col_num_embed=100)
    (transformer): VADPerceptionTransformer(
      (encoder): BEVFormerEncoder(
        (layers): ModuleList(
          (0-2): 3 x BEVFormerLayer(
            (attentions): ModuleList(
              (0): TemporalSelfAttention(
                (dropout): Dropout(p=0.1, inplace=False)
                (sampling_offsets): Linear(in_features=512, out_features=128, bias=True)
                (attention_weights): Linear(in_features=512, out_features=64, bias=True)
                (value_proj): Linear(in_features=256, out_features=256, bias=True)
                (output_proj): Linear(in_features=256, out_features=256, bias=True)
              )
              (1): SpatialCrossAttention(
                (dropout): Dropout(p=0.1, inplace=False)
                (deformable_attention): MSDeformableAttention3D(
                  (sampling_offsets): Linear(in_features=256, out_features=128, bias=True)
                  (attention_weights): Linear(in_features=256, out_features=64, bias=True)
                  (value_proj): Linear(in_features=256, out_features=256, bias=True)
                )
                (output_proj): Linear(in_features=256, out_features=256, bias=True)
              )
            )
            (ffns): ModuleList(
              (0): FFN(
                (activate): ReLU(inplace=True)
                (layers): Sequential(
                  (0): Sequential(
                    (0): Linear(in_features=256, out_features=512, bias=True)
                    (1): ReLU(inplace=True)
                    (2): Dropout(p=0.0, inplace=False)
                  )
                  (1): Linear(in_features=512, out_features=256, bias=True)
                  (2): Dropout(p=0.0, inplace=False)
                )
                (dropout_layer): Identity()
              )
            )
            (norms): ModuleList(
              (0-2): 3 x LayerNorm((256,), eps=1e-05, elementwise_affine=True)
            )
          )
        )
      )
      (decoder): DetectionTransformerDecoder(
        (layers): ModuleList(
          (0-2): 3 x DetrTransformerDecoderLayer(
            (attentions): ModuleList(
              (0): MultiheadAttention(
                (attn): MultiheadAttention(
                  (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
                )
                (proj_drop): Dropout(p=0.0, inplace=False)
                (dropout_layer): Dropout(p=0.0, inplace=False)
              )
              (1): CustomMSDeformableAttention(
                (dropout): Dropout(p=0.1, inplace=False)
                (sampling_offsets): Linear(in_features=256, out_features=64, bias=True)
                (attention_weights): Linear(in_features=256, out_features=32, bias=True)
                (value_proj): Linear(in_features=256, out_features=256, bias=True)
                (output_proj): Linear(in_features=256, out_features=256, bias=True)
              )
            )
            (ffns): ModuleList(
              (0): FFN(
                (activate): ReLU(inplace=True)
                (layers): Sequential(
                  (0): Sequential(
                    (0): Linear(in_features=256, out_features=512, bias=True)
                    (1): ReLU(inplace=True)
                    (2): Dropout(p=0.0, inplace=False)
                  )
                  (1): Linear(in_features=512, out_features=256, bias=True)
                  (2): Dropout(p=0.0, inplace=False)
                )
                (dropout_layer): Identity()
              )
            )
            (norms): ModuleList(
              (0-2): 3 x LayerNorm((256,), eps=1e-05, elementwise_affine=True)
            )
          )
        )
      )
      (map_decoder): MapDetectionTransformerDecoder(
        (layers): ModuleList(
          (0-2): 3 x DetrTransformerDecoderLayer(
            (attentions): ModuleList(
              (0): MultiheadAttention(
                (attn): MultiheadAttention(
                  (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
                )
                (proj_drop): Dropout(p=0.0, inplace=False)
                (dropout_layer): Dropout(p=0.0, inplace=False)
              )
              (1): CustomMSDeformableAttention(
                (dropout): Dropout(p=0.1, inplace=False)
                (sampling_offsets): Linear(in_features=256, out_features=64, bias=True)
                (attention_weights): Linear(in_features=256, out_features=32, bias=True)
                (value_proj): Linear(in_features=256, out_features=256, bias=True)
                (output_proj): Linear(in_features=256, out_features=256, bias=True)
              )
            )
            (ffns): ModuleList(
              (0): FFN(
                (activate): ReLU(inplace=True)
                (layers): Sequential(
                  (0): Sequential(
                    (0): Linear(in_features=256, out_features=512, bias=True)
                    (1): ReLU(inplace=True)
                    (2): Dropout(p=0.0, inplace=False)
                  )
                  (1): Linear(in_features=512, out_features=256, bias=True)
                  (2): Dropout(p=0.0, inplace=False)
                )
                (dropout_layer): Identity()
              )
            )
            (norms): ModuleList(
              (0-2): 3 x LayerNorm((256,), eps=1e-05, elementwise_affine=True)
            )
          )
        )
      )
      (reference_points): Linear(in_features=256, out_features=3, bias=True)
      (map_reference_points): Linear(in_features=256, out_features=2, bias=True)
      (can_bus_mlp): Sequential(
        (0): Linear(in_features=18, out_features=128, bias=True)
        (1): ReLU(inplace=True)
        (2): Linear(in_features=128, out_features=256, bias=True)
        (3): ReLU(inplace=True)
        (norm): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
      )
    )
    (cls_branches): ModuleList(
      (0-2): 3 x Sequential(
        (0): Linear(in_features=256, out_features=256, bias=True)
        (1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
        (2): ReLU(inplace=True)
        (3): Linear(in_features=256, out_features=256, bias=True)
        (4): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
        (5): ReLU(inplace=True)
        (6): Linear(in_features=256, out_features=9, bias=True)
      )
    )
    (reg_branches): ModuleList(
      (0-2): 3 x Sequential(
        (0): Linear(in_features=256, out_features=256, bias=True)
        (1): ReLU()
        (2): Linear(in_features=256, out_features=256, bias=True)
        (3): ReLU()
        (4): Linear(in_features=256, out_features=10, bias=True)
      )
    )
    (traj_branches): ModuleList(
      (0): Sequential(
        (0): Linear(in_features=1024, out_features=1024, bias=True)
        (1): ReLU()
        (2): Linear(in_features=1024, out_features=1024, bias=True)
        (3): ReLU()
        (4): Linear(in_features=1024, out_features=2, bias=True)
      )
    )
    (traj_cls_branches): ModuleList(
      (0): Sequential(
        (0): Linear(in_features=3584, out_features=512, bias=True)
        (1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (2): ReLU(inplace=True)
        (3): Linear(in_features=512, out_features=512, bias=True)
        (4): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (5): ReLU(inplace=True)
        (6): Linear(in_features=512, out_features=1, bias=True)
      )
    )
    (map_cls_branches): ModuleList(
      (0-2): 3 x Sequential(
        (0): Linear(in_features=256, out_features=256, bias=True)
        (1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
        (2): ReLU(inplace=True)
        (3): Linear(in_features=256, out_features=256, bias=True)
        (4): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
        (5): ReLU(inplace=True)
        (6): Linear(in_features=256, out_features=6, bias=True)
      )
    )
    (map_reg_branches): ModuleList(
      (0-2): 3 x Sequential(
        (0): Linear(in_features=256, out_features=256, bias=True)
        (1): ReLU()
        (2): Linear(in_features=256, out_features=256, bias=True)
        (3): ReLU()
        (4): Linear(in_features=256, out_features=2, bias=True)
      )
    )
    (bev_embedding): Embedding(10000, 256)
    (query_embedding): Embedding(300, 512)
    (map_instance_embedding): Embedding(100, 512)
    (map_pts_embedding): Embedding(20, 512)
    (motion_decoder): CustomTransformerDecoder(
      (layers): ModuleList(
        (0): BaseTransformerLayer(
          (attentions): ModuleList(
            (0): MultiheadAttention(
              (attn): MultiheadAttention(
                (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
              )
              (proj_drop): Dropout(p=0.0, inplace=False)
              (dropout_layer): Dropout(p=0.0, inplace=False)
            )
          )
          (ffns): ModuleList(
            (0): FFN(
              (activate): ReLU(inplace=True)
              (layers): Sequential(
                (0): Sequential(
                  (0): Linear(in_features=256, out_features=512, bias=True)
                  (1): ReLU(inplace=True)
                  (2): Dropout(p=0.0, inplace=False)
                )
                (1): Linear(in_features=512, out_features=256, bias=True)
                (2): Dropout(p=0.0, inplace=False)
              )
              (dropout_layer): Identity()
            )
          )
          (norms): ModuleList(
            (0-1): 2 x LayerNorm((256,), eps=1e-05, elementwise_affine=True)
          )
        )
      )
    )
    (motion_mode_query): Embedding(6, 256)
    (pos_mlp_sa): Linear(in_features=2, out_features=256, bias=True)
    (lane_encoder): LaneNet(
      (layer_seq): Sequential(
        (lmlp_0): MLP(
          (mlp): Sequential(
            (0): Linear(in_features=256, out_features=128, bias=True)
            (1): LayerNorm((128,), eps=1e-05, elementwise_affine=True)
            (2): ReLU()
          )
        )
        (lmlp_1): MLP(
          (mlp): Sequential(
            (0): Linear(in_features=256, out_features=128, bias=True)
            (1): LayerNorm((128,), eps=1e-05, elementwise_affine=True)
            (2): ReLU()
          )
        )
        (lmlp_2): MLP(
          (mlp): Sequential(
            (0): Linear(in_features=256, out_features=128, bias=True)
            (1): LayerNorm((128,), eps=1e-05, elementwise_affine=True)
            (2): ReLU()
          )
        )
      )
    )
    (motion_map_decoder): CustomTransformerDecoder(
      (layers): ModuleList(
        (0): BaseTransformerLayer(
          (attentions): ModuleList(
            (0): MultiheadAttention(
              (attn): MultiheadAttention(
                (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
              )
              (proj_drop): Dropout(p=0.0, inplace=False)
              (dropout_layer): Dropout(p=0.0, inplace=False)
            )
          )
          (ffns): ModuleList(
            (0): FFN(
              (activate): ReLU(inplace=True)
              (layers): Sequential(
                (0): Sequential(
                  (0): Linear(in_features=256, out_features=512, bias=True)
                  (1): ReLU(inplace=True)
                  (2): Dropout(p=0.0, inplace=False)
                )
                (1): Linear(in_features=512, out_features=256, bias=True)
                (2): Dropout(p=0.0, inplace=False)
              )
              (dropout_layer): Identity()
            )
          )
          (norms): ModuleList(
            (0-1): 2 x LayerNorm((256,), eps=1e-05, elementwise_affine=True)
          )
        )
      )
    )
    (pos_mlp): Linear(in_features=2, out_features=256, bias=True)
    (ego_query): Embedding(1, 256)
    (ego_agent_decoder): CustomTransformerDecoder(
      (layers): ModuleList(
        (0): BaseTransformerLayer(
          (attentions): ModuleList(
            (0): MultiheadAttention(
              (attn): MultiheadAttention(
                (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
              )
              (proj_drop): Dropout(p=0.0, inplace=False)
              (dropout_layer): Dropout(p=0.0, inplace=False)
            )
          )
          (ffns): ModuleList(
            (0): FFN(
              (activate): ReLU(inplace=True)
              (layers): Sequential(
                (0): Sequential(
                  (0): Linear(in_features=256, out_features=512, bias=True)
                  (1): ReLU(inplace=True)
                  (2): Dropout(p=0.0, inplace=False)
                )
                (1): Linear(in_features=512, out_features=256, bias=True)
                (2): Dropout(p=0.0, inplace=False)
              )
              (dropout_layer): Identity()
            )
          )
          (norms): ModuleList(
            (0-1): 2 x LayerNorm((256,), eps=1e-05, elementwise_affine=True)
          )
        )
      )
    )
    (ego_agent_pos_mlp): Linear(in_features=2, out_features=256, bias=True)
    (ego_map_decoder): CustomTransformerDecoder(
      (layers): ModuleList(
        (0): BaseTransformerLayer(
          (attentions): ModuleList(
            (0): MultiheadAttention(
              (attn): MultiheadAttention(
                (out_proj): NonDynamicallyQuantizableLinear(in_features=256, out_features=256, bias=True)
              )
              (proj_drop): Dropout(p=0.0, inplace=False)
              (dropout_layer): Dropout(p=0.0, inplace=False)
            )
          )
          (ffns): ModuleList(
            (0): FFN(
              (activate): ReLU(inplace=True)
              (layers): Sequential(
                (0): Sequential(
                  (0): Linear(in_features=256, out_features=512, bias=True)
                  (1): ReLU(inplace=True)
                  (2): Dropout(p=0.0, inplace=False)
                )
                (1): Linear(in_features=512, out_features=256, bias=True)
                (2): Dropout(p=0.0, inplace=False)
              )
              (dropout_layer): Identity()
            )
          )
          (norms): ModuleList(
            (0-1): 2 x LayerNorm((256,), eps=1e-05, elementwise_affine=True)
          )
        )
      )
    )
    (ego_map_pos_mlp): Linear(in_features=2, out_features=256, bias=True)
    (ego_fut_decoder): Sequential(
      (0): Linear(in_features=1024, out_features=1024, bias=True)
      (1): ReLU()
      (2): Linear(in_features=1024, out_features=1024, bias=True)
      (3): ReLU()
      (4): Linear(in_features=1024, out_features=12, bias=True)
    )
    (agent_fus_mlp): Sequential(
      (0): Linear(in_features=3072, out_features=256, bias=True)
      (1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)
      (2): ReLU()
      (3): Linear(in_features=256, out_features=256, bias=True)
    )
    (ego_coord_mlp): Linear(in_features=2, out_features=2, bias=True)
    (state_gru): GRU(32, 512, num_layers=4)
    (ego_gru): GRU(512, 512, num_layers=4)
    (motion_gru): GRU(512, 512, num_layers=4)
    (traj_branches_ar): ModuleList(
      (0): Sequential(
        (0): Linear(in_features=512, out_features=512, bias=True)
        (1): ReLU()
        (2): Linear(in_features=512, out_features=512, bias=True)
        (3): ReLU()
        (4): Linear(in_features=512, out_features=2, bias=True)
      )
    )
    (traj_cls_branches_ar): ModuleList(
      (0): Sequential(
        (0): Linear(in_features=512, out_features=512, bias=True)
        (1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (2): ReLU(inplace=True)
        (3): Linear(in_features=512, out_features=512, bias=True)
        (4): LayerNorm((512,), eps=1e-05, elementwise_affine=True)
        (5): ReLU(inplace=True)
        (6): Linear(in_features=512, out_features=1, bias=True)
      )
    )
    (ego_fut_decoder_ar): Sequential(
      (0): Linear(in_features=512, out_features=512, bias=True)
      (1): ReLU()
      (2): Linear(in_features=512, out_features=512, bias=True)
      (3): ReLU()
      (4): Linear(in_features=512, out_features=12, bias=True)
    )
    (present_distribution): DistributionModule(
      (encoder): DistributionEncoder1DV2(
        (conv1): Conv1d(512, 1024, kernel_size=(1,), stride=(1,))
        (conv2): Conv1d(1024, 1024, kernel_size=(1,), stride=(1,))
        (conv3): Conv1d(1024, 256, kernel_size=(1,), stride=(1,))
        (relu): ReLU(inplace=True)
      )
      (last_conv): Sequential(
        (0): AdaptiveAvgPool1d(output_size=1)
        (1): Conv1d(256, 64, kernel_size=(1,), stride=(1,))
      )
    )
    (future_distribution): DistributionModule(
      (encoder): DistributionEncoder1DV2(
        (conv1): Conv1d(524, 1048, kernel_size=(1,), stride=(1,))
        (conv2): Conv1d(1048, 1048, kernel_size=(1,), stride=(1,))
        (conv3): Conv1d(1048, 262, kernel_size=(1,), stride=(1,))
        (relu): ReLU(inplace=True)
      )
      (last_conv): Sequential(
        (0): AdaptiveAvgPool1d(output_size=1)
        (1): Conv1d(262, 64, kernel_size=(1,), stride=(1,))
      )
    )
    (future_prediction): FuturePrediction(
      (spatial_grus): ModuleList(
        (0): SpatialGRU(
          (conv_update): Conv2d(544, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (conv_reset): Conv2d(544, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (conv_state_tilde): ConvBlock(
            (conv): Conv2d(544, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
            (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (activation): ReLU(inplace=True)
          )
        )
        (1-2): 2 x SpatialGRU(
          (conv_update): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (conv_reset): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
          (conv_state_tilde): ConvBlock(
            (conv): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
            (norm): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
            (activation): ReLU(inplace=True)
          )
        )
      )
      (res_blocks): ModuleList(
        (0-2): 3 x Sequential(
          (0): Bottleneck(
            (layers): Sequential(
              (conv_down_project): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (abn_down_project): Sequential(
                (0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
              (abn): Sequential(
                (0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (conv_up_project): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (abn_up_project): Sequential(
                (0): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (dropout): Dropout2d(p=0.0, inplace=False)
            )
          )
          (1): Bottleneck(
            (layers): Sequential(
              (conv_down_project): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (abn_down_project): Sequential(
                (0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
              (abn): Sequential(
                (0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (conv_up_project): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (abn_up_project): Sequential(
                (0): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (dropout): Dropout2d(p=0.0, inplace=False)
            )
          )
          (2): Bottleneck(
            (layers): Sequential(
              (conv_down_project): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (abn_down_project): Sequential(
                (0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
              (abn): Sequential(
                (0): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (conv_up_project): Conv2d(256, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
              (abn_up_project): Sequential(
                (0): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
                (1): ReLU(inplace=True)
              )
              (dropout): Dropout2d(p=0.0, inplace=False)
            )
          )
        )
      )
    )
    (predict_model): PredictModel(
      (gru): GRU(32, 128, num_layers=4)
      (linear1): Linear(in_features=128, out_features=256, bias=True)
      (linear2): Linear(in_features=256, out_features=512, bias=True)
      (linear3): Linear(in_features=512, out_features=512, bias=True)
      (relu): ReLU(inplace=True)
    )
    (loss_traj): L1Loss()
    (loss_traj_cls): FocalLoss()
    (loss_map_bbox): L1Loss()
    (loss_map_cls): FocalLoss()
    (loss_map_iou): GIoULoss()
    (loss_map_pts): PtsL1Loss()
    (loss_map_dir): PtsDirCosLoss()
    (loss_plan_reg): L1Loss()
    (loss_plan_bound): PlanMapBoundLoss()
    (loss_plan_col): PlanCollisionLoss()
    (loss_plan_dir): PlanMapDirectionLoss()
    (loss_vae_gen): ProbabilisticLoss()
  )
  (img_backbone): ResNet(
    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (layer1): ResLayer(
      (0): Bottleneck(
        (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (1): Bottleneck(
        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (2): Bottleneck(
        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
    )
    (layer2): ResLayer(
      (0): Bottleneck(
        (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (1): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (2): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (3): Bottleneck(
        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
    )
    (layer3): ResLayer(
      (0): Bottleneck(
        (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (1): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (2): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (3): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (4): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (5): Bottleneck(
        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
    )
    (layer4): ResLayer(
      (0): Bottleneck(
        (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (downsample): Sequential(
          (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (1): Bottleneck(
        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
      (2): Bottleneck(
        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
      )
      init_cfg={'type': 'Constant', 'val': 0, 'override': {'name': 'norm3'}}
    )
  )
  init_cfg={'type': 'Pretrained', 'checkpoint': 'ckpts/resnet50-19c8e357.pth'}
  (img_neck): FPN(
    (lateral_convs): ModuleList(
      (0): ConvModule(
        (conv): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))
      )
    )
    (fpn_convs): ModuleList(
      (0): ConvModule(
        (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
      )
    )
  )
  init_cfg={'type': 'Xavier', 'layer': 'Conv2d', 'distribution': 'uniform'}
  (grid_mask): GridMask()
)