Add joint_training_small outputs

.gitattributes

@@ -37,3 +37,8 @@ Volt_experiments/single_dataset/nuscenes/train.log filter=lfs diff=lfs merge=lfs
 Volt_experiments/single_dataset/scannet/train.log filter=lfs diff=lfs merge=lfs -text
 Volt_experiments/single_dataset/scannet200/train.log filter=lfs diff=lfs merge=lfs -text
 Volt_experiments/single_dataset/waymo/train.log filter=lfs diff=lfs merge=lfs -text
+Volt_experiments/joint_training_small/nuscenes/train.log filter=lfs diff=lfs merge=lfs -text
+Volt_experiments/joint_training_small/scannet/train.log filter=lfs diff=lfs merge=lfs -text
+Volt_experiments/joint_training_small/scannet200/train.log filter=lfs diff=lfs merge=lfs -text
+Volt_experiments/joint_training_small/semantic_kitti/train.log filter=lfs diff=lfs merge=lfs -text
+Volt_experiments/joint_training_small/waymo/train.log filter=lfs diff=lfs merge=lfs -text

Volt_experiments/joint_training_small/nuscenes/config.py

@@ -0,0 +1,392 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 12644538
+save_path = 'exp/nuscenes/2026-05-04_005622'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 40
+eval_epoch = 40
+clip_grad = None
+use_ema = True
+ema_decay = 0.999
+dataset_ratios = None
+sync_bn = False
+enable_amp = True
+amp_dtype = 'float16'
+empty_cache = False
+empty_cache_per_epoch = False
+find_unused_parameters = True
+enable_wandb = True
+wandb_project = 'Volt'
+wandb_key = None
+mix_prob = 0.2
+param_dicts = None
+hooks = [
+    dict(type='CheckpointLoader'),
+    dict(type='ModelHook'),
+    dict(type='IterationTimer', warmup_iter=2),
+    dict(type='InformationWriter'),
+    dict(type='SemSegEvaluator'),
+    dict(type='CheckpointSaver', save_freq=None),
+    dict(type='PreciseEvaluator', test_last=False)
+]
+train = dict(type='MultiDatasetTrainer')
+test = dict(type='SemSegTester', verbose=True)
+model = dict(
+    type='DefaultSegmentorV2',
+    backbone_out_channels=128,
+    backbone=dict(
+        type='Volt',
+        in_channels=4,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        init_values=None,
+        qk_norm=True,
+        drop_path=0.3,
+        stride=5,
+        kernel_size=5,
+        increase_drop_path=True,
+        up_mlp_dim=128),
+    teacher=dict(
+        type='DefaultSegmentorV2',
+        backbone=dict(
+            type='SpUNet-v1m3',
+            in_channels=4,
+            num_classes=0,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2),
+            enc_mode=False,
+            conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+            zero_init=False,
+            norm_decouple=True,
+            norm_adaptive=False,
+            norm_affine=True),
+        backbone_out_channels=96,
+        conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+        num_classes=(16, 19, 22)),
+    teacher_weights='exp/nuscenes/2026-02-25_010147/model/model_best.pth',
+    criteria=[
+        dict(
+            type='CrossEntropyLoss',
+            loss_weight=1.0,
+            label_smoothing=0.1,
+            ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ],
+    conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+    num_classes=(16, 19, 22))
+optimizer = dict(type='AdamW', lr=0.002, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=0.002,
+    pct_start=0.04,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=100.0)
+ignore_index = -1
+names = [
+    'barrier', 'bicycle', 'bus', 'car', 'construction_vehicle', 'motorcycle',
+    'pedestrian', 'traffic_cone', 'trailer', 'truck', 'driveable_surface',
+    'other_flat', 'sidewalk', 'terrain', 'manmade', 'vegetation'
+]
+data = dict(
+    num_classes=16,
+    ignore_index=-1,
+    names=[
+        'barrier', 'bicycle', 'bus', 'car', 'construction_vehicle',
+        'motorcycle', 'pedestrian', 'traffic_cone', 'trailer', 'truck',
+        'driveable_surface', 'other_flat', 'sidewalk', 'terrain', 'manmade',
+        'vegetation'
+    ],
+    train=dict(
+        type='ConcatDataset',
+        datasets=[
+            dict(
+                type='NuScenesDataset',
+                split='train',
+                data_root='data/nuscenes',
+                transform=[
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=70.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='Update', keys_dict=dict(condition='nuScenes')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=2),
+            dict(
+                type='SemanticKITTIDataset',
+                split='train',
+                data_root='data/semantic_kitti',
+                transform=[
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='InstanceCutMix',
+                        db_path='data/semantic_kitti_instances/train.h5'),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=50.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(
+                        type='RandomShift',
+                        shift=((-0.2, 0.2), (-0.2, 0.2), (-0.2, 0.2))),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(type='InstanceShift', p=0.5, shift_range=[4, 4, 0.5]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.5,
+                        axis='z',
+                        angle=[-0.5, 0.5]),
+                    dict(type='InstanceScale', p=0.5, scale=[0.9, 1.1]),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(
+                        type='Update',
+                        keys_dict=dict(condition='SemanticKITTI')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='WaymoDataset',
+                split='training',
+                data_root='data/waymo',
+                transform=[
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=75.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(
+                        type='RandomShift',
+                        shift=((-0.2, 0.2), (-0.2, 0.2), (-0.2, 0.2))),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='SphereCrop', point_max=102400, mode='random'),
+                    dict(type='Update', keys_dict=dict(condition='Waymo')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1)
+        ],
+        loop=1),
+    val=dict(
+        type='NuScenesDataset',
+        split='val',
+        data_root='data/nuscenes',
+        transform=[
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='PointClipDistance', max_dist=70.0, z_min=-4.0,
+                z_max=2.0),
+            dict(
+                type='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True,
+                return_inverse=True),
+            dict(type='Update', keys_dict=dict(condition='nuScenes')),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse', 'condition'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-1),
+    test=dict(
+        type='NuScenesDataset',
+        split='val',
+        data_root='data/nuscenes',
+        transform=[
+            dict(
+                type='PointClipDistance', max_dist=70.0, z_min=-4.0,
+                z_max=2.0),
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.025,
+                hash_type='fnv',
+                mode='train',
+                return_inverse=True)
+        ],
+        test_mode=True,
+        test_cfg=dict(
+            voxelize=dict(
+                type='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='test',
+                return_grid_coord=True),
+            crop=None,
+            post_transform=[
+                dict(type='Update', keys_dict=dict(condition='nuScenes')),
+                dict(type='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index', 'condition'),
+                    feat_keys=('coord', 'strength'))
+            ],
+            aug_transform=[[{
+                'type': 'RandomScale',
+                'scale': [0.9, 0.9]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [0.95, 0.95]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1, 1]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1.05, 1.05]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1.1, 1.1]
+            }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [0.9, 0.9]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1, 1]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1.1, 1.1]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }]]),
+        ignore_index=-1))

