Add single-dataset Volt experiment outputs

.gitattributes

@@ -33,3 +33,7 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Volt_experiments/single_dataset/nuscenes/train.log filter=lfs diff=lfs merge=lfs -text
+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/single_dataset/nuscenes/config.py

@@ -0,0 +1,254 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 38847342
+save_path = 'exp/nuscenes/2026-04-24_120759'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 50
+eval_epoch = 50
+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 = False
+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',
+    num_classes=16,
+    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='DefaultSegmentor',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=4,
+            num_classes=16,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2))),
+    teacher_weights='weights/teacher_weights/nuscenes_unet_teacher.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)
+    ])
+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)
+dataset_type = 'NuScenesDataset'
+data_root = 'data/nuscenes'
+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='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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse'),
+                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='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index'),
+                    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/single_dataset/nuscenes/model/model_best.pth

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

Volt_experiments/single_dataset/nuscenes/model/model_last.pth

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

Volt_experiments/single_dataset/nuscenes/train.log

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

Volt_experiments/single_dataset/scannet/config.py

@@ -0,0 +1,315 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 37898871
+save_path = 'exp/scannet/2026-04-24_120048'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 800
+eval_epoch = 100
+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 = False
+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',
+    num_classes=20,
+    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='DefaultSegmentor',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=6,
+            num_classes=20,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2))),
+    teacher_weights='weights/teacher_weights/scannet_unet_teacher.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)
+    ])
+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)
+dataset_type = 'ScanNetDataset'
+data_root = 'data/scannet'
+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='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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False,
+        loop=8),
+    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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse'),
+                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='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index'),
+                    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/single_dataset/scannet/model/model_best.pth

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

Volt_experiments/single_dataset/scannet/model/model_last.pth

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

Volt_experiments/single_dataset/scannet/train.log

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

Volt_experiments/single_dataset/scannet200/config.py

@@ -0,0 +1,389 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 7980693
+save_path = 'exp/scannet200/2026-04-23_205124'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 800
+eval_epoch = 100
+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 = False
+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',
+    num_classes=200,
+    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='DefaultSegmentor',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=6,
+            num_classes=200,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2))),
+    teacher_weights='weights/teacher_weights/scannet200_unet_teacher.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)
+    ])
+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)
+dataset_type = 'ScanNet200Dataset'
+data_root = 'data/scannet'
+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='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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False,
+        loop=8),
+    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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse'),
+                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='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index'),
+                    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/single_dataset/scannet200/model/model_best.pth

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

Volt_experiments/single_dataset/scannet200/model/model_last.pth

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

Volt_experiments/single_dataset/scannet200/train.log

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

Volt_experiments/single_dataset/scannetpp/config.py

@@ -0,0 +1,354 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 20286765
+save_path = 'exp/scannetpp/2026-04-22_112552'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 800
+eval_epoch = 100
+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 = False
+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_names = [
+    'wall', 'ceiling', 'floor', 'table', 'door', 'ceiling lamp', 'cabinet',
+    'blinds', 'curtain', 'chair', 'storage cabinet', 'office chair',
+    'bookshelf', 'whiteboard', 'window', 'box', 'window frame', 'monitor',
+    'shelf', 'doorframe', 'pipe', 'heater', 'kitchen cabinet', 'sofa',
+    'windowsill', 'bed', 'shower wall', 'trash can', 'book', 'plant',
+    'blanket', 'tv', 'computer tower', 'kitchen counter', 'refrigerator',
+    'jacket', 'electrical duct', 'sink', 'bag', 'picture', 'pillow', 'towel',
+    'suitcase', 'backpack', 'crate', 'keyboard', 'rack', 'toilet', 'paper',
+    'printer', 'poster', 'painting', 'microwave', 'board', 'shoes', 'socket',
+    'bottle', 'bucket', 'cushion', 'basket', 'shoe rack', 'telephone',
+    'file folder', 'cloth', 'blind rail', 'laptop', 'plant pot', 'exhaust fan',
+    'cup', 'coat hanger', 'light switch', 'speaker', 'table lamp', 'air vent',
+    'clothes hanger', 'kettle', 'smoke detector', 'container', 'power strip',
+    'slippers', 'paper bag', 'mouse', 'cutting board', 'toilet paper',
+    'paper towel', 'pot', 'clock', 'pan', 'tap', 'jar', 'soap dispenser',
+    'binder', 'bowl', 'tissue box', 'whiteboard eraser', 'toilet brush',
+    'spray bottle', 'headphones', 'stapler', 'marker'
+]
+data = dict(
+    names=[
+        'wall', 'ceiling', 'floor', 'table', 'door', 'ceiling lamp', 'cabinet',
+        'blinds', 'curtain', 'chair', 'storage cabinet', 'office chair',
+        'bookshelf', 'whiteboard', 'window', 'box', 'window frame', 'monitor',
+        'shelf', 'doorframe', 'pipe', 'heater', 'kitchen cabinet', 'sofa',
+        'windowsill', 'bed', 'shower wall', 'trash can', 'book', 'plant',
+        'blanket', 'tv', 'computer tower', 'kitchen counter', 'refrigerator',
+        'jacket', 'electrical duct', 'sink', 'bag', 'picture', 'pillow',
+        'towel', 'suitcase', 'backpack', 'crate', 'keyboard', 'rack', 'toilet',
+        'paper', 'printer', 'poster', 'painting', 'microwave', 'board',
+        'shoes', 'socket', 'bottle', 'bucket', 'cushion', 'basket',
+        'shoe rack', 'telephone', 'file folder', 'cloth', 'blind rail',
+        'laptop', 'plant pot', 'exhaust fan', 'cup', 'coat hanger',
+        'light switch', 'speaker', 'table lamp', 'air vent', 'clothes hanger',
+        'kettle', 'smoke detector', 'container', 'power strip', 'slippers',
+        'paper bag', 'mouse', 'cutting board', 'toilet paper', 'paper towel',
+        'pot', 'clock', 'pan', 'tap', 'jar', 'soap dispenser', 'binder',
+        'bowl', 'tissue box', 'whiteboard eraser', 'toilet brush',
+        'spray bottle', 'headphones', 'stapler', 'marker'
+    ],
+    num_classes=100,
+    ignore_index=-1,
+    train=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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False,
+        loop=8),
+    val=dict(
+        type='ScanNetPPDataset',
+        split='val',
+        data_root='data/scannetpp',
+        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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False),
+    test=dict(
+        type='ScanNetPPDataset',
+        split='val',
+        data_root='data/scannetpp',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(type='NormalizeColor'),
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.01,
+                hash_type='fnv',
+                mode='train',
+                return_inverse=True)
+        ],
+        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='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index'),
+                    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
+                           }]])))
+model = dict(
+    type='DefaultSegmentorV2',
+    num_classes=100,
+    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='DefaultSegmentor',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=6,
+            num_classes=100,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2))),
+    teacher_weights='weights/scannetpp_unet_teacher.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)
+    ])
+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)
+dataset_type = 'ScanNetPPDataset'
+data_root = 'data/scannetpp'

