Merge branch 'master' into openlane

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/models/pointnet2_ssg.py

+# model settings
+model = dict(
+    type='EncoderDecoder3D',
+    backbone=dict(
+        type='PointNet2SASSG',
+        in_channels=6,  # [xyz, rgb], should be modified with dataset
+        num_points=(1024, 256, 64, 16),
+        radius=(0.1, 0.2, 0.4, 0.8),
+        num_samples=(32, 32, 32, 32),
+        sa_channels=((32, 32, 64), (64, 64, 128), (128, 128, 256), (256, 256,
+                                                                    512)),
+        fp_channels=(),
+        norm_cfg=dict(type='BN2d'),
+        sa_cfg=dict(
+            type='PointSAModule',
+            pool_mod='max',
+            use_xyz=True,
+            normalize_xyz=False)),
+    decode_head=dict(
+        type='PointNet2Head',
+        fp_channels=((768, 256, 256), (384, 256, 256), (320, 256, 128),
+                     (128, 128, 128, 128)),
+        channels=128,
+        dropout_ratio=0.5,
+        conv_cfg=dict(type='Conv1d'),
+        norm_cfg=dict(type='BN1d'),
+        act_cfg=dict(type='ReLU'),
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            class_weight=None,  # should be modified with dataset
+            loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='slide'))

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/models/votenet.py

+model = dict(
+    type='VoteNet',
+    backbone=dict(
+        type='PointNet2SASSG',
+        in_channels=4,
+        num_points=(2048, 1024, 512, 256),
+        radius=(0.2, 0.4, 0.8, 1.2),
+        num_samples=(64, 32, 16, 16),
+        sa_channels=((64, 64, 128), (128, 128, 256), (128, 128, 256),
+                     (128, 128, 256)),
+        fp_channels=((256, 256), (256, 256)),
+        norm_cfg=dict(type='BN2d'),
+        sa_cfg=dict(
+            type='PointSAModule',
+            pool_mod='max',
+            use_xyz=True,
+            normalize_xyz=True)),
+    bbox_head=dict(
+        type='VoteHead',
+        vote_module_cfg=dict(
+            in_channels=256,
+            vote_per_seed=1,
+            gt_per_seed=3,
+            conv_channels=(256, 256),
+            conv_cfg=dict(type='Conv1d'),
+            norm_cfg=dict(type='BN1d'),
+            norm_feats=True,
+            vote_loss=dict(
+                type='ChamferDistance',
+                mode='l1',
+                reduction='none',
+                loss_dst_weight=10.0)),
+        vote_aggregation_cfg=dict(
+            type='PointSAModule',
+            num_point=256,
+            radius=0.3,
+            num_sample=16,
+            mlp_channels=[256, 128, 128, 128],
+            use_xyz=True,
+            normalize_xyz=True),
+        pred_layer_cfg=dict(
+            in_channels=128, shared_conv_channels=(128, 128), bias=True),
+        conv_cfg=dict(type='Conv1d'),
+        norm_cfg=dict(type='BN1d'),
+        objectness_loss=dict(
+            type='CrossEntropyLoss',
+            class_weight=[0.2, 0.8],
+            reduction='sum',
+            loss_weight=5.0),
+        center_loss=dict(
+            type='ChamferDistance',
+            mode='l2',
+            reduction='sum',
+            loss_src_weight=10.0,
+            loss_dst_weight=10.0),
+        dir_class_loss=dict(
+            type='CrossEntropyLoss', reduction='sum', loss_weight=1.0),
+        dir_res_loss=dict(
+            type='SmoothL1Loss', reduction='sum', loss_weight=10.0),
+        size_class_loss=dict(
+            type='CrossEntropyLoss', reduction='sum', loss_weight=1.0),
+        size_res_loss=dict(
+            type='SmoothL1Loss', reduction='sum', loss_weight=10.0 / 3.0),
+        semantic_loss=dict(
+            type='CrossEntropyLoss', reduction='sum', loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(
+        pos_distance_thr=0.3, neg_distance_thr=0.6, sample_mod='vote'),
+    test_cfg=dict(
+        sample_mod='seed',
+        nms_thr=0.25,
+        score_thr=0.05,
+        per_class_proposal=True))

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/cosine.py

+# This schedule is mainly used by models with dynamic voxelization
+# optimizer
+lr = 0.003  # max learning rate
+optimizer = dict(
+    type='AdamW',
+    lr=lr,
+    betas=(0.95, 0.99),  # the momentum is change during training
+    weight_decay=0.001)
+optimizer_config = dict(grad_clip=dict(max_norm=10, norm_type=2))
+
+lr_config = dict(
+    policy='CosineAnnealing',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1.0 / 10,
+    min_lr_ratio=1e-5)
+
+momentum_config = None
+
+runner = dict(type='EpochBasedRunner', max_epochs=40)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/cyclic_20e.py

+# For nuScenes dataset, we usually evaluate the model at the end of training.
+# Since the models are trained by 24 epochs by default, we set evaluation
+# interval to be 20. Please change the interval accordingly if you do not
+# use a default schedule.
+# optimizer
+# This schedule is mainly used by models on nuScenes dataset
+optimizer = dict(type='AdamW', lr=1e-4, weight_decay=0.01)
+# max_norm=10 is better for SECOND
+optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2))
+lr_config = dict(
+    policy='cyclic',
+    target_ratio=(10, 1e-4),
+    cyclic_times=1,
+    step_ratio_up=0.4,
+)
+momentum_config = dict(
+    policy='cyclic',
+    target_ratio=(0.85 / 0.95, 1),
+    cyclic_times=1,
+    step_ratio_up=0.4,
+)
+
+# runtime settings
+runner = dict(type='EpochBasedRunner', max_epochs=20)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/cyclic_40e.py