Volt_experiments/joint_training_small/nuscenes/model/model_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:380a2380442baf0706cac41db68f050fa8a70dcb6d623e33bde0dcd50873d4dd
+size 378004481

Volt_experiments/joint_training_small/nuscenes/model/model_last.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:be555278472ebc6cebc57203370ba9fd5917fa5f9ce2a427d722517f011b3578
+size 378004481

Volt_experiments/joint_training_small/nuscenes/train.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c41e6c0824bd49d5a6569bf6f89752a6bfdb6f92c1553a94c57ece22f2e42a0a
+size 33798056

Volt_experiments/joint_training_small/scannet/config.py

@@ -0,0 +1,536 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 10598737
+save_path = 'exp/scannet/2026-05-03_012618'
+num_worker = 96
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 500
+eval_epoch = 100
+clip_grad = None
+use_ema = True
+ema_decay = 0.999
+dataset_ratios = [1, 1, 1, 1]
+sync_bn = False
+enable_amp = True
+amp_dtype = 'float16'
+empty_cache = False
+empty_cache_per_epoch = False
+find_unused_parameters = True
+enable_wandb = True
+wandb_project = 'Volt'
+wandb_key = None
+mix_prob = 0.85
+param_dicts = None
+hooks = [
+    dict(type='CheckpointLoader'),
+    dict(type='ModelHook'),
+    dict(type='IterationTimer', warmup_iter=2),
+    dict(type='InformationWriter'),
+    dict(type='SemSegEvaluator'),
+    dict(type='CheckpointSaver', save_freq=None),
+    dict(type='PreciseEvaluator', test_last=False)
+]
+train = dict(type='DefaultTrainer')
+test = dict(type='SemSegTester', verbose=True)
+model = dict(
+    type='DefaultSegmentorV2',
+    backbone_out_channels=128,
+    backbone=dict(
+        type='Volt',
+        in_channels=6,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        init_values=None,
+        qk_norm=True,
+        drop_path=0.3,
+        stride=5,
+        kernel_size=5,
+        increase_drop_path=True,
+        up_mlp_dim=128),
+    teacher=dict(
+        type='DefaultSegmentorV2',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=6,
+            num_classes=0,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2)),
+        backbone_out_channels=96,
+        conditions=('ScanNet', 'ScanNet200', 'ScanNet++', 'ARKitScenes'),
+        num_classes=(20, 200, 100, 185)),
+    teacher_weights='exp/multi/2026-01-21_214020/model/model_best.pth',
+    criteria=[
+        dict(
+            type='CrossEntropyLoss',
+            loss_weight=1.0,
+            label_smoothing=0.1,
+            ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ],
+    conditions=('ScanNet', 'ScanNet200', 'ScanNet++', 'ARKitScenes'),
+    num_classes=(20, 200, 100, 185))
+optimizer = dict(type='AdamW', lr=0.001, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=0.001,
+    pct_start=0.05,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=1000.0)
+ignore_index = -1
+data = dict(
+    num_classes=20,
+    ignore_index=-1,
+    names=[
+        'wall', 'floor', 'cabinet', 'bed', 'chair', 'sofa', 'table', 'door',
+        'window', 'bookshelf', 'picture', 'counter', 'desk', 'curtain',
+        'refridgerator', 'shower curtain', 'toilet', 'sink', 'bathtub',
+        'otherfurniture'
+    ],
+    train=dict(
+        type='ConcatDataset',
+        datasets=[
+            dict(
+                type='ScanNetDataset',
+                split='train',
+                data_root='data/scannet',
+                transform=[
+                    dict(type='CenterShift', apply_z=True),
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='ElasticDistortion',
+                        distortion_params=[[0.2, 0.4], [0.8, 1.6]]),
+                    dict(
+                        type='ChromaticAutoContrast', p=0.2,
+                        blend_factor=None),
+                    dict(type='ChromaticTranslation', p=0.95, ratio=0.05),
+                    dict(type='ChromaticJitter', p=0.95, std=0.05),
+                    dict(
+                        type='InstanceShift',
+                        p=0.2,
+                        shift_range=[0.1, 0.1, 0.1]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.2,
+                        axis='z',
+                        angle=[-0.25, 0.25]),
+                    dict(type='InstanceFlip', p=0.2, flip_prob=0.5),
+                    dict(type='InstanceScale', p=0.2, scale=[0.9, 1.1]),
+                    dict(type='InstanceDropOut', p=0.1, drop_ratio=0.5),
+                    dict(type='InstanceColorDropout', p=0.2, drop_value=0),
+                    dict(type='SwapInstances', p=0.2),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='Update', keys_dict=dict(condition='ScanNet')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='ScanNet200Dataset',
+                split='train',
+                data_root='data/scannet',
+                transform=[
+                    dict(type='CenterShift', apply_z=True),
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='ElasticDistortion',
+                        distortion_params=[[0.2, 0.4], [0.8, 1.6]]),
+                    dict(
+                        type='ChromaticAutoContrast', p=0.2,
+                        blend_factor=None),
+                    dict(type='ChromaticTranslation', p=0.95, ratio=0.05),
+                    dict(type='ChromaticJitter', p=0.95, std=0.05),
+                    dict(
+                        type='InstanceShift',
+                        p=0.2,
+                        shift_range=[0.1, 0.1, 0.1]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.2,
+                        axis='z',
+                        angle=[-0.25, 0.25]),
+                    dict(type='InstanceFlip', p=0.2, flip_prob=0.5),
+                    dict(type='InstanceScale', p=0.2, scale=[0.9, 1.1]),
+                    dict(type='InstanceDropOut', p=0.1, drop_ratio=0.5),
+                    dict(type='InstanceColorDropout', p=0.2, drop_value=0),
+                    dict(type='SwapInstances', p=0.2),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(
+                        type='Update', keys_dict=dict(condition='ScanNet200')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='ScanNetPPDataset',
+                split='train',
+                data_root='data/scannetpp',
+                transform=[
+                    dict(type='SphereCrop', point_max=1000000, mode='random'),
+                    dict(type='CenterShift', apply_z=True),
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='ChromaticAutoContrast', p=0.2,
+                        blend_factor=None),
+                    dict(type='ChromaticTranslation', p=0.95, ratio=0.05),
+                    dict(type='ChromaticJitter', p=0.95, std=0.05),
+                    dict(
+                        type='InstanceShift',
+                        p=0.2,
+                        shift_range=[0.1, 0.1, 0.1]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.2,
+                        axis='z',
+                        angle=[-0.25, 0.25]),
+                    dict(type='InstanceFlip', p=0.2, flip_prob=0.5),
+                    dict(type='InstanceScale', p=0.2, scale=[0.9, 1.1]),
+                    dict(type='InstanceDropOut', p=0.1, drop_ratio=0.5),
+                    dict(type='InstanceColorDropout', p=0.2, drop_value=0),
+                    dict(type='SwapInstances', p=0.2),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='SphereCrop', point_max=204800, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='Update', keys_dict=dict(condition='ScanNet++')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='ARKitScenesLabelMakerDataset',
+                split=['train', 'val'],
+                data_root='data/arkitscenes',
+                transform=[
+                    dict(type='CenterShift', apply_z=True),
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='ElasticDistortion',
+                        distortion_params=[[0.2, 0.4], [0.8, 1.6]]),
+                    dict(
+                        type='ChromaticAutoContrast', p=0.2,
+                        blend_factor=None),
+                    dict(type='ChromaticTranslation', p=0.95, ratio=0.05),
+                    dict(type='ChromaticJitter', p=0.95, std=0.05),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='SphereCrop', point_max=102400, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(
+                        type='Update',
+                        keys_dict=dict(condition='ARKitScenes')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1)
+        ],
+        loop=5),
+    val=dict(
+        type='ScanNetDataset',
+        split='val',
+        data_root='data/scannet',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True,
+                return_inverse=True),
+            dict(type='CenterShift', apply_z=False),
+            dict(type='NormalizeColor'),
+            dict(type='Update', keys_dict=dict(condition='ScanNet')),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse', 'condition'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False),
+    test=dict(
+        type='ScanNetDataset',
+        split='val',
+        data_root='data/scannet',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(type='NormalizeColor')
+        ],
+        test_mode=True,
+        test_cfg=dict(
+            voxelize=dict(
+                type='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='test',
+                return_grid_coord=True),
+            crop=None,
+            post_transform=[
+                dict(type='CenterShift', apply_z=False),
+                dict(type='Update', keys_dict=dict(condition='ScanNet')),
+                dict(type='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index', 'condition'),
+                    feat_keys=('color', 'normal'))
+            ],
+            aug_transform=[[{
+                'type': 'RandomRotateTargetAngle',
+                'angle': [0],
+                'axis': 'z',
+                'center': [0, 0, 0],
+                'p': 1
+            }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }], [{
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }]])))

