Release experiment records

.gitattributes

@@ -33,3 +33,10 @@ 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
+nuscenes-semseg-pt-v3m1-0-base/train.log filter=lfs diff=lfs merge=lfs -text
+s3dis-semseg-pt-v3m1-0-rpe/train.log filter=lfs diff=lfs merge=lfs -text
+scannet-semseg-pt-v3m1-0-base/train.log filter=lfs diff=lfs merge=lfs -text
+scannet200-semseg-pt-v3m1-0-base/train.log filter=lfs diff=lfs merge=lfs -text
+s3dis-semseg-pt-v3m1-1-ppt-extreme/train.log filter=lfs diff=lfs merge=lfs -text
+scannet-semseg-pt-v3m1-1-ppt-extreme/train.log filter=lfs diff=lfs merge=lfs -text
+waymo-semseg-pt-v3m1-0-base/train.log filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,25 @@
 ---
 license: mit
 ---
+
+## Model Zoo
+### 1. Indoor semantic segmentation
+| Model | Benchmark | Additional Data | Num GPUs | Val mIoU | Config | Tensorboard | Exp Record |
+| :---: | :---: |:---------------:| :---: | :---: | :---: | :---: | :---: |
+| PTv3 | ScanNet |     ✗     | 4 | 77.6% | [link](https://github.com/Pointcept/Pointcept/blob/main/configs/scannet/semseg-pt-v3m1-0-base.py) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tensorboard) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tree/main/scannet-semseg-pt-v3m1-0-base) |
+| PTv3 + PPT | ScanNet |     ✓     | 8 | 78.5% | [link](https://github.com/Pointcept/Pointcept/blob/main/configs/scannet/semseg-pt-v3m1-1-ppt-extreme.py) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tensorboard) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tree/main/scannet-semseg-pt-v3m1-1-ppt-extreme) |
+| PTv3 | ScanNet200 |     ✗     | 4 | 35.3% | [link](https://github.com/Pointcept/Pointcept/blob/main/configs/scannet200/semseg-pt-v3m1-0-base.py) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tensorboard) |[link](https://huggingface.co/Pointcept/PointTransformerV3/tree/main/scannet200-semseg-pt-v3m1-0-base)|
+| PTv3 + PPT | ScanNet200 | ✓ (f.t.)  | 4 |  |  |  |  |
+| PTv3 | S3DIS (Area5) |     ✗     | 4 | 73.6% | [link](https://github.com/Pointcept/Pointcept/blob/main/configs/s3dis/semseg-pt-v3m1-0-rpe.py) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tensorboard) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tree/main/s3dis-semseg-pt-v3m1-0-rpe) |
+| PTv3 + PPT | S3DIS (Area5) |     ✓     | 8 | 75.4% | [link](https://github.com/Pointcept/Pointcept/blob/main/configs/s3dis/semseg-pt-v3m1-1-ppt-extreme.py) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tensorboard) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tree/main/s3dis-semseg-pt-v3m1-1-ppt-extreme) |
+
+### 2. Outdoor semantic segmentation
+| Model | Benchmark | Additional Data | Num GPUs | Val mIoU | Config | Tensorboard | Exp Record |
+| :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: |
+| PTv3 | nuScenes | ✗ | 4 | 80.3 | [link](https://github.com/Pointcept/Pointcept/blob/main/configs/nuscenes/semseg-pt-v3m1-0-base.py) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tensorboard)|[link](https://huggingface.co/Pointcept/PointTransformerV3/tree/main/nuscenes-semseg-pt-v3m1-0-base) |
+| PTv3 + PPT | nuScenes | ✓ | 8 | | | | |
+| PTv3 | SemanticKITTI | ✗ | 4 | | | | |
+| PTv3 + PPT | SemanticKITTI | ✓ | 8 | | | | |
+| PTv3 | Waymo | ✗ | 4 | 71.2 | [link](https://github.com/Pointcept/Pointcept/blob/main/configs/waymo/semseg-pt-v3m1-0-base.py) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tensorboard) | [link](https://huggingface.co/Pointcept/PointTransformerV3/tree/main/waymo-semseg-pt-v3m1-0-base) (log only) |
+| PTv3 + PPT | Waymo | ✓ | 8 | | | | |
+* Model weights trained with Waymo Open Dataset cannot be released due to the regulations. 

nuscenes-semseg-pt-v3m1-0-base/config.py

@@ -0,0 +1,230 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 28024989
+save_path = 'exp/nuscenes/semseg-pt-v3m1-0-base'
+num_worker = 16
+batch_size = 12
+batch_size_val = None
+batch_size_test = None
+epoch = 50
+eval_epoch = 50
+sync_bn = False
+enable_amp = True
+empty_cache = False
+find_unused_parameters = False
+mix_prob = 0.8
+param_dicts = [dict(keyword='block', lr=0.0002)]
+hooks = [
+    dict(type='CheckpointLoader'),
+    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=64,
+    backbone=dict(
+        type='PT-v3m1',
+        in_channels=4,
+        order=['z', 'z-trans', 'hilbert', 'hilbert-trans'],
+        stride=(2, 2, 2, 2),
+        enc_depths=(2, 2, 2, 6, 2),
+        enc_channels=(32, 64, 128, 256, 512),
+        enc_num_head=(2, 4, 8, 16, 32),
+        enc_patch_size=(1024, 1024, 1024, 1024, 1024),
+        dec_depths=(2, 2, 2, 2),
+        dec_channels=(64, 64, 128, 256),
+        dec_num_head=(4, 4, 8, 16),
+        dec_patch_size=(1024, 1024, 1024, 1024),
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+        drop_path=0.3,
+        shuffle_orders=True,
+        pre_norm=True,
+        enable_rpe=False,
+        enable_flash=True,
+        upcast_attention=False,
+        upcast_softmax=False,
+        cls_mode=False,
+        pdnorm_bn=False,
+        pdnorm_ln=False,
+        pdnorm_decouple=True,
+        pdnorm_adaptive=False,
+        pdnorm_affine=True,
+        pdnorm_conditions=('nuScenes', 'SemanticKITTI', 'Waymo')),
+    criteria=[
+        dict(type='CrossEntropyLoss', loss_weight=1.0, 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.005)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=[0.002, 0.0002],
+    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='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',
+                keys=('coord', 'strength', 'segment'),
+                return_grid_coord=True),
+            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='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='train',
+                keys=('coord', 'strength', 'segment'),
+                return_grid_coord=True),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-1),
+    test=dict(
+        type='NuScenesDataset',
+        split='val',
+        data_root='data/nuscenes',
+        transform=[
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.025,
+                hash_type='fnv',
+                mode='train',
+                keys=('coord', 'strength', 'segment'),
+                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,
+                keys=('coord', 'strength')),
+            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))

nuscenes-semseg-pt-v3m1-0-base/events.out.tfevents.1704002329.nuscenes-semseg-pt-v3m1-0-base

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

nuscenes-semseg-pt-v3m1-0-base/model/model_best.pth

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

nuscenes-semseg-pt-v3m1-0-base/model/model_last.pth

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

nuscenes-semseg-pt-v3m1-0-base/train.log

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

s3dis-semseg-pt-v3m1-0-rpe/config.py

@@ -0,0 +1,244 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 25326354
+save_path = 'exp/s3dis/semseg-pt-v3m1-0-rpe'
+num_worker = 24
+batch_size = 12
+batch_size_val = None
+batch_size_test = None
+epoch = 3000
+eval_epoch = 100
+sync_bn = False
+enable_amp = True
+empty_cache = False
+find_unused_parameters = False
+mix_prob = 0.8
+param_dicts = [dict(keyword='block', lr=0.0006)]
+hooks = [
+    dict(type='CheckpointLoader'),
+    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=13,
+    backbone_out_channels=64,
+    backbone=dict(
+        type='PT-v3m1',
+        in_channels=6,
+        order=['z', 'z-trans', 'hilbert', 'hilbert-trans'],
+        stride=(2, 2, 2, 2),
+        enc_depths=(2, 2, 2, 6, 2),
+        enc_channels=(32, 64, 128, 256, 512),
+        enc_num_head=(2, 4, 8, 16, 32),
+        enc_patch_size=(128, 128, 128, 128, 128),
+        dec_depths=(2, 2, 2, 2),
+        dec_channels=(64, 64, 128, 256),
+        dec_num_head=(4, 4, 8, 16),
+        dec_patch_size=(128, 128, 128, 128),
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+        drop_path=0.3,
+        shuffle_orders=True,
+        pre_norm=True,
+        enable_rpe=True,
+        enable_flash=False,
+        upcast_attention=True,
+        upcast_softmax=True,
+        cls_mode=False,
+        pdnorm_bn=False,
+        pdnorm_ln=False,
+        pdnorm_decouple=True,
+        pdnorm_adaptive=False,
+        pdnorm_affine=True,
+        pdnorm_conditions=('ScanNet', 'S3DIS', 'Structured3D')),
+    criteria=[
+        dict(type='CrossEntropyLoss', loss_weight=1.0, ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ])
+optimizer = dict(type='AdamW', lr=0.006, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=[0.006, 0.0006],
+    pct_start=0.05,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=1000.0)
+dataset_type = 'S3DISDataset'
+data_root = 'data/s3dis'
+data = dict(
+    num_classes=13,
+    ignore_index=-1,
+    names=[
+        'ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door',
+        'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'
+    ],
+    train=dict(
+        type='S3DISDataset',
+        split=('Area_1', 'Area_2', 'Area_3', 'Area_4', 'Area_6'),
+        data_root='data/s3dis',
+        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='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=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=30),
+    val=dict(
+        type='S3DISDataset',
+        split='Area_5',
+        data_root='data/s3dis',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(
+                type='Copy',
+                keys_dict=dict(coord='origin_coord',
+                               segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True),
+            dict(type='CenterShift', apply_z=False),
+            dict(type='NormalizeColor'),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'origin_coord', 'segment',
+                      'origin_segment'),
+                offset_keys_dict=dict(
+                    offset='coord', origin_offset='origin_coord'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False),
+    test=dict(
+        type='S3DISDataset',
+        split='Area_5',
+        data_root='data/s3dis',
+        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',
+                keys=('coord', 'color', 'normal'),
+                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': '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
+                           }]])))

s3dis-semseg-pt-v3m1-0-rpe/events.out.tfevents.1703439768.s3dis-semseg-pt-v3m1-0-rpe

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

s3dis-semseg-pt-v3m1-0-rpe/model/model_best.pth

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

s3dis-semseg-pt-v3m1-0-rpe/model/model_last.pth

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

s3dis-semseg-pt-v3m1-1-ppt-extreme/config.py

@@ -0,0 +1,432 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 36123202
+save_path = 'exp/s3dis/semseg-pt-v3m1-1-ppt-extreme'
+num_worker = 48
+batch_size = 24
+batch_size_val = None
+batch_size_test = None
+epoch = 100
+eval_epoch = 100
+sync_bn = False
+enable_amp = True
+empty_cache = False
+find_unused_parameters = True
+mix_prob = 0.8
+param_dicts = [dict(keyword='block', lr=0.0005)]
+hooks = [
+    dict(type='CheckpointLoader'),
+    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='PPT-v1m1',
+    backbone=dict(
+        type='PT-v3m1',
+        in_channels=6,
+        order=('z', 'z-trans', 'hilbert', 'hilbert-trans'),
+        stride=(2, 2, 2, 2),
+        enc_depths=(2, 2, 2, 6, 2),
+        enc_channels=(32, 64, 128, 256, 384),
+        enc_num_head=(2, 4, 8, 16, 24),
+        enc_patch_size=(128, 128, 128, 128, 128),
+        dec_depths=(2, 2, 2, 2),
+        dec_channels=(64, 64, 128, 256),
+        dec_num_head=(4, 4, 8, 16),
+        dec_patch_size=(128, 128, 128, 128),
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+        drop_path=0.3,
+        shuffle_orders=True,
+        pre_norm=True,
+        enable_rpe=True,
+        enable_flash=False,
+        upcast_attention=True,
+        upcast_softmax=True,
+        cls_mode=False,
+        pdnorm_bn=True,
+        pdnorm_ln=True,
+        pdnorm_decouple=True,
+        pdnorm_adaptive=False,
+        pdnorm_affine=True,
+        pdnorm_conditions=('ScanNet', 'S3DIS', 'Structured3D')),
+    criteria=[
+        dict(type='CrossEntropyLoss', loss_weight=1.0, ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ],
+    backbone_out_channels=64,
+    context_channels=256,
+    conditions=('Structured3D', 'ScanNet', 'S3DIS'),
+    template='[x]',
+    clip_model='ViT-B/16',
+    class_name=('wall', 'floor', 'cabinet', 'bed', 'chair', 'sofa', 'table',
+                'door', 'window', 'bookshelf', 'bookcase', 'picture',
+                'counter', 'desk', 'shelves', 'curtain', 'dresser', 'pillow',
+                'mirror', 'ceiling', 'refrigerator', 'television',
+                'shower curtain', 'nightstand', 'toilet', 'sink', 'lamp',
+                'bathtub', 'garbagebin', 'board', 'beam', 'column', 'clutter',
+                'otherstructure', 'otherfurniture', 'otherprop'),
+    valid_index=((0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 13, 14, 15, 16, 17, 18, 19,
+                  20, 21, 23, 25, 26, 33, 34, 35),
+                 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15, 20, 22, 24, 25,
+                  27, 34), (0, 1, 4, 5, 6, 7, 8, 10, 19, 29, 30, 31, 32)),
+    backbone_mode=False)
+optimizer = dict(type='AdamW', lr=0.005, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=[0.005, 0.0005],
+    pct_start=0.05,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=1000.0)
+data = dict(
+    num_classes=13,
+    ignore_index=-1,
+    names=[
+        'ceiling', 'floor', 'wall', 'beam', 'column', 'window', 'door',
+        'table', 'chair', 'sofa', 'bookcase', 'board', 'clutter'
+    ],
+    train=dict(
+        type='ConcatDataset',
+        datasets=[
+            dict(
+                type='Structured3DDataset',
+                split=['train', 'val', 'test'],
+                data_root='data/structured3d',
+                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='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.8, mode='random'),
+                    dict(type='SphereCrop', point_max=204800, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='Add', keys_dict=dict(condition='Structured3D')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                loop=4),
+            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='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', point_max=102400, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='Add', keys_dict=dict(condition='ScanNet')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                loop=2),
+            dict(
+                type='S3DISDataset',
+                split=('Area_1', 'Area_2', 'Area_3', 'Area_4', 'Area_6'),
+                data_root='data/s3dis',
+                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='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=204800, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='Add', keys_dict=dict(condition='S3DIS')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                loop=1)
+        ],
+        loop=1),
+    val=dict(
+        type='S3DISDataset',
+        split='Area_5',
+        data_root='data/s3dis',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(
+                type='Copy',
+                keys_dict=dict(coord='origin_coord',
+                               segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True),
+            dict(type='CenterShift', apply_z=False),
+            dict(type='NormalizeColor'),
+            dict(type='ToTensor'),
+            dict(type='Add', keys_dict=dict(condition='S3DIS')),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'origin_coord', 'segment',
+                      'origin_segment', 'condition'),
+                offset_keys_dict=dict(
+                    offset='coord', origin_offset='origin_coord'),
+                feat_keys=('color', 'normal'))
+        ],
+        test_mode=False),
+    test=dict(
+        type='S3DISDataset',
+        split='Area_5',
+        data_root='data/s3dis',
+        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',
+                keys=('coord', 'color', 'normal'),
+                return_grid_coord=True),
+            crop=None,
+            post_transform=[
+                dict(type='CenterShift', apply_z=False),
+                dict(type='Add', keys_dict=dict(condition='S3DIS')),
+                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
+                           }]])))