+# The schedule is usually used by models trained on KITTI dataset
+
+# The learning rate set in the cyclic schedule is the initial learning rate
+# rather than the max learning rate. Since the target_ratio is (10, 1e-4),
+# the learning rate will change from 0.0018 to 0.018, than go to 0.0018*1e-4
+lr = 0.0018
+# The optimizer follows the setting in SECOND.Pytorch, but here we use
+# the offcial AdamW optimizer implemented by PyTorch.
+optimizer = dict(type='AdamW', lr=lr, betas=(0.95, 0.99), weight_decay=0.01)
+optimizer_config = dict(grad_clip=dict(max_norm=10, norm_type=2))
+# We use cyclic learning rate and momentum schedule following SECOND.Pytorch
+# https://github.com/traveller59/second.pytorch/blob/3aba19c9688274f75ebb5e576f65cfe54773c021/torchplus/train/learning_schedules_fastai.py#L69  # noqa
+# We implement them in mmcv, for more details, please refer to
+# https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/lr_updater.py#L327  # noqa
+# https://github.com/open-mmlab/mmcv/blob/f48241a65aebfe07db122e9db320c31b685dc674/mmcv/runner/hooks/momentum_updater.py#L130  # noqa
+lr_config = dict(
+    policy='cyclic',
+    target_ratio=(10, 1e-4),
+    cyclic_times=1,
+    step_ratio_up=0.4,
+)
+momentum_config = dict(
+    policy='cyclic',
+    target_ratio=(0.85 / 0.95, 1),
+    cyclic_times=1,
+    step_ratio_up=0.4,
+)
+# Although the max_epochs is 40, this schedule is usually used we
+# RepeatDataset with repeat ratio N, thus the actual max epoch
+# number could be Nx40
+runner = dict(type='EpochBasedRunner', max_epochs=40)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/mmdet_schedule_1x.py

+# optimizer
+optimizer = dict(type='SGD', lr=0.02, momentum=0.9, weight_decay=0.0001)
+optimizer_config = dict(grad_clip=None)
+# learning policy
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=500,
+    warmup_ratio=0.001,
+    step=[8, 11])
+runner = dict(type='EpochBasedRunner', max_epochs=12)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/schedule_2x.py

+# optimizer
+# This schedule is mainly used by models on nuScenes dataset
+optimizer = dict(type='AdamW', lr=0.001, weight_decay=0.01)
+# max_norm=10 is better for SECOND
+optimizer_config = dict(grad_clip=dict(max_norm=35, norm_type=2))
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1.0 / 1000,
+    step=[20, 23])
+momentum_config = None
+# runtime settings
+runner = dict(type='EpochBasedRunner', max_epochs=24)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/schedule_3x.py

+# optimizer
+# This schedule is mainly used by models on indoor dataset,
+# e.g., VoteNet on SUNRGBD and ScanNet
+lr = 0.008  # max learning rate
+optimizer = dict(type='AdamW', lr=lr, weight_decay=0.01)
+optimizer_config = dict(grad_clip=dict(max_norm=10, norm_type=2))
+lr_config = dict(policy='step', warmup=None, step=[24, 32])
+# runtime settings
+runner = dict(type='EpochBasedRunner', max_epochs=36)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/seg_cosine_150e.py

+# optimizer
+# This schedule is mainly used on S3DIS dataset in segmentation task
+optimizer = dict(type='SGD', lr=0.2, weight_decay=0.0001, momentum=0.9)
+optimizer_config = dict(grad_clip=None)
+lr_config = dict(policy='CosineAnnealing', warmup=None, min_lr=0.002)
+momentum_config = None
+
+# runtime settings
+runner = dict(type='EpochBasedRunner', max_epochs=150)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/seg_cosine_200e.py

+# optimizer
+# This schedule is mainly used on ScanNet dataset in segmentation task
+optimizer = dict(type='Adam', lr=0.001, weight_decay=0.01)
+optimizer_config = dict(grad_clip=None)
+lr_config = dict(policy='CosineAnnealing', warmup=None, min_lr=1e-5)
+momentum_config = None
+
+# runtime settings
+runner = dict(type='EpochBasedRunner', max_epochs=200)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/configs/_base_/schedules/seg_cosine_50e.py