Volt_experiments/joint_training_small/scannet/model/model_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bcfa0f94fbe13292c059307cc87a521fbd47fc375c35b96e0e6d43fd476fba2a
+size 381395577

Volt_experiments/joint_training_small/scannet/model/model_last.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:624a426a8500997ad087e40e34d67869efbe4457b0eff49f8b61005b6eaf1680
+size 381395641

Volt_experiments/joint_training_small/scannet/train.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd326e149192d080dbf3ddba37d4d81795d6f765822f55f9c43f2a4601fc7cc3
+size 25353593

Volt_experiments/joint_training_small/scannet200/config.py

@@ -0,0 +1,544 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 50190337
+save_path = 'exp/scannet200/2026-05-03_105701'
+num_worker = 96
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 600
+eval_epoch = 100
+clip_grad = None
+use_ema = True
+ema_decay = 0.999
+dataset_ratios = [1, 1, 1]
+sync_bn = False
+enable_amp = True
+amp_dtype = 'float16'
+empty_cache = False
+empty_cache_per_epoch = False
+find_unused_parameters = True
+enable_wandb = True
+wandb_project = 'Volt'
+wandb_key = None
+mix_prob = 0.85
+param_dicts = None
+hooks = [
+    dict(type='CheckpointLoader'),
+    dict(type='ModelHook'),
+    dict(type='IterationTimer', warmup_iter=2),
+    dict(type='InformationWriter'),
+    dict(type='SemSegEvaluator'),
+    dict(type='CheckpointSaver', save_freq=None),
+    dict(type='PreciseEvaluator', test_last=False)
+]
+train = dict(type='DefaultTrainer')
+test = dict(type='SemSegTester', verbose=True)
+CLASS_LABELS_200 = (
+    'wall', 'chair', 'floor', 'table', 'door', 'couch', 'cabinet', 'shelf',
+    'desk', 'office chair', 'bed', 'pillow', 'sink', 'picture', 'window',
+    'toilet', 'bookshelf', 'monitor', 'curtain', 'book', 'armchair',
+    'coffee table', 'box', 'refrigerator', 'lamp', 'kitchen cabinet', 'towel',
+    'clothes', 'tv', 'nightstand', 'counter', 'dresser', 'stool', 'cushion',
+    'plant', 'ceiling', 'bathtub', 'end table', 'dining table', 'keyboard',
+    'bag', 'backpack', 'toilet paper', 'printer', 'tv stand', 'whiteboard',
+    'blanket', 'shower curtain', 'trash can', 'closet', 'stairs', 'microwave',
+    'stove', 'shoe', 'computer tower', 'bottle', 'bin', 'ottoman', 'bench',
+    'board', 'washing machine', 'mirror', 'copier', 'basket', 'sofa chair',
+    'file cabinet', 'fan', 'laptop', 'shower', 'paper', 'person',
+    'paper towel dispenser', 'oven', 'blinds', 'rack', 'plate', 'blackboard',
+    'piano', 'suitcase', 'rail', 'radiator', 'recycling bin', 'container',
+    'wardrobe', 'soap dispenser', 'telephone', 'bucket', 'clock', 'stand',
+    'light', 'laundry basket', 'pipe', 'clothes dryer', 'guitar',
+    'toilet paper holder', 'seat', 'speaker', 'column', 'bicycle', 'ladder',
+    'bathroom stall', 'shower wall', 'cup', 'jacket', 'storage bin',
+    'coffee maker', 'dishwasher', 'paper towel roll', 'machine', 'mat',
+    'windowsill', 'bar', 'toaster', 'bulletin board', 'ironing board',
+    'fireplace', 'soap dish', 'kitchen counter', 'doorframe',
+    'toilet paper dispenser', 'mini fridge', 'fire extinguisher', 'ball',
+    'hat', 'shower curtain rod', 'water cooler', 'paper cutter', 'tray',
+    'shower door', 'pillar', 'ledge', 'toaster oven', 'mouse',
+    'toilet seat cover dispenser', 'furniture', 'cart', 'storage container',
+    'scale', 'tissue box', 'light switch', 'crate', 'power outlet',
+    'decoration', 'sign', 'projector', 'closet door', 'vacuum cleaner',
+    'candle', 'plunger', 'stuffed animal', 'headphones', 'dish rack', 'broom',
+    'guitar case', 'range hood', 'dustpan', 'hair dryer', 'water bottle',
+    'handicap bar', 'purse', 'vent', 'shower floor', 'water pitcher',
+    'mailbox', 'bowl', 'paper bag', 'alarm clock', 'music stand',
+    'projector screen', 'divider', 'laundry detergent', 'bathroom counter',
+    'object', 'bathroom vanity', 'closet wall', 'laundry hamper',
+    'bathroom stall door', 'ceiling light', 'trash bin', 'dumbbell',
+    'stair rail', 'tube', 'bathroom cabinet', 'cd case', 'closet rod',
+    'coffee kettle', 'structure', 'shower head', 'keyboard piano',
+    'case of water bottles', 'coat rack', 'storage organizer', 'folded chair',
+    'fire alarm', 'power strip', 'calendar', 'poster', 'potted plant',
+    'luggage', 'mattress')
+model = dict(
+    type='DefaultSegmentorV2',
+    backbone_out_channels=128,
+    backbone=dict(
+        type='Volt',
+        in_channels=6,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        init_values=None,
+        qk_norm=True,
+        drop_path=0.3,
+        stride=5,
+        kernel_size=5,
+        increase_drop_path=True,
+        up_mlp_dim=128),
+    teacher=dict(
+        type='DefaultSegmentorV2',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=6,
+            num_classes=0,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2)),
+        backbone_out_channels=96,
+        conditions=('ScanNet', 'ScanNet200', 'ScanNet++', 'ARKitScenes'),
+        num_classes=(20, 200, 100, 185)),
+    teacher_weights='exp/multi/2026-01-21_214020/model/model_best.pth',
+    criteria=[
+        dict(
+            type='CrossEntropyLoss',
+            loss_weight=1.0,
+            label_smoothing=0.1,
+            ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ],
+    conditions=('ScanNet', 'ScanNet200', 'ScanNet++', 'ARKitScenes'),
+    num_classes=(20, 200, 100, 185))
+optimizer = dict(type='AdamW', lr=0.001, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=0.001,
+    pct_start=0.05,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=1000.0)
+ignore_index = -1
+data = dict(
+    num_classes=200,
+    ignore_index=-1,
+    names=(
+        'wall', 'chair', 'floor', 'table', 'door', 'couch', 'cabinet', 'shelf',
+        'desk', 'office chair', 'bed', 'pillow', 'sink', 'picture', 'window',
+        'toilet', 'bookshelf', 'monitor', 'curtain', 'book', 'armchair',
+        'coffee table', 'box', 'refrigerator', 'lamp', 'kitchen cabinet',
+        'towel', 'clothes', 'tv', 'nightstand', 'counter', 'dresser', 'stool',
+        'cushion', 'plant', 'ceiling', 'bathtub', 'end table', 'dining table',
+        'keyboard', 'bag', 'backpack', 'toilet paper', 'printer', 'tv stand',
+        'whiteboard', 'blanket', 'shower curtain', 'trash can', 'closet',
+        'stairs', 'microwave', 'stove', 'shoe', 'computer tower', 'bottle',
+        'bin', 'ottoman', 'bench', 'board', 'washing machine', 'mirror',
+        'copier', 'basket', 'sofa chair', 'file cabinet', 'fan', 'laptop',
+        'shower', 'paper', 'person', 'paper towel dispenser', 'oven', 'blinds',
+        'rack', 'plate', 'blackboard', 'piano', 'suitcase', 'rail', 'radiator',
+        'recycling bin', 'container', 'wardrobe', 'soap dispenser',
+        'telephone', 'bucket', 'clock', 'stand', 'light', 'laundry basket',
+        'pipe', 'clothes dryer', 'guitar', 'toilet paper holder', 'seat',
+        'speaker', 'column', 'bicycle', 'ladder', 'bathroom stall',
+        'shower wall', 'cup', 'jacket', 'storage bin', 'coffee maker',
+        'dishwasher', 'paper towel roll', 'machine', 'mat', 'windowsill',
+        'bar', 'toaster', 'bulletin board', 'ironing board', 'fireplace',
+        'soap dish', 'kitchen counter', 'doorframe', 'toilet paper dispenser',
+        'mini fridge', 'fire extinguisher', 'ball', 'hat',
+        'shower curtain rod', 'water cooler', 'paper cutter', 'tray',
+        'shower door', 'pillar', 'ledge', 'toaster oven', 'mouse',
+        'toilet seat cover dispenser', 'furniture', 'cart',
+        'storage container', 'scale', 'tissue box', 'light switch', 'crate',
+        'power outlet', 'decoration', 'sign', 'projector', 'closet door',
+        'vacuum cleaner', 'candle', 'plunger', 'stuffed animal', 'headphones',
+        'dish rack', 'broom', 'guitar case', 'range hood', 'dustpan',
+        'hair dryer', 'water bottle', 'handicap bar', 'purse', 'vent',
+        'shower floor', 'water pitcher', 'mailbox', 'bowl', 'paper bag',
+        'alarm clock', 'music stand', 'projector screen', 'divider',
+        'laundry detergent', 'bathroom counter', 'object', 'bathroom vanity',
+        'closet wall', 'laundry hamper', 'bathroom stall door',
+        'ceiling light', 'trash bin', 'dumbbell', 'stair rail', 'tube',
+        'bathroom cabinet', 'cd case', 'closet rod', 'coffee kettle',
+        'structure', 'shower head', 'keyboard piano', 'case of water bottles',
+        'coat rack', 'storage organizer', 'folded chair', 'fire alarm',
+        'power strip', 'calendar', 'poster', 'potted plant', 'luggage',
+        'mattress'),
+    train=dict(
+        type='ConcatDataset',
+        datasets=[
+            dict(
+                type='ScanNet200Dataset',
+                split='train',
+                data_root='data/scannet',
+                transform=[
+                    dict(type='CenterShift', apply_z=True),
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='ElasticDistortion',
+                        distortion_params=[[0.2, 0.4], [0.8, 1.6]]),
+                    dict(
+                        type='ChromaticAutoContrast', p=0.2,
+                        blend_factor=None),
+                    dict(type='ChromaticTranslation', p=0.95, ratio=0.05),
+                    dict(type='ChromaticJitter', p=0.95, std=0.05),
+                    dict(
+                        type='InstanceShift',
+                        p=0.2,
+                        shift_range=[0.1, 0.1, 0.1]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.2,
+                        axis='z',
+                        angle=[-0.25, 0.25]),
+                    dict(type='InstanceFlip', p=0.2, flip_prob=0.5),
+                    dict(type='InstanceScale', p=0.2, scale=[0.9, 1.1]),
+                    dict(type='InstanceDropOut', p=0.1, drop_ratio=0.5),
+                    dict(type='InstanceColorDropout', p=0.2, drop_value=0),
+                    dict(type='SwapInstances', p=0.2),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(
+                        type='Update', keys_dict=dict(condition='ScanNet200')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='ScanNetPPDataset',
+                split='train',
+                data_root='data/scannetpp',
+                transform=[
+                    dict(type='SphereCrop', point_max=1000000, mode='random'),
+                    dict(type='CenterShift', apply_z=True),
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='ChromaticAutoContrast', p=0.2,
+                        blend_factor=None),
+                    dict(type='ChromaticTranslation', p=0.95, ratio=0.05),
+                    dict(type='ChromaticJitter', p=0.95, std=0.05),
+                    dict(
+                        type='InstanceShift',
+                        p=0.2,
+                        shift_range=[0.1, 0.1, 0.1]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.2,
+                        axis='z',
+                        angle=[-0.25, 0.25]),
+                    dict(type='InstanceFlip', p=0.2, flip_prob=0.5),
+                    dict(type='InstanceScale', p=0.2, scale=[0.9, 1.1]),
+                    dict(type='InstanceDropOut', p=0.1, drop_ratio=0.5),
+                    dict(type='InstanceColorDropout', p=0.2, drop_value=0),
+                    dict(type='SwapInstances', p=0.2),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='SphereCrop', point_max=204800, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='Update', keys_dict=dict(condition='ScanNet++')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='ARKitScenesLabelMakerDataset',
+                split=['train', 'val'],
+                data_root='data/arkitscenes',
+                transform=[
+                    dict(type='CenterShift', apply_z=True),
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='ElasticDistortion',
+                        distortion_params=[[0.2, 0.4], [0.8, 1.6]]),
+                    dict(
+                        type='ChromaticAutoContrast', p=0.2,
+                        blend_factor=None),
+                    dict(type='ChromaticTranslation', p=0.95, ratio=0.05),
+                    dict(type='ChromaticJitter', p=0.95, std=0.05),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='SphereCrop', point_max=102400, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(
+                        type='Update',
+                        keys_dict=dict(condition='ARKitScenes')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1)
+        ],
+        loop=6),
+    val=dict(
+        type='ScanNet200Dataset',
+        split='val',
+        data_root='data/scannet',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True,
+                return_inverse=True),
+            dict(type='CenterShift', apply_z=False),
+            dict(type='NormalizeColor'),
+            dict(type='Update', keys_dict=dict(condition='ScanNet200')),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse', 'condition'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False),
+    test=dict(
+        type='ScanNet200Dataset',
+        split='val',
+        data_root='data/scannet',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(type='NormalizeColor')
+        ],
+        test_mode=True,
+        test_cfg=dict(
+            voxelize=dict(
+                type='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='test',
+                return_grid_coord=True),
+            crop=None,
+            post_transform=[
+                dict(type='CenterShift', apply_z=False),
+                dict(type='Update', keys_dict=dict(condition='ScanNet200')),
+                dict(type='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index', 'condition'),
+                    feat_keys=('color', 'normal'))
+            ],
+            aug_transform=[[{
+                'type': 'RandomRotateTargetAngle',
+                'angle': [0],
+                'axis': 'z',
+                'center': [0, 0, 0],
+                'p': 1
+            }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [0.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }],
+                           [{
+                               'type': 'RandomRotateTargetAngle',
+                               'angle': [1.5],
+                               'axis': 'z',
+                               'center': [0, 0, 0],
+                               'p': 1
+                           }, {
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }], [{
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }]])))
+num_worker_per_gpu = 12
+batch_size_per_gpu = 2
+batch_size_val_per_gpu = 1
+batch_size_test_per_gpu = 1