s3dis-semseg-pt-v3m1-1-ppt-extreme/events.out.tfevents.1708160591.s3dis-semseg-pt-v3m1-1-ppt-extreme

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

s3dis-semseg-pt-v3m1-1-ppt-extreme/model/model_best.pth

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

s3dis-semseg-pt-v3m1-1-ppt-extreme/model/model_last.pth

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

s3dis-semseg-pt-v3m1-1-ppt-extreme/train.log

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

scannet-semseg-pt-v3m1-0-base/config.py

@@ -0,0 +1,301 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 43244662
+save_path = 'exp/scannet/semseg-pt-v3m1-0-base'
+num_worker = 24
+batch_size = 12
+batch_size_val = None
+batch_size_test = None
+epoch = 800
+eval_epoch = 100
+sync_bn = False
+enable_amp = True
+empty_cache = False
+find_unused_parameters = False
+mix_prob = 0.8
+param_dicts = [dict(keyword='block', lr=0.0006)]
+hooks = [
+    dict(type='CheckpointLoader'),
+    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=64,
+    backbone=dict(
+        type='PT-v3m1',
+        in_channels=6,
+        order=['z', 'z-trans', 'hilbert', 'hilbert-trans'],
+        stride=(2, 2, 2, 2),
+        enc_depths=(2, 2, 2, 6, 2),
+        enc_channels=(32, 64, 128, 256, 512),
+        enc_num_head=(2, 4, 8, 16, 32),
+        enc_patch_size=(1024, 1024, 1024, 1024, 1024),
+        dec_depths=(2, 2, 2, 2),
+        dec_channels=(64, 64, 128, 256),
+        dec_num_head=(4, 4, 8, 16),
+        dec_patch_size=(1024, 1024, 1024, 1024),
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+        drop_path=0.3,
+        shuffle_orders=True,
+        pre_norm=True,
+        enable_rpe=False,
+        enable_flash=True,
+        upcast_attention=False,
+        upcast_softmax=False,
+        cls_mode=False,
+        pdnorm_bn=False,
+        pdnorm_ln=False,
+        pdnorm_decouple=True,
+        pdnorm_adaptive=False,
+        pdnorm_affine=True,
+        pdnorm_conditions=('ScanNet', 'S3DIS', 'Structured3D')),
+    criteria=[
+        dict(type='CrossEntropyLoss', loss_weight=1.0, ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ])
+optimizer = dict(type='AdamW', lr=0.006, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=[0.006, 0.0006],
+    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='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True),
+            dict(type='SphereCrop', point_max=102400, 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='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True),
+            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),
+    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',
+                keys=('coord', 'color', 'normal'),
+                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
+                           }]])))