Volt_experiments/single_dataset/scannetpp/model/model_best.pth

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

Volt_experiments/single_dataset/scannetpp/model/model_last.pth

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

Volt_experiments/single_dataset/semantic_kitti/config.py

@@ -0,0 +1,273 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 34972726
+save_path = 'exp/semantic_kitti/2026-04-24_202427'
+num_worker = 24
+batch_size = 16
+gradient_accumulation_steps = 1
+batch_size_val = None
+batch_size_test = None
+epoch = 20
+eval_epoch = 20
+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 = False
+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',
+    num_classes=19,
+    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='DefaultSegmentor',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=4,
+            num_classes=19,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2))),
+    teacher_weights='weights/teacher_weights/semantic_kitti_unet_teacher.pth',
+    criteria=[
+        dict(
+            type='CrossEntropyLoss',
+            weight=[
+                3.1557, 8.7029, 7.8281, 6.1354, 6.3161, 7.9937, 8.9704,
+                10.1922, 1.6155, 4.2187, 1.9385, 5.5455, 2.0198, 2.6261,
+                1.3212, 5.1102, 2.5492, 5.8585, 7.3929
+            ],
+            loss_weight=1.0,
+            label_smoothing=0.1,
+            ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ])
+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)
+dataset_type = 'SemanticKITTIDataset'
+data_root = 'data/semantic_kitti'
+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='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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-1,
+        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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse'),
+                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='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index'),
+                    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/single_dataset/semantic_kitti/model/model_best.pth

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

Volt_experiments/single_dataset/semantic_kitti/model/model_last.pth

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

Volt_experiments/single_dataset/waymo/config.py

@@ -0,0 +1,263 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 47918425
+save_path = 'exp/waymo/2026-04-24_121009'
+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 = False
+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='DefaultTrainer')
+test = dict(type='SemSegTester', verbose=True)
+model = dict(
+    type='DefaultSegmentorV2',
+    num_classes=22,
+    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='DefaultSegmentor',
+        backbone=dict(
+            type='SpUNet-v1m1',
+            in_channels=4,
+            num_classes=22,
+            channels=(32, 64, 128, 256, 256, 128, 96, 96),
+            layers=(2, 3, 4, 6, 2, 2, 2, 2))),
+    teacher_weights='weights/teacher_weights/waymo_unet_teacher.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)
+    ])
+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)
+dataset_type = 'WaymoDataset'
+data_root = 'data/waymo'
+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='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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-1,
+        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='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', 'origin_segment',
+                      'inverse'),
+                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='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index'),
+                    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/single_dataset/waymo/model/model_best.pth

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

Volt_experiments/single_dataset/waymo/model/model_last.pth

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

Volt_experiments/single_dataset/waymo/train.log

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