Volt_experiments/joint_training_small/scannet200/model/model_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bd634d0d1b5918668bc3a02bd5e4737d8a2ac66fd303cf3acbfaac7c6130e0f1
+size 381350961

Volt_experiments/joint_training_small/scannet200/model/model_last.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b7e8cdfaa83bfa45911682002244774601a82d3d86c42072baa781da92ebf9d
+size 381350961

Volt_experiments/joint_training_small/scannet200/train.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1db212fb19e5aa51ebc6d1a1b3a0809fc6c7c0fddb963247315140b6c67d193f
+size 25176805

Volt_experiments/joint_training_small/semantic_kitti/config.py

@@ -0,0 +1,398 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 53039635
+save_path = 'exp/semantic_kitti/2026-04-28_232453'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 30
+eval_epoch = 30
+clip_grad = None
+use_ema = True
+ema_decay = 0.999
+sync_bn = False
+enable_amp = True
+amp_dtype = 'float16'
+empty_cache = False
+empty_cache_per_epoch = False
+find_unused_parameters = True
+enable_wandb = True
+wandb_project = 'Volt'
+wandb_key = None
+mix_prob = 0.5
+param_dicts = None
+hooks = [
+    dict(type='CheckpointLoader'),
+    dict(type='ModelHook'),
+    dict(type='IterationTimer', warmup_iter=2),
+    dict(type='InformationWriter'),
+    dict(type='SemSegEvaluator'),
+    dict(type='CheckpointSaver', save_freq=None),
+    dict(type='PreciseEvaluator', test_last=False)
+]
+train = dict(type='MultiDatasetTrainer')
+test = dict(type='SemSegTester', verbose=True)
+model = dict(
+    type='DefaultSegmentorV2',
+    backbone_out_channels=128,
+    backbone=dict(
+        type='Volt',
+        in_channels=4,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        init_values=None,
+        qk_norm=True,
+        drop_path=0.3,
+        stride=5,
+        kernel_size=5,
+        increase_drop_path=True,
+        up_mlp_dim=128),
+    teacher=dict(
+        type='DefaultSegmentorV2',
+        backbone=dict(
+            type='SpUNet-v1m3',
+            in_channels=4,
+            num_classes=0,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2),
+            enc_mode=False,
+            conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+            zero_init=False,
+            norm_decouple=True,
+            norm_adaptive=False,
+            norm_affine=True),
+        backbone_out_channels=96,
+        conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+        num_classes=(16, 19, 22)),
+    teacher_weights='exp/nuscenes/2026-02-25_010147/model/model_best.pth',
+    criteria=[
+        dict(
+            type='CrossEntropyLoss',
+            loss_weight=1.0,
+            label_smoothing=0.1,
+            ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ],
+    conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+    num_classes=(16, 19, 22))
+optimizer = dict(type='AdamW', lr=0.002, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=0.002,
+    pct_start=0.04,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=100.0)
+ignore_index = -1
+names = [
+    'car', 'bicycle', 'motorcycle', 'truck', 'other-vehicle', 'person',
+    'bicyclist', 'motorcyclist', 'road', 'parking', 'sidewalk', 'other-ground',
+    'building', 'fence', 'vegetation', 'trunk', 'terrain', 'pole',
+    'traffic-sign'
+]
+data = dict(
+    num_classes=19,
+    ignore_index=-1,
+    names=[
+        'car', 'bicycle', 'motorcycle', 'truck', 'other-vehicle', 'person',
+        'bicyclist', 'motorcyclist', 'road', 'parking', 'sidewalk',
+        'other-ground', 'building', 'fence', 'vegetation', 'trunk', 'terrain',
+        'pole', 'traffic-sign'
+    ],
+    train=dict(
+        type='ConcatDataset',
+        datasets=[
+            dict(
+                type='SemanticKITTIDataset',
+                split='train',
+                data_root='data/semantic_kitti',
+                transform=[
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='InstanceCutMix',
+                        db_path='data/semantic_kitti_instances/train.h5'),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=50.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(
+                        type='RandomShift',
+                        shift=((-0.2, 0.2), (-0.2, 0.2), (-0.2, 0.2))),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(type='InstanceShift', p=0.5, shift_range=[4, 4, 0.5]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.5,
+                        axis='z',
+                        angle=[-0.5, 0.5]),
+                    dict(type='InstanceScale', p=0.5, scale=[0.9, 1.1]),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(
+                        type='Update',
+                        keys_dict=dict(condition='SemanticKITTI')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='WaymoDataset',
+                split='training',
+                data_root='data/waymo',
+                transform=[
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=75.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(
+                        type='RandomShift',
+                        shift=((-0.2, 0.2), (-0.2, 0.2), (-0.2, 0.2))),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='SphereCrop', point_max=102400, mode='random'),
+                    dict(type='Update', keys_dict=dict(condition='Waymo')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='NuScenesDataset',
+                split='train',
+                data_root='data/nuscenes',
+                transform=[
+                    dict(
+                        type='RandomRotateTargetAngle',
+                        angle=[-0.5],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=1),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=70.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='Update', keys_dict=dict(condition='nuScenes')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=2)
+        ],
+        loop=1),
+    val=dict(
+        type='SemanticKITTIDataset',
+        split='val',
+        data_root='data/semantic_kitti',
+        transform=[
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='PointClipDistance', max_dist=50.0, z_min=-4.0,
+                z_max=2.0),
+            dict(
+                type='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True,
+                return_inverse=True),
+            dict(type='Update', keys_dict=dict(condition='SemanticKITTI')),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse', 'condition'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-1),
+    test=dict(
+        type='SemanticKITTIDataset',
+        split='val',
+        data_root='data/semantic_kitti',
+        transform=[
+            dict(
+                type='PointClipDistance', max_dist=50.0, z_min=-4.0,
+                z_max=2.0),
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.025,
+                hash_type='fnv',
+                mode='train',
+                return_inverse=True)
+        ],
+        test_mode=True,
+        test_cfg=dict(
+            voxelize=dict(
+                type='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='test',
+                return_grid_coord=True),
+            crop=None,
+            post_transform=[
+                dict(type='Update', keys_dict=dict(condition='SemanticKITTI')),
+                dict(type='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index', 'condition'),
+                    feat_keys=('coord', 'strength'))
+            ],
+            aug_transform=[[{
+                'type': 'RandomScale',
+                'scale': [0.9, 0.9]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [0.95, 0.95]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1, 1]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1.05, 1.05]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1.1, 1.1]
+            }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [0.9, 0.9]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1, 1]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1.1, 1.1]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }]]),
+        ignore_index=-1))