scannet-semseg-pt-v3m1-0-base/events.out.tfevents.1703049730.scannet-semseg-pt-v3m1-0-base

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

scannet-semseg-pt-v3m1-0-base/model/model_best.pth

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

scannet-semseg-pt-v3m1-0-base/model/model_last.pth

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

scannet-semseg-pt-v3m1-0-base/train.log

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

scannet-semseg-pt-v3m1-1-ppt-extreme/config.py

@@ -0,0 +1,381 @@
+weight = 'exp/scannet/semseg-pt-v3m1-1-ppt-extreme/model/model_best.pth'
+resume = False
+evaluate = True
+test_only = False
+seed = 44350923
+save_path = 'exp/scannet/semseg-pt-v3m1-1-ppt-extreme'
+num_worker = 48
+batch_size = 24
+batch_size_val = None
+batch_size_test = None
+epoch = 100
+eval_epoch = 100
+sync_bn = False
+enable_amp = True
+empty_cache = False
+find_unused_parameters = True
+mix_prob = 0.8
+param_dicts = [dict(keyword='block', lr=0.0005)]
+hooks = [
+    dict(type='CheckpointLoader'),
+    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='PPT-v1m1',
+    backbone=dict(
+        type='PT-v3m1',
+        in_channels=6,
+        order=('z', 'z-trans', 'hilbert', 'hilbert-trans'),
+        stride=(2, 2, 2, 2),
+        enc_depths=(3, 3, 3, 6, 3),
+        enc_channels=(48, 96, 192, 384, 512),
+        enc_num_head=(3, 6, 12, 24, 32),
+        enc_patch_size=(1024, 1024, 1024, 1024, 1024),
+        dec_depths=(3, 3, 3, 3),
+        dec_channels=(64, 96, 192, 384),
+        dec_num_head=(4, 6, 12, 24),
+        dec_patch_size=(1024, 1024, 1024, 1024),
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+        drop_path=0.3,
+        shuffle_orders=True,
+        pre_norm=True,
+        enable_rpe=False,
+        enable_flash=True,
+        upcast_attention=False,
+        upcast_softmax=False,
+        cls_mode=False,
+        pdnorm_bn=True,
+        pdnorm_ln=True,
+        pdnorm_decouple=True,
+        pdnorm_adaptive=False,
+        pdnorm_affine=True,
+        pdnorm_conditions=('ScanNet', 'S3DIS', 'Structured3D')),
+    criteria=[
+        dict(type='CrossEntropyLoss', loss_weight=1.0, ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ],
+    backbone_out_channels=64,
+    context_channels=256,
+    conditions=('Structured3D', 'ScanNet', 'S3DIS'),
+    template='[x]',
+    clip_model='ViT-B/16',
+    class_name=('wall', 'floor', 'cabinet', 'bed', 'chair', 'sofa', 'table',
+                'door', 'window', 'bookshelf', 'bookcase', 'picture',
+                'counter', 'desk', 'shelves', 'curtain', 'dresser', 'pillow',
+                'mirror', 'ceiling', 'refrigerator', 'television',
+                'shower curtain', 'nightstand', 'toilet', 'sink', 'lamp',
+                'bathtub', 'garbagebin', 'board', 'beam', 'column', 'clutter',
+                'otherstructure', 'otherfurniture', 'otherprop'),
+    valid_index=((0, 1, 2, 3, 4, 5, 6, 7, 8, 11, 13, 14, 15, 16, 17, 18, 19,
+                  20, 21, 23, 25, 26, 33, 34, 35),
+                 (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15, 20, 22, 24, 25,
+                  27, 34), (0, 1, 4, 5, 6, 7, 8, 10, 19, 29, 30, 31, 32)),
+    backbone_mode=False)
+optimizer = dict(type='AdamW', lr=0.005, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=[0.005, 0.0005],
+    pct_start=0.05,
+    anneal_strategy='cos',
+    div_factor=10.0,
+    final_div_factor=1000.0)
+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='Structured3DDataset',
+                split=['train', 'val', 'test'],
+                data_root='data/structured3d',
+                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.8, mode='random'),
+                    dict(type='SphereCrop', point_max=102400, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='Add', keys_dict=dict(condition='Structured3D')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                loop=2),
+            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='GridSample',
+                        grid_size=0.02,
+                        hash_type='fnv',
+                        mode='train',
+                        return_grid_coord=True),
+                    dict(type='SphereCrop', point_max=102400, mode='random'),
+                    dict(type='CenterShift', apply_z=False),
+                    dict(type='NormalizeColor'),
+                    dict(type='ShufflePoint'),
+                    dict(type='Add', keys_dict=dict(condition='ScanNet')),
+                    dict(type='ToTensor'),
+                    dict(
+                        type='Collect',
+                        keys=('coord', 'grid_coord', 'segment', 'condition'),
+                        feat_keys=('color', 'normal'))
+                ],
+                test_mode=False,
+                loop=1)
+        ],
+        loop=1),
+    val=dict(
+        type='ScanNetDataset',
+        split='val',
+        data_root='data/scannet',
+        transform=[
+            dict(type='CenterShift', apply_z=True),
+            dict(
+                type='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True),
+            dict(type='CenterShift', apply_z=False),
+            dict(type='NormalizeColor'),
+            dict(type='ToTensor'),
+            dict(type='Add', keys_dict=dict(condition='ScanNet')),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment', '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',
+                keys=('coord', 'color', 'normal'),
+                return_grid_coord=True),
+            crop=None,
+            post_transform=[
+                dict(type='CenterShift', apply_z=False),
+                dict(type='Add', 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
+                           }]])))