+# optimizer
+# This schedule is mainly used on S3DIS dataset in segmentation task
+optimizer = dict(type='Adam', lr=0.001, weight_decay=0.001)
+optimizer_config = dict(grad_clip=None)
+lr_config = dict(policy='CosineAnnealing', warmup=None, min_lr=1e-5)
+momentum_config = None
+
+# runtime settings
+runner = dict(type='EpochBasedRunner', max_epochs=50)

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/datasets/__init__.py

+from .pipelines import *
+from .argo_dataset import AV2Dataset
\ No newline at end of file

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/datasets/argo_dataset.py

+from .base_dataset import BaseMapDataset
+from mmdet.datasets import DATASETS
+import numpy as np
+from time import time
+import mmcv
+import os
+from shapely.geometry import LineString
+
+@DATASETS.register_module()
+class AV2Dataset(BaseMapDataset):
+    """Argoverse2 map dataset class.
+
+    Args:
+        ann_file (str): annotation file path
+        cat2id (dict): category to class id
+        roi_size (tuple): bev range
+        eval_config (Config): evaluation config
+        meta (dict): meta information
+        pipeline (Config): data processing pipeline config,
+        interval (int): annotation load interval
+        work_dir (str): path to work dir
+        test_mode (bool): whether in test mode
+    """
+
+    def __init__(self, **kwargs,):
+        super().__init__(**kwargs)
+    
+    def load_annotations(self, ann_file):
+        """Load annotations from ann_file.
+
+        Args:
+            ann_file (str): Path of the annotation file.
+
+        Returns:
+            list[dict]: List of annotations.
+        """
+        
+        start_time = time()
+        ann = mmcv.load(ann_file)
+        samples = []
+        for seg_id, sequence in ann.items():
+            samples.extend(sequence)
+        samples = samples[::self.interval]
+        
+        print(f'collected {len(samples)} samples in {(time() - start_time):.2f}s')
+        self.samples = samples
+
+    def get_sample(self, idx):
+        """Get data sample. For each sample, map extractor will be applied to extract 
+        map elements. 
+
+        Args:
+            idx (int): data index
+
+        Returns:
+            result (dict): dict of input
+        """
+
+        sample = self.samples[idx]
+        
+        if not self.test_mode:
+            ann = sample['annotation']
+
+            # collected required keys
+            map_label2geom = {}
+            for k, v in ann.items():
+                if k in self.cat2id.keys():
+                    map_label2geom[self.cat2id[k]] = [LineString(np.array(l)[:, :3]) for l in v]
+        
+        ego2img_rts = []
+        cams = sample['sensor']
+        for c in cams.values():
+            extrinsic, intrinsic = np.array(
+                c['extrinsic']), np.array(c['intrinsic'])
+            ego2cam_rt = extrinsic
+            viewpad = np.eye(4)
+            viewpad[:intrinsic.shape[0], :intrinsic.shape[1]] = intrinsic
+            ego2cam_rt = (viewpad @ ego2cam_rt)
+            ego2img_rts.append(ego2cam_rt)
+
+        pose = sample['pose']
+        input_dict = {
+            'token': sample['timestamp'],
+            'img_filenames': [os.path.join(self.root_path, c['image_path']) for c in cams.values()],
+            # intrinsics are 3x3 Ks
+            'cam_intrinsics': [c['intrinsic'] for c in cams.values()],
+            # extrinsics are 4x4 tranform matrix, NOTE: **ego2cam**
+            'cam_extrinsics': [c['extrinsic'] for c in cams.values()],
+            'ego2img': ego2img_rts,
+            'ego2global_translation': pose['ego2global_translation'], 
+            'ego2global_rotation': pose['ego2global_rotation'],
+        }
+        if not self.test_mode:
+            input_dict.update({'map_geoms': map_label2geom}) # {0: List[ped_crossing(LineString)], 1: ...}})
+
+        return input_dict
\ No newline at end of file

autonomous_driving/Online-HD-Map-Construction-CVPR2023/src/datasets/evaluation/distance.py

+from scipy.spatial import distance
+from numpy.typing import NDArray
+
+def chamfer_distance(line1: NDArray, line2: NDArray) -> float:
+    ''' Calculate chamfer distance between two lines. Make sure the 
+    lines are interpolated.
+
+    Args:
+        line1 (array): coordinates of line1
+        line2 (array): coordinates of line2
+    
+    Returns:
+        distance (float): chamfer distance
+    '''
+    
+    dist_matrix = distance.cdist(line1, line2, 'euclidean')
+    dist12 = dist_matrix.min(-1).sum() / len(line1)
+    dist21 = dist_matrix.min(-2).sum() / len(line2)
+
+    return (dist12 + dist21) / 2
+
+def frechet_distance(line1: NDArray, line2: NDArray) -> float:
+    ''' Calculate frechet distance between two lines. Make sure the 
+    lines are interpolated.
+
+    Args:
+        line1 (array): coordinates of line1
+        line2 (array): coordinates of line2
+    
+    Returns:
+        distance (float): frechet distance
+    '''
+    
+    raise NotImplementedError
+