Volt_experiments/joint_training_small/semantic_kitti/model/model_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9d326a7b2e62f94a1021d18f5dad9eb13070f42b65877812fe68b6b3ff101f50
+size 378004481

Volt_experiments/joint_training_small/semantic_kitti/model/model_last.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4145f6ec18427f30ed583f21d38d1a7bf6a6a47d169400b255c6cff95314dbac
+size 378006849

Volt_experiments/joint_training_small/semantic_kitti/train.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a04c18271095423c75f6087c67ff1325ad911cba3de867726fb9b36e94db1433
+size 29370538

Volt_experiments/joint_training_small/waymo/config.py

@@ -0,0 +1,398 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 56946903
+save_path = 'exp/waymo/2026-05-05_095255'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 25
+eval_epoch = 25
+clip_grad = None
+use_ema = True
+ema_decay = 0.999
+dataset_ratios = None
+sync_bn = False
+enable_amp = True
+amp_dtype = 'float16'
+empty_cache = False
+empty_cache_per_epoch = False
+find_unused_parameters = True
+enable_wandb = True
+wandb_project = 'Volt'
+wandb_key = None
+mix_prob = 0.2
+param_dicts = None
+hooks = [
+    dict(type='CheckpointLoader'),
+    dict(type='ModelHook'),
+    dict(type='IterationTimer', warmup_iter=2),
+    dict(type='InformationWriter'),
+    dict(type='SemSegEvaluator'),
+    dict(type='CheckpointSaver', save_freq=None),
+    dict(type='PreciseEvaluator', test_last=False)
+]
+train = dict(type='MultiDatasetTrainer')
+test = dict(type='SemSegTester', verbose=True)
+model = dict(
+    type='DefaultSegmentorV2',
+    backbone_out_channels=128,
+    backbone=dict(
+        type='Volt',
+        in_channels=4,
+        embed_dim=384,
+        depth=12,
+        num_heads=6,
+        mlp_ratio=4,
+        init_values=None,
+        qk_norm=True,
+        drop_path=0.3,
+        stride=5,
+        kernel_size=5,
+        increase_drop_path=True,
+        up_mlp_dim=128),
+    teacher=dict(
+        type='DefaultSegmentorV2',
+        backbone=dict(
+            type='SpUNet-v1m3',
+            in_channels=4,
+            num_classes=0,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2),
+            enc_mode=False,
+            conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+            zero_init=False,
+            norm_decouple=True,
+            norm_adaptive=False,
+            norm_affine=True),
+        backbone_out_channels=96,
+        conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+        num_classes=(16, 19, 22)),
+    teacher_weights='exp/nuscenes/2026-02-25_010147/model/model_best.pth',
+    criteria=[
+        dict(
+            type='CrossEntropyLoss',
+            loss_weight=1.0,
+            label_smoothing=0.1,
+            ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ],
+    conditions=('nuScenes', 'SemanticKITTI', 'Waymo'),
+    num_classes=(16, 19, 22))
+optimizer = dict(type='AdamW', lr=0.002, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=0.002,
+    pct_start=0.04,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=100.0)
+ignore_index = -1
+names = [
+    'Car', 'Truck', 'Bus', 'Other Vehicle', 'Motorcyclist', 'Bicyclist',
+    'Pedestrian', 'Sign', 'Traffic Light', 'Pole', 'Construction Cone',
+    'Bicycle', 'Motorcycle', 'Building', 'Vegetation', 'Tree Trunk', 'Curb',
+    'Road', 'Lane Marker', 'Other Ground', 'Walkable', 'Sidewalk'
+]
+data = dict(
+    num_classes=22,
+    ignore_index=-1,
+    names=[
+        'Car', 'Truck', 'Bus', 'Other Vehicle', 'Motorcyclist', 'Bicyclist',
+        'Pedestrian', 'Sign', 'Traffic Light', 'Pole', 'Construction Cone',
+        'Bicycle', 'Motorcycle', 'Building', 'Vegetation', 'Tree Trunk',
+        'Curb', 'Road', 'Lane Marker', 'Other Ground', 'Walkable', 'Sidewalk'
+    ],
+    train=dict(
+        type='ConcatDataset',
+        datasets=[
+            dict(
+                type='WaymoDataset',
+                split='training',
+                data_root='data/waymo',
+                transform=[
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=75.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(
+                        type='RandomShift',
+                        shift=((-0.2, 0.2), (-0.2, 0.2), (-0.2, 0.2))),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='Update', keys_dict=dict(condition='Waymo')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='SemanticKITTIDataset',
+                split='train',
+                data_root='data/semantic_kitti',
+                transform=[
+                    dict(
+                        type='RandomDropout',
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2),
+                    dict(
+                        type='InstanceCutMix',
+                        db_path='data/semantic_kitti_instances/train.h5'),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=50.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(
+                        type='RandomShift',
+                        shift=((-0.2, 0.2), (-0.2, 0.2), (-0.2, 0.2))),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(type='InstanceShift', p=0.5, shift_range=[4, 4, 0.5]),
+                    dict(
+                        type='InstanceRotate',
+                        p=0.5,
+                        axis='z',
+                        angle=[-0.5, 0.5]),
+                    dict(type='InstanceScale', p=0.5, scale=[0.9, 1.1]),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(
+                        type='Update',
+                        keys_dict=dict(condition='SemanticKITTI')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=1),
+            dict(
+                type='NuScenesDataset',
+                split='train',
+                data_root='data/nuscenes',
+                transform=[
+                    dict(
+                        type='RandomRotateTargetAngle',
+                        angle=[-0.5],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=1),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-1, 1],
+                        axis='z',
+                        center=[0, 0, 0],
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='x',
+                        p=0.5),
+                    dict(
+                        type='RandomRotate',
+                        angle=[-0.015625, 0.015625],
+                        axis='y',
+                        p=0.5),
+                    dict(
+                        type='PointClipDistance',
+                        max_dist=70.0,
+                        z_min=-4.0,
+                        z_max=2.0),
+                    dict(type='RandomScale', scale=[0.9, 1.1]),
+                    dict(type='RandomFlip', p=0.5),
+                    dict(type='RandomJitter', sigma=0.005, clip=0.02),
+                    dict(
+                        type='GridSample',
+                        grid_size=0.05,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', sample_rate=0.6, mode='random'),
+                    dict(type='Update', keys_dict=dict(condition='nuScenes')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('coord', 'strength'))
+                ],
+                test_mode=False,
+                ignore_index=-1,
+                loop=2)
+        ],
+        loop=1),
+    val=dict(
+        type='WaymoDataset',
+        split='validation',
+        data_root='data/waymo',
+        transform=[
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='PointClipDistance', max_dist=75.0, z_min=-4.0,
+                z_max=2.0),
+            dict(
+                type='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True,
+                return_inverse=True),
+            dict(type='Update', keys_dict=dict(condition='Waymo')),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse', 'condition'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-1),
+    test=dict(
+        type='WaymoDataset',
+        split='validation',
+        data_root='data/waymo',
+        transform=[
+            dict(
+                type='PointClipDistance', max_dist=75.0, z_min=-4.0,
+                z_max=2.0),
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.025,
+                hash_type='fnv',
+                mode='train',
+                return_inverse=True)
+        ],
+        test_mode=True,
+        test_cfg=dict(
+            voxelize=dict(
+                type='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='test',
+                return_grid_coord=True),
+            crop=None,
+            post_transform=[
+                dict(type='Update', keys_dict=dict(condition='Waymo')),
+                dict(type='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index', 'condition'),
+                    feat_keys=('coord', 'strength'))
+            ],
+            aug_transform=[[{
+                'type': 'RandomScale',
+                'scale': [0.9, 0.9]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [0.95, 0.95]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1, 1]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1.05, 1.05]
+            }], [{
+                'type': 'RandomScale',
+                'scale': [1.1, 1.1]
+            }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [0.9, 0.9]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [0.95, 0.95]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1, 1]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1.05, 1.05]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }],
+                           [{
+                               'type': 'RandomScale',
+                               'scale': [1.1, 1.1]
+                           }, {
+                               'type': 'RandomFlip',
+                               'p': 1
+                           }]]),
+        ignore_index=-1))

Volt_experiments/joint_training_small/waymo/model/model_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92b545fa79952b16728dac82f77f3d5ee9a1bed751e2b7c0d191f94ae696da2f
+size 378006849

Volt_experiments/joint_training_small/waymo/model/model_last.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:92b545fa79952b16728dac82f77f3d5ee9a1bed751e2b7c0d191f94ae696da2f
+size 378006849

Volt_experiments/joint_training_small/waymo/train.log

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63eb6ca8c684fd5004a21a96ed3760614fd40b919891a4e7b640ca318b4a281d
+size 35180982