scannet-semseg-pt-v3m1-1-ppt-extreme/events.out.tfevents.1706979139.scannet-semseg-pt-v3m1-1-ppt-extreme

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

scannet-semseg-pt-v3m1-1-ppt-extreme/model/model_best.pth

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

scannet-semseg-pt-v3m1-1-ppt-extreme/model/model_last.pth

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

scannet-semseg-pt-v3m1-1-ppt-extreme/train.log

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

scannet200-semseg-pt-v3m1-0-base/config.py

@@ -0,0 +1,375 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 1023306
+save_path = 'exp/scannet200/semseg-pt-v3m1-0-base'
+num_worker = 24
+batch_size = 12
+batch_size_val = None
+batch_size_test = None
+epoch = 800
+eval_epoch = 100
+sync_bn = False
+enable_amp = True
+empty_cache = False
+find_unused_parameters = False
+mix_prob = 0.8
+param_dicts = [dict(keyword='block', lr=0.0006)]
+hooks = [
+    dict(type='CheckpointLoader'),
+    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=64,
+    backbone=dict(
+        type='PT-v3m1',
+        in_channels=6,
+        order=['z', 'z-trans', 'hilbert', 'hilbert-trans'],
+        stride=(2, 2, 2, 2),
+        enc_depths=(2, 2, 2, 6, 2),
+        enc_channels=(32, 64, 128, 256, 512),
+        enc_num_head=(2, 4, 8, 16, 32),
+        enc_patch_size=(1024, 1024, 1024, 1024, 1024),
+        dec_depths=(2, 2, 2, 2),
+        dec_channels=(64, 64, 128, 256),
+        dec_num_head=(4, 4, 8, 16),
+        dec_patch_size=(1024, 1024, 1024, 1024),
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+        drop_path=0.3,
+        shuffle_orders=True,
+        pre_norm=True,
+        enable_rpe=False,
+        enable_flash=True,
+        upcast_attention=False,
+        upcast_softmax=False,
+        cls_mode=False,
+        pdnorm_bn=False,
+        pdnorm_ln=False,
+        pdnorm_decouple=True,
+        pdnorm_adaptive=False,
+        pdnorm_affine=True,
+        pdnorm_conditions=('ScanNet', 'S3DIS', 'Structured3D')),
+    criteria=[
+        dict(type='CrossEntropyLoss', loss_weight=1.0, ignore_index=-1),
+        dict(
+            type='LovaszLoss',
+            mode='multiclass',
+            loss_weight=1.0,
+            ignore_index=-1)
+    ])
+optimizer = dict(type='AdamW', lr=0.006, weight_decay=0.05)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=[0.006, 0.0006],
+    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='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True),
+            dict(type='SphereCrop', point_max=102400, 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='GridSample',
+                grid_size=0.02,
+                hash_type='fnv',
+                mode='train',
+                return_grid_coord=True),
+            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),
+    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',
+                keys=('coord', 'color', 'normal'),
+                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
+                           }]])))

scannet200-semseg-pt-v3m1-0-base/events.out.tfevents.1703049688.scannet200-semseg-pt-v3m1-0-base

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

scannet200-semseg-pt-v3m1-0-base/model/model_best.pth

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

scannet200-semseg-pt-v3m1-0-base/model/model_last.pth

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

scannet200-semseg-pt-v3m1-0-base/train.log

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

waymo-semseg-pt-v3m1-0-base/config.py

@@ -0,0 +1,217 @@
+weight = None
+resume = False
+evaluate = True
+test_only = False
+seed = 2311533
+save_path = 'exp/waymo/semseg-pt-v3m1-0-base'
+num_worker = 16
+batch_size = 12
+batch_size_val = None
+batch_size_test = None
+epoch = 50
+eval_epoch = 50
+sync_bn = False
+enable_amp = True
+empty_cache = False
+find_unused_parameters = False
+mix_prob = 0.8
+param_dicts = [dict(keyword='block', lr=0.0002)]
+hooks = [
+    dict(type='CheckpointLoader'),
+    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=64,
+    backbone=dict(
+        type='PT-v3m1',
+        in_channels=4,
+        order=['z', 'z-trans', 'hilbert', 'hilbert-trans'],
+        stride=(2, 2, 2, 2),
+        enc_depths=(2, 2, 2, 6, 2),
+        enc_channels=(32, 64, 128, 256, 512),
+        enc_num_head=(2, 4, 8, 16, 32),
+        enc_patch_size=(1024, 1024, 1024, 1024, 1024),
+        dec_depths=(2, 2, 2, 2),
+        dec_channels=(64, 64, 128, 256),
+        dec_num_head=(4, 4, 8, 16),
+        dec_patch_size=(1024, 1024, 1024, 1024),
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        attn_drop=0.0,
+        proj_drop=0.0,
+        drop_path=0.3,
+        shuffle_orders=True,
+        pre_norm=True,
+        enable_rpe=False,
+        enable_flash=True,
+        upcast_attention=False,
+        upcast_softmax=False,
+        cls_mode=False,
+        pdnorm_bn=False,
+        pdnorm_ln=False,
+        pdnorm_decouple=True,
+        pdnorm_adaptive=False,
+        pdnorm_affine=True,
+        pdnorm_conditions=('nuScenes', 'SemanticKITTI', 'Waymo')),
+    criteria=[
+        dict(type='CrossEntropyLoss', loss_weight=1.0, 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.005)
+scheduler = dict(
+    type='OneCycleLR',
+    max_lr=[0.002, 0.0002],
+    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='RandomRotate',
+                angle=[-1, 1],
+                axis='z',
+                center=[0, 0, 0],
+                p=0.5),
+            dict(
+                type='PointClip',
+                point_cloud_range=(-75.2, -75.2, -4, 75.2, 75.2, 2)),
+            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',
+                keys=('coord', 'strength', 'segment'),
+                return_grid_coord=True),
+            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='PointClip',
+                point_cloud_range=(-75.2, -75.2, -4, 75.2, 75.2, 2)),
+            dict(
+                type='GridSample',
+                grid_size=0.05,
+                hash_type='fnv',
+                mode='train',
+                keys=('coord', 'strength', 'segment'),
+                return_grid_coord=True),
+            dict(type='ToTensor'),
+            dict(
+                type='Collect',
+                keys=('coord', 'grid_coord', 'segment'),
+                feat_keys=('coord', 'strength'))
+        ],
+        test_mode=False,
+        ignore_index=-1),
+    test=dict(
+        type='WaymoDataset',
+        split='validation',
+        data_root='data/waymo',
+        transform=[
+            dict(
+                type='PointClip',
+                point_cloud_range=(-75.2, -75.2, -4, 75.2, 75.2, 2)),
+            dict(type='Copy', keys_dict=dict(segment='origin_segment')),
+            dict(
+                type='GridSample',
+                grid_size=0.025,
+                hash_type='fnv',
+                mode='train',
+                keys=('coord', 'strength', 'segment'),
+                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,
+                keys=('coord', 'strength')),
+            crop=None,
+            post_transform=[
+                dict(type='ToTensor'),
+                dict(
+                    type='Collect',
+                    keys=('coord', 'grid_coord', 'index'),
+                    feat_keys=('coord', 'strength'))
+            ],
+            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
+                           }]]),
+        ignore_index=-1))

waymo-semseg-pt-v3m1-0-base/events.out.tfevents.1708353865.waymo-semseg-pt-v3m1-0-base

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

waymo-semseg-pt-v3m1-0-base/train.log

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