add preprocessing and dataset code

configs/alc/semseg-pt-v3m1-0-base-scannet200-debug.py

@@ -0,0 +1,294 @@
+from pointcept.datasets.preprocessing.scannet.meta_data.scannet200_constants import (
+    CLASS_LABELS_200,
+)
+
+
+_base_ = ["../_base_/default_runtime.py"]
+
+# misc custom setting
+batch_size = 2  # bs: total bs in all gpus
+num_worker = 24
+mix_prob = 0.8
+empty_cache = False
+enable_amp = True
+
+# model settings
+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),
+    ],
+)
+
+# scheduler settings
+epoch = 800
+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,
+)
+param_dicts = [dict(keyword="block", lr=0.0006)]
+
+# dataset settings
+dataset_type = "ARKitScenesLabelMakerScanNet200Dataset"
+data_root = "data/alc"
+
+data = dict(
+    num_classes=200,
+    ignore_index=-1,
+    names=CLASS_LABELS_200,
+    train=dict(
+        type=dataset_type,
+        split="train",
+        data_root=data_root,
+        transform=[
+            dict(type="CenterShift", apply_z=True),
+            dict(type="RandomDropout", dropout_ratio=0.2, dropout_application_ratio=0.2),
+            # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+            dict(type="RandomRotate", angle=[-1, 1], axis="z", center=[0, 0, 0], p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+            dict(type="RandomScale", scale=[0.9, 1.1]),
+            # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+            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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+            # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+            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="ToTensor"),
+            dict(
+                type="Collect",
+                keys=("coord", "grid_coord", "segment"),
+                feat_keys=("color", "normal"),
+            ),
+        ],
+        test_mode=False,
+    ),
+    val=dict(
+        type=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=[
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [dict(type="RandomFlip", p=1)],
+            ],
+        ),
+    ),
+)

configs/alc/semseg-pt-v3m1-0-base-scannet200.py

@@ -0,0 +1,294 @@
+from pointcept.datasets.preprocessing.scannet.meta_data.scannet200_constants import (
+    CLASS_LABELS_200,
+)
+
+
+_base_ = ["../_base_/default_runtime.py"]
+
+# misc custom setting
+batch_size = 12  # bs: total bs in all gpus
+num_worker = 24
+mix_prob = 0.8
+empty_cache = False
+enable_amp = True
+
+# model settings
+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", "ALC"),
+    ),
+    criteria=[
+        dict(type="CrossEntropyLoss", loss_weight=1.0, ignore_index=-1),
+        dict(type="LovaszLoss", mode="multiclass", loss_weight=1.0, ignore_index=-1),
+    ],
+)
+
+# scheduler settings
+epoch = 800
+optimizer = dict(type="AdamW", lr=0.00161, weight_decay=0.05)
+scheduler = dict(
+    type="OneCycleLR",
+    max_lr=[0.00161, 0.000161],
+    pct_start=0.05,
+    anneal_strategy="cos",
+    div_factor=10.0,
+    final_div_factor=1000.0,
+)
+param_dicts = [dict(keyword="block", lr=0.0006)]
+
+# dataset settings
+dataset_type = "ARKitScenesLabelMakerScanNet200Dataset"
+data_root = "data/alc"
+
+data = dict(
+    num_classes=200,
+    ignore_index=-1,
+    names=CLASS_LABELS_200,
+    train=dict(
+        type=dataset_type,
+        split="train",
+        data_root=data_root,
+        transform=[
+            dict(type="CenterShift", apply_z=True),
+            dict(type="RandomDropout", dropout_ratio=0.2, dropout_application_ratio=0.2),
+            # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+            dict(type="RandomRotate", angle=[-1, 1], axis="z", center=[0, 0, 0], p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+            dict(type="RandomScale", scale=[0.9, 1.1]),
+            # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+            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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+            # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+            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="ToTensor"),
+            dict(
+                type="Collect",
+                keys=("coord", "grid_coord", "segment"),
+                feat_keys=("color", "normal"),
+            ),
+        ],
+        test_mode=False,
+    ),
+    val=dict(
+        type=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=[
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [dict(type="RandomFlip", p=1)],
+            ],
+        ),
+    ),
+)

configs/alc/semseg-pt-v3m1-0-base-wn199-debug.py

@@ -0,0 +1,291 @@
+from pointcept.datasets.preprocessing.alc.preprocess_arkitscenes_labelmaker_consensus import WORDNET_NAMES
+
+_base_ = ["../_base_/default_runtime.py"]
+
+# misc custom setting
+batch_size = 1  # bs: total bs in all gpus
+num_worker = 24
+mix_prob = 0.8
+empty_cache = False
+enable_amp = True
+
+# model settings
+model = dict(
+    type="DefaultSegmentorV2",
+    num_classes=185,
+    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),
+    ],
+)
+
+# scheduler settings
+epoch = 800
+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,
+)
+param_dicts = [dict(keyword="block", lr=0.0006)]
+
+# dataset settings
+dataset_type = "ARKitScenesLabelMakerConsensusDataset"
+data_root = "data/alc"
+
+data = dict(
+    num_classes=185,
+    ignore_index=-1,
+    names=WORDNET_NAMES,
+    train=dict(
+        type=dataset_type,
+        split="train",
+        data_root=data_root,
+        transform=[
+            dict(type="CenterShift", apply_z=True),
+            dict(type="RandomDropout", dropout_ratio=0.2, dropout_application_ratio=0.2),
+            # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+            dict(type="RandomRotate", angle=[-1, 1], axis="z", center=[0, 0, 0], p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+            dict(type="RandomScale", scale=[0.9, 1.1]),
+            # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+            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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+            # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+            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="ToTensor"),
+            dict(
+                type="Collect",
+                keys=("coord", "grid_coord", "segment"),
+                feat_keys=("color", "normal"),
+            ),
+        ],
+        test_mode=False,
+    ),
+    val=dict(
+        type=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=[
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [dict(type="RandomFlip", p=1)],
+            ],
+        ),
+    ),
+)

configs/alc/semseg-pt-v3m1-0-base-wn199.py

@@ -0,0 +1,291 @@
+from pointcept.datasets.preprocessing.alc.preprocess_arkitscenes_labelmaker_consensus import WORDNET_NAMES
+
+_base_ = ["../_base_/default_runtime.py"]
+
+# misc custom setting
+batch_size = 12  # bs: total bs in all gpus
+num_worker = 24
+mix_prob = 0.8
+empty_cache = False
+enable_amp = True
+
+# model settings
+model = dict(
+    type="DefaultSegmentorV2",
+    num_classes=185,
+    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),
+    ],
+)
+
+# scheduler settings
+epoch = 800
+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,
+)
+param_dicts = [dict(keyword="block", lr=0.0006)]
+
+# dataset settings
+dataset_type = "ARKitScenesLabelMakerConsensusDataset"
+data_root = "data/alc"
+
+data = dict(
+    num_classes=185,
+    ignore_index=-1,
+    names=WORDNET_NAMES,
+    train=dict(
+        type=dataset_type,
+        split="train",
+        data_root=data_root,
+        transform=[
+            dict(type="CenterShift", apply_z=True),
+            dict(type="RandomDropout", dropout_ratio=0.2, dropout_application_ratio=0.2),
+            # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+            dict(type="RandomRotate", angle=[-1, 1], axis="z", center=[0, 0, 0], p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+            dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+            dict(type="RandomScale", scale=[0.9, 1.1]),
+            # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+            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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+            # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+            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="ToTensor"),
+            dict(
+                type="Collect",
+                keys=("coord", "grid_coord", "segment"),
+                feat_keys=("color", "normal"),
+            ),
+        ],
+        test_mode=False,
+    ),
+    val=dict(
+        type=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=dataset_type,
+        split="val",
+        data_root=data_root,
+        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=[
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [dict(type="RandomFlip", p=1)],
+            ],
+        ),
+    ),
+)

configs/scannet/semseg-pt-v3m1-1-ppt-extreme-alc.py

@@ -0,0 +1,782 @@
+_base_ = ["../_base_/default_runtime.py"]
+
+# misc custom setting
+batch_size = 24  # bs: total bs in all gpus
+num_worker = 48
+mix_prob = 0.8
+empty_cache = False
+enable_amp = True
+find_unused_parameters = True
+
+# trainer
+train = dict(
+    type="MultiDatasetTrainer",
+)
+
+# model
+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=(
+            "S3DIS",
+            "ScanNet",
+            "Structured3D",
+            "ALC",
+            # "ScanNet200"
+        ),
+    ),
+    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=(
+        "S3DIS",
+        "ScanNet",
+        "Structured3D",
+        "ALC",
+        # "ScanNet200"
+    ),
+    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",
+        "book",
+        "ashcan",
+        "display",
+        "cushion",
+        "box",
+        "doorframe",
+        "swivel chair",
+        "towel",
+        "backpack",
+        "chest of drawers",
+        "apparel",
+        "armchair",
+        "plant",
+        "radiator",
+        "toilet tissue",
+        "shoe",
+        "bag",
+        "bottle",
+        "countertop",
+        "coffee table",
+        "computer keyboard",
+        "fridge",
+        "stool",
+        "computer",
+        "mug",
+        "telephone",
+        "light",
+        "jacket",
+        "microwave",
+        "footstool",
+        "baggage",
+        "laptop",
+        "printer",
+        "shower stall",
+        "soap dispenser",
+        "stove",
+        "fan",
+        "paper",
+        "stand",
+        "bench",
+        "wardrobe",
+        "blanket",
+        "booth",
+        "duplicator",
+        "bar",
+        "soap dish",
+        "switch",
+        "coffee maker",
+        "decoration",
+        "range hood",
+        "blackboard",
+        "clock",
+        "railing",
+        "mat",
+        "seat",
+        "bannister",
+        "container",
+        "mouse",
+        "person",
+        "stairway",
+        "basket",
+        "dumbbell",
+        "bucket",
+        "windowsill",
+        "signboard",
+        "dishwasher",
+        "loudspeaker",
+        "washer",
+        "paper towel",
+        "clothes hamper",
+        "piano",
+        "sack",
+        "handcart",
+        "blind",
+        "dish rack",
+        "mailbox",
+        "bicycle",
+        "ladder",
+        "rack",
+        "tray",
+        "toaster",
+        "paper cutter",
+        "plunger",
+        "dryer",
+        "guitar",
+        "fire extinguisher",
+        "pitcher",
+        "pipe",
+        "plate",
+        "vacuum",
+        "bowl",
+        "hat",
+        "rod",
+        "water cooler",
+        "kettle",
+        "oven",
+        "scale",
+        "broom",
+        "hand blower",
+        "coatrack",
+        "teddy",
+        "alarm clock",
+        "ironing board",
+        "fire alarm",
+        "machine",
+        "music stand",
+        "fireplace",
+        "furniture",
+        "vase",
+        "vent",
+        "candle",
+        "crate",
+        "dustpan",
+        "earphone",
+        "jar",
+        "projector",
+        "gat",
+        "step",
+        "step stool",
+        "vending machine",
+        "coat",
+        "coat hanger",
+        "drinking fountain",
+        "hamper",
+        "thermostat",
+        "banner",
+        "iron",
+        "soap",
+        "chopping board",
+        "kitchen island",
+        "shirt",
+        "sleeping bag",
+        "tire",
+        "toothbrush",
+        "bathrobe",
+        "faucet",
+        "slipper",
+        "thermos",
+        "tripod",
+        "dispenser",
+        "heater",
+        "pool table",
+        "remote control",
+        "stapler",
+        "treadmill",
+        "beanbag",
+        "dartboard",
+        "metronome",
+        "rope",
+        "sewing machine",
+        "shredder",
+        "toolbox",
+        "water heater",
+        "brush",
+        "control",
+        "dais",
+        "dollhouse",
+        "envelope",
+        "food",
+        "frying pan",
+        "helmet",
+        "tennis racket",
+        "umbrella",
+        "couch",
+        "shelf",
+        "office chair",
+        "monitor",
+        "kitchen cabinet",
+        "clothes",
+        "tv",
+        "end table",
+        "dining table",
+        "keyboard",
+        "toilet paper",
+        "tv stand",
+        "whiteboard",
+        "trash can",
+        "closet",
+        "stairs",
+        "computer tower",
+        "bin",
+        "ottoman",
+        "washing machine",
+        "copier",
+        "sofa chair",
+        "file cabinet",
+        "shower",
+        "paper towel dispenser",
+        "blinds",
+        "suitcase",
+        "rail",
+        "recycling bin",
+        "laundry basket",
+        "clothes dryer",
+        "toilet paper holder",
+        "speaker",
+        "bathroom stall",
+        "shower wall",
+        "cup",
+        "storage bin",
+        "paper towel roll",
+        "bulletin board",
+        "kitchen counter",
+        "toilet paper dispenser",
+        "mini fridge",
+        "ball",
+        "shower curtain rod",
+        "shower door",
+        "pillar",
+        "ledge",
+        "toaster oven",
+        "toilet seat cover dispenser",
+        "cart",
+        "storage container",
+        "tissue box",
+        "light switch",
+        "power outlet",
+        "sign",
+        "closet door",
+        "vacuum cleaner",
+        "stuffed animal",
+        "headphones",
+        "guitar case",
+        "hair dryer",
+        "water bottle",
+        "handicap bar",
+        "purse",
+        "shower floor",
+        "water pitcher",
+        "paper bag",
+        "projector screen",
+        "divider",
+        "laundry detergent",
+        "bathroom counter",
+        "object",
+        "bathroom vanity",
+        "closet wall",
+        "laundry hamper",
+        "bathroom stall door",
+        "ceiling light",
+        "trash bin",
+        "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",
+        "power strip",
+        "calendar",
+        "poster",
+        "potted plant",
+        "luggage",
+        "mattress",
+    ),
+    valid_index=(
+        (0, 1, 4, 5, 6, 7, 8, 10, 19, 29, 30, 31, 32),
+        (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15, 20, 22, 24, 25, 27, 34),
+        (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,
+            4,
+            36,
+            2,
+            7,
+            1,
+            37,
+            6,
+            8,
+            9,
+            38,
+            39,
+            40,
+            11,
+            19,
+            41,
+            13,
+            42,
+            43,
+            5,
+            25,
+            44,
+            26,
+            45,
+            46,
+            47,
+            3,
+            15,
+            18,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            54,
+            55,
+            24,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            27,
+            22,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            82,
+            83,
+            84,
+            85,
+            86,
+            87,
+            88,
+            89,
+            90,
+            91,
+            92,
+            93,
+            94,
+            95,
+            96,
+            97,
+            31,
+            98,
+            99,
+            100,
+            101,
+            102,
+            103,
+            104,
+            105,
+            106,
+            107,
+            108,
+            109,
+            110,
+            111,
+            52,
+            112,
+            113,
+            114,
+            115,
+            116,
+            117,
+            118,
+            119,
+            120,
+            121,
+            122,
+            123,
+            124,
+            125,
+            126,
+            127,
+            128,
+            129,
+            130,
+            131,
+            132,
+            133,
+            134,
+            135,
+            136,
+            137,
+            138,
+            139,
+            140,
+            141,
+            142,
+            143,
+            144,
+            145,
+            146,
+            147,
+            148,
+            149,
+            150,
+            151,
+            152,
+            153,
+            154,
+            155,
+            156,
+            157,
+            158,
+            159,
+            160,
+            161,
+            162,
+            163,
+            164,
+            165,
+            166,
+            167,
+            168,
+            169,
+            170,
+            171,
+            172,
+            173,
+            174,
+            175,
+            176,
+            177,
+            178,
+            179,
+            180,
+            181,
+            182,
+            183,
+            184,
+            185,
+            186,
+            187,
+            188,
+            189,
+            190,
+            191,
+            192,
+            193,
+            194,
+            195,
+            196,
+            197,
+            198,
+        ),
+    ),
+    backbone_mode=False,
+)
+
+# optimizer
+# epoch = 800
+# eval_epoch = 800
+epoch = 1000
+eval_epoch = 1000
+# epoch = 1600
+# eval_epoch = 1600
+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,
+)
+param_dicts = [dict(keyword="block", lr=0.0005)]
+
+# datasets
+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=[
+            # # Structured3DDataset
+            # 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=1,
+            # ),
+            # ScanNetDataset
+            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,
+            ),
+            # S3DISDataset
+            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,
+            ),
+            # ALC
+            dict(
+                type="ARKitScenesLabelMakerConsensusDataset",
+                split=["train", "val"],
+                data_root="data/alc",
+                transform=[
+                    dict(type="CenterShift", apply_z=True),
+                    dict(type="RandomDropout", dropout_ratio=0.2, dropout_application_ratio=0.2),
+                    # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+                    dict(type="RandomRotate", angle=[-1, 1], axis="z", center=[0, 0, 0], p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+                    dict(type="RandomScale", scale=[0.9, 1.1]),
+                    # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+                    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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+                    # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+                    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="ALC")),
+                    dict(type="ToTensor"),
+                    dict(
+                        type="Collect",
+                        keys=("coord", "grid_coord", "segment", "condition"),
+                        feat_keys=("color", "normal"),
+                    ),
+                ],
+                test_mode=False,
+                loop=2,
+            ),
+        ],
+        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}],
+            ],
+        ),
+    ),
+)
+
+# hook
+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=True),
+]

configs/scannet200/semseg-pt-v3m1-1-ppt-extreme-alc.py

@@ -0,0 +1,972 @@
+from pointcept.datasets.preprocessing.scannet.meta_data.scannet200_constants import CLASS_LABELS_200
+
+_base_ = ["../_base_/default_runtime.py"]
+
+# misc custom setting
+batch_size = 24  # bs: total bs in all gpus
+num_worker = 36
+mix_prob = 0.8
+empty_cache = False
+enable_amp = True
+find_unused_parameters = True
+
+# trainer
+train = dict(
+    type="MultiDatasetTrainer",
+)
+
+# model
+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=(
+            "S3DIS",
+            # "ScanNet",
+            "Structured3D",
+            "ALC",
+            "ScanNet200",
+        ),
+    ),
+    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=(
+        "S3DIS",
+        # "ScanNet",
+        "Structured3D",
+        "ALC",
+        "ScanNet200",
+    ),
+    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",
+        "book",
+        "ashcan",
+        "display",
+        "cushion",
+        "box",
+        "doorframe",
+        "swivel chair",
+        "towel",
+        "backpack",
+        "chest of drawers",
+        "apparel",
+        "armchair",
+        "plant",
+        "radiator",
+        "toilet tissue",
+        "shoe",
+        "bag",
+        "bottle",
+        "countertop",
+        "coffee table",
+        "computer keyboard",
+        "fridge",
+        "stool",
+        "computer",
+        "mug",
+        "telephone",
+        "light",
+        "jacket",
+        "microwave",
+        "footstool",
+        "baggage",
+        "laptop",
+        "printer",
+        "shower stall",
+        "soap dispenser",
+        "stove",
+        "fan",
+        "paper",
+        "stand",
+        "bench",
+        "wardrobe",
+        "blanket",
+        "booth",
+        "duplicator",
+        "bar",
+        "soap dish",
+        "switch",
+        "coffee maker",
+        "decoration",
+        "range hood",
+        "blackboard",
+        "clock",
+        "railing",
+        "mat",
+        "seat",
+        "bannister",
+        "container",
+        "mouse",
+        "person",
+        "stairway",
+        "basket",
+        "dumbbell",
+        "bucket",
+        "windowsill",
+        "signboard",
+        "dishwasher",
+        "loudspeaker",
+        "washer",
+        "paper towel",
+        "clothes hamper",
+        "piano",
+        "sack",
+        "handcart",
+        "blind",
+        "dish rack",
+        "mailbox",
+        "bicycle",
+        "ladder",
+        "rack",
+        "tray",
+        "toaster",
+        "paper cutter",
+        "plunger",
+        "dryer",
+        "guitar",
+        "fire extinguisher",
+        "pitcher",
+        "pipe",
+        "plate",
+        "vacuum",
+        "bowl",
+        "hat",
+        "rod",
+        "water cooler",
+        "kettle",
+        "oven",
+        "scale",
+        "broom",
+        "hand blower",
+        "coatrack",
+        "teddy",
+        "alarm clock",
+        "ironing board",
+        "fire alarm",
+        "machine",
+        "music stand",
+        "fireplace",
+        "furniture",
+        "vase",
+        "vent",
+        "candle",
+        "crate",
+        "dustpan",
+        "earphone",
+        "jar",
+        "projector",
+        "gat",
+        "step",
+        "step stool",
+        "vending machine",
+        "coat",
+        "coat hanger",
+        "drinking fountain",
+        "hamper",
+        "thermostat",
+        "banner",
+        "iron",
+        "soap",
+        "chopping board",
+        "kitchen island",
+        "shirt",
+        "sleeping bag",
+        "tire",
+        "toothbrush",
+        "bathrobe",
+        "faucet",
+        "slipper",
+        "thermos",
+        "tripod",
+        "dispenser",
+        "heater",
+        "pool table",
+        "remote control",
+        "stapler",
+        "treadmill",
+        "beanbag",
+        "dartboard",
+        "metronome",
+        "rope",
+        "sewing machine",
+        "shredder",
+        "toolbox",
+        "water heater",
+        "brush",
+        "control",
+        "dais",
+        "dollhouse",
+        "envelope",
+        "food",
+        "frying pan",
+        "helmet",
+        "tennis racket",
+        "umbrella",
+        "couch",
+        "shelf",
+        "office chair",
+        "monitor",
+        "kitchen cabinet",
+        "clothes",
+        "tv",
+        "end table",
+        "dining table",
+        "keyboard",
+        "toilet paper",
+        "tv stand",
+        "whiteboard",
+        "trash can",
+        "closet",
+        "stairs",
+        "computer tower",
+        "bin",
+        "ottoman",
+        "washing machine",
+        "copier",
+        "sofa chair",
+        "file cabinet",
+        "shower",
+        "paper towel dispenser",
+        "blinds",
+        "suitcase",
+        "rail",
+        "recycling bin",
+        "laundry basket",
+        "clothes dryer",
+        "toilet paper holder",
+        "speaker",
+        "bathroom stall",
+        "shower wall",
+        "cup",
+        "storage bin",
+        "paper towel roll",
+        "bulletin board",
+        "kitchen counter",
+        "toilet paper dispenser",
+        "mini fridge",
+        "ball",
+        "shower curtain rod",
+        "shower door",
+        "pillar",
+        "ledge",
+        "toaster oven",
+        "toilet seat cover dispenser",
+        "cart",
+        "storage container",
+        "tissue box",
+        "light switch",
+        "power outlet",
+        "sign",
+        "closet door",
+        "vacuum cleaner",
+        "stuffed animal",
+        "headphones",
+        "guitar case",
+        "hair dryer",
+        "water bottle",
+        "handicap bar",
+        "purse",
+        "shower floor",
+        "water pitcher",
+        "paper bag",
+        "projector screen",
+        "divider",
+        "laundry detergent",
+        "bathroom counter",
+        "object",
+        "bathroom vanity",
+        "closet wall",
+        "laundry hamper",
+        "bathroom stall door",
+        "ceiling light",
+        "trash bin",
+        "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",
+        "power strip",
+        "calendar",
+        "poster",
+        "potted plant",
+        "luggage",
+        "mattress",
+    ),
+    valid_index=(
+        (0, 1, 4, 5, 6, 7, 8, 10, 19, 29, 30, 31, 32),
+        (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,
+            4,
+            36,
+            2,
+            7,
+            1,
+            37,
+            6,
+            8,
+            9,
+            38,
+            39,
+            40,
+            11,
+            19,
+            41,
+            13,
+            42,
+            43,
+            5,
+            25,
+            44,
+            26,
+            45,
+            46,
+            47,
+            3,
+            15,
+            18,
+            48,
+            49,
+            50,
+            51,
+            52,
+            53,
+            54,
+            55,
+            24,
+            56,
+            57,
+            58,
+            59,
+            60,
+            61,
+            62,
+            63,
+            27,
+            22,
+            64,
+            65,
+            66,
+            67,
+            68,
+            69,
+            70,
+            71,
+            72,
+            73,
+            74,
+            75,
+            76,
+            77,
+            78,
+            79,
+            80,
+            81,
+            82,
+            83,
+            84,
+            85,
+            86,
+            87,
+            88,
+            89,
+            90,
+            91,
+            92,
+            93,
+            94,
+            95,
+            96,
+            97,
+            31,
+            98,
+            99,
+            100,
+            101,
+            102,
+            103,
+            104,
+            105,
+            106,
+            107,
+            108,
+            109,
+            110,
+            111,
+            52,
+            112,
+            113,
+            114,
+            115,
+            116,
+            117,
+            118,
+            119,
+            120,
+            121,
+            122,
+            123,
+            124,
+            125,
+            126,
+            127,
+            128,
+            129,
+            130,
+            131,
+            132,
+            133,
+            134,
+            135,
+            136,
+            137,
+            138,
+            139,
+            140,
+            141,
+            142,
+            143,
+            144,
+            145,
+            146,
+            147,
+            148,
+            149,
+            150,
+            151,
+            152,
+            153,
+            154,
+            155,
+            156,
+            157,
+            158,
+            159,
+            160,
+            161,
+            162,
+            163,
+            164,
+            165,
+            166,
+            167,
+            168,
+            169,
+            170,
+            171,
+            172,
+            173,
+            174,
+            175,
+            176,
+            177,
+            178,
+            179,
+            180,
+            181,
+            182,
+            183,
+            184,
+            185,
+            186,
+            187,
+            188,
+            189,
+            190,
+            191,
+            192,
+            193,
+            194,
+            195,
+            196,
+            197,
+            198,
+        ),
+        (
+            0,
+            4,
+            1,
+            6,
+            7,
+            199,
+            2,
+            200,
+            13,
+            201,
+            3,
+            17,
+            25,
+            11,
+            8,
+            24,
+            9,
+            202,
+            15,
+            36,
+            47,
+            55,
+            40,
+            20,
+            26,
+            203,
+            43,
+            204,
+            205,
+            23,
+            12,
+            16,
+            58,
+            39,
+            48,
+            19,
+            27,
+            206,
+            207,
+            208,
+            52,
+            44,
+            209,
+            68,
+            210,
+            211,
+            77,
+            22,
+            212,
+            213,
+            214,
+            64,
+            71,
+            51,
+            215,
+            53,
+            216,
+            217,
+            75,
+            29,
+            218,
+            18,
+            219,
+            96,
+            220,
+            221,
+            72,
+            67,
+            222,
+            73,
+            94,
+            223,
+            131,
+            224,
+            114,
+            124,
+            86,
+            106,
+            225,
+            226,
+            49,
+            227,
+            92,
+            76,
+            70,
+            61,
+            98,
+            87,
+            74,
+            62,
+            228,
+            123,
+            229,
+            120,
+            230,
+            90,
+            231,
+            31,
+            112,
+            113,
+            232,
+            233,
+            234,
+            63,
+            235,
+            83,
+            101,
+            236,
+            140,
+            89,
+            99,
+            80,
+            116,
+            237,
+            138,
+            142,
+            81,
+            238,
+            41,
+            239,
+            240,
+            121,
+            241,
+            127,
+            242,
+            129,
+            117,
+            115,
+            243,
+            244,
+            245,
+            246,
+            93,
+            247,
+            143,
+            248,
+            249,
+            132,
+            250,
+            251,
+            147,
+            252,
+            84,
+            253,
+            151,
+            254,
+            255,
+            146,
+            118,
+            256,
+            257,
+            110,
+            133,
+            258,
+            85,
+            148,
+            259,
+            260,
+            261,
+            262,
+            145,
+            263,
+            264,
+            111,
+            126,
+            265,
+            137,
+            141,
+            266,
+            267,
+            268,
+            269,
+            270,
+            271,
+            272,
+            273,
+            274,
+            275,
+            276,
+            97,
+            277,
+            278,
+            279,
+            280,
+            281,
+            282,
+            283,
+            284,
+            285,
+            286,
+            287,
+            288,
+            289,
+            139,
+            290,
+            291,
+            292,
+            293,
+            294,
+            295,
+        ),
+    ),
+    backbone_mode=False,
+)
+
+# optimizer
+epoch = 800
+eval_epoch = 800
+# epoch = 1600
+# eval_epoch = 1600
+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,
+)
+param_dicts = [dict(keyword="block", lr=0.0005)]
+
+# datasets
+data = dict(
+    num_classes=200,
+    ignore_index=-1,
+    names=CLASS_LABELS_200,
+    train=dict(
+        type="ConcatDataset",
+        datasets=[
+            # Structured3DDataset
+            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=1,
+            ),
+            # ScanNet200Dataset
+            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="ShufflePoint"),
+                    dict(type="Add", keys_dict=dict(condition="ScanNet200")),
+                    dict(type="ToTensor"),
+                    dict(type="Collect", keys=("coord", "grid_coord", "segment", "condition"), feat_keys=("color", "normal")),
+                ],
+                test_mode=False,
+                loop=1,
+            ),
+            # S3DISDataset
+            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,
+            ),
+            # ALC dataset
+            dict(
+                type="ARKitScenesLabelMakerConsensusDataset",
+                split=["train", "val"],
+                data_root="data/alc",
+                transform=[
+                    dict(type="CenterShift", apply_z=True),
+                    dict(type="RandomDropout", dropout_ratio=0.2, dropout_application_ratio=0.2),
+                    # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+                    dict(type="RandomRotate", angle=[-1, 1], axis="z", center=[0, 0, 0], p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+                    dict(type="RandomScale", scale=[0.9, 1.1]),
+                    # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+                    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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+                    # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+                    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="ALC")),
+                    dict(type="ToTensor"),
+                    dict(
+                        type="Collect",
+                        keys=("coord", "grid_coord", "segment", "condition"),
+                        feat_keys=("color", "normal"),
+                    ),
+                ],
+                test_mode=False,
+            ),
+        ],
+        loop=1,
+    ),
+    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="Add", keys_dict=dict(condition="ScanNet200")),
+            dict(type="Collect", keys=("coord", "grid_coord", "segment", "condition"), feat_keys=("color", "normal")),
+        ],
+        test_mode=False,
+    ),
+    test=dict(
+        type="ScanNet200Dataset",
+        split="val",
+        data_root="data/scannet",
+        transform=[dict(type="CenterShift", apply_z=True), dict(type="NormalizeColor")],
+        test_mode=True,
+        test_cfg=dict(
+            voxelize=dict(type="GridSample", grid_size=0.02, hash_type="fnv", mode="test", 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="ScanNet200")),
+                dict(type="ToTensor"),
+                dict(type="Collect", keys=("coord", "grid_coord", "index", "condition"), feat_keys=("color", "normal")),
+            ],
+            aug_transform=[
+                [{"type": "RandomRotateTargetAngle", "angle": [0], "axis": "z", "center": [0, 0, 0], "p": 1}],
+                [{"type": "RandomRotateTargetAngle", "angle": [0.5], "axis": "z", "center": [0, 0, 0], "p": 1}],
+                [{"type": "RandomRotateTargetAngle", "angle": [1], "axis": "z", "center": [0, 0, 0], "p": 1}],
+                [{"type": "RandomRotateTargetAngle", "angle": [1.5], "axis": "z", "center": [0, 0, 0], "p": 1}],
+                [{"type": "RandomRotateTargetAngle", "angle": [0], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [0.95, 0.95]}],
+                [{"type": "RandomRotateTargetAngle", "angle": [0.5], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [0.95, 0.95]}],
+                [{"type": "RandomRotateTargetAngle", "angle": [1], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [0.95, 0.95]}],
+                [{"type": "RandomRotateTargetAngle", "angle": [1.5], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [0.95, 0.95]}],
+                [{"type": "RandomRotateTargetAngle", "angle": [0], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [1.05, 1.05]}],
+                [{"type": "RandomRotateTargetAngle", "angle": [0.5], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [1.05, 1.05]}],
+                [{"type": "RandomRotateTargetAngle", "angle": [1], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [1.05, 1.05]}],
+                [{"type": "RandomRotateTargetAngle", "angle": [1.5], "axis": "z", "center": [0, 0, 0], "p": 1}, {"type": "RandomScale", "scale": [1.05, 1.05]}],
+                [{"type": "RandomFlip", "p": 1}],
+            ],
+        ),
+    ),
+)

configs/scannetpp/semseg-pt-v3m1-2-ppt-extreme-alc.py

@@ -0,0 +1,445 @@
+_base_ = [
+    "../_base_/default_runtime.py",
+    "../_base_/dataset/scannetpp.py",
+]
+
+# misc custom setting
+batch_size = 24  # bs: total bs in all gpus
+num_worker = 48
+mix_prob = 0.8
+empty_cache = False
+enable_amp = True
+find_unused_parameters = True
+
+# trainer
+train = dict(
+    type="MultiDatasetTrainer",
+)
+
+# model settings
+model = dict(
+    type="PPT-v1m2",
+    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", "ScanNet++", "S3DIS", "Structured3D", "ALC"),
+    ),
+    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=("ScanNet", "ScanNet++", "S3DIS", "Structured3D", "ALC"),
+    num_classes=(200, 100, 13, 25, 185),
+)
+
+# scheduler settings
+epoch = 100
+eval_epoch = 100
+# epoch = 200
+# eval_epoch = 200
+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,
+)
+param_dicts = [dict(keyword="block", lr=0.0005)]
+
+# dataset settings
+data = dict(
+    num_classes=100,
+    ignore_index=-1,
+    train=dict(
+        type="ConcatDataset",
+        datasets=[
+            # ScanNet
+            dict(
+                type="ScanNet200Dataset",
+                split=["train", "val"],
+                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="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+                    dict(
+                        type="RandomRotate",
+                        angle=[-1, 1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=0.5,
+                    ),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+                    dict(type="RandomScale", scale=[0.9, 1.1]),
+                    # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+                    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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+                    # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+                    dict(
+                        type="GridSample",
+                        grid_size=0.02,
+                        hash_type="fnv",
+                        mode="train",
+                        return_grid_coord=True,
+                    ),
+                    dict(type="SphereCrop", point_max=204800, mode="random"),
+                    dict(type="CenterShift", apply_z=False),
+                    dict(type="NormalizeColor"),
+                    dict(type="ShufflePoint"),
+                    dict(type="Add", keys_dict={"condition": "ScanNet"}),
+                    dict(type="ToTensor"),
+                    dict(
+                        type="Collect",
+                        keys=("coord", "grid_coord", "segment", "condition"),
+                        feat_keys=("color", "normal"),
+                    ),
+                ],
+                test_mode=False,
+                loop=1,  # sampling weight
+            ),
+            # ScanNetPPDataset
+            dict(
+                type="ScanNetPPDataset",
+                # split="train_grid1mm_chunk6x6_stride3x3",
+                split=[
+                    "train_grid1mm_chunk6x6_stride3x3",
+                    "val_grid1mm_chunk6x6_stride3x3",
+                ],
+                data_root="data/scannetpp",
+                transform=[
+                    dict(type="CenterShift", apply_z=True),
+                    dict(
+                        type="RandomDropout",
+                        dropout_ratio=0.2,
+                        dropout_application_ratio=0.2,
+                    ),
+                    # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+                    dict(
+                        type="RandomRotate",
+                        angle=[-1, 1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=0.5,
+                    ),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+                    dict(type="RandomScale", scale=[0.9, 1.1]),
+                    # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+                    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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+                    # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+                    dict(
+                        type="GridSample",
+                        grid_size=0.02,
+                        hash_type="fnv",
+                        mode="train",
+                        return_grid_coord=True,
+                    ),
+                    dict(type="SphereCrop", point_max=204800, mode="random"),
+                    dict(type="CenterShift", apply_z=False),
+                    dict(type="NormalizeColor"),
+                    # dict(type="ShufflePoint"),
+                    dict(type="Add", keys_dict={"condition": "ScanNet++"}),
+                    dict(type="ToTensor"),
+                    dict(
+                        type="Collect",
+                        keys=("coord", "grid_coord", "segment", "condition"),
+                        feat_keys=("color", "normal"),
+                    ),
+                ],
+                test_mode=False,
+            ),
+            # ALC dataset
+            dict(
+                type="ARKitScenesLabelMakerConsensusDataset",
+                split=["train", "val"],
+                data_root="data/alc",
+                transform=[
+                    dict(type="CenterShift", apply_z=True),
+                    dict(type="RandomDropout", dropout_ratio=0.2, dropout_application_ratio=0.2),
+                    # dict(type="RandomRotateTargetAngle", angle=(1/2, 1, 3/2), center=[0, 0, 0], axis="z", p=0.75),
+                    dict(type="RandomRotate", angle=[-1, 1], axis="z", center=[0, 0, 0], p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="x", p=0.5),
+                    dict(type="RandomRotate", angle=[-1 / 64, 1 / 64], axis="y", p=0.5),
+                    dict(type="RandomScale", scale=[0.9, 1.1]),
+                    # dict(type="RandomShift", shift=[0.2, 0.2, 0.2]),
+                    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="HueSaturationTranslation", hue_max=0.2, saturation_max=0.2),
+                    # dict(type="RandomColorDrop", p=0.2, color_augment=0.0),
+                    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="ALC")),
+                    dict(type="ToTensor"),
+                    dict(
+                        type="Collect",
+                        keys=("coord", "grid_coord", "segment", "condition"),
+                        feat_keys=("color", "normal"),
+                    ),
+                ],
+                test_mode=False,
+                loop=2,
+            ),
+        ],
+    ),
+    val=dict(
+        type="ScanNetPPDataset",
+        split="val",
+        data_root="data/scannetpp",
+        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={"condition": "ScanNet++"}),
+            dict(
+                type="Collect",
+                keys=("coord", "grid_coord", "segment", "condition"),
+                feat_keys=("color", "normal"),
+            ),
+        ],
+        test_mode=False,
+    ),
+    test=dict(
+        type="ScanNetPPDataset",
+        split="test",
+        data_root="data/scannetpp",
+        transform=[
+            dict(type="CenterShift", apply_z=True),
+            dict(type="NormalizeColor"),
+            dict(type="Copy", keys_dict={"segment": "origin_segment"}),
+            dict(
+                type="GridSample",
+                grid_size=0.01,
+                hash_type="fnv",
+                mode="train",
+                keys=("coord", "color", "normal", "segment"),
+                return_inverse=True,
+            ),
+        ],
+        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={"condition": "ScanNet++"}),
+                dict(type="ToTensor"),
+                dict(
+                    type="Collect",
+                    keys=("coord", "grid_coord", "index", "condition"),
+                    feat_keys=("color", "normal"),
+                ),
+            ],
+            aug_transform=[
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    )
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[0.95, 0.95]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[0],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[1],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [
+                    dict(
+                        type="RandomRotateTargetAngle",
+                        angle=[3 / 2],
+                        axis="z",
+                        center=[0, 0, 0],
+                        p=1,
+                    ),
+                    dict(type="RandomScale", scale=[1.05, 1.05]),
+                ],
+                [dict(type="RandomFlip", p=1)],
+            ],
+        ),
+    ),
+)
+
+# hook
+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=True),
+]

pointcept/datasets/alc.py

@@ -0,0 +1,156 @@
+import glob
+import os
+from collections.abc import Sequence
+from copy import deepcopy
+
+import numpy as np
+import torch
+from labelmaker.label_data import get_wordnet
+from torch.utils.data import Dataset
+
+from pointcept.utils.cache import shared_dict
+from pointcept.utils.logger import get_root_logger
+
+from .builder import DATASETS
+from .preprocessing.alc.preprocess_arkitscenes_labelmaker_consensus import get_wordnet_compact_mapping
+from .preprocessing.scannet.meta_data.scannet200_constants import VALID_CLASS_IDS_20, VALID_CLASS_IDS_200
+from .transform import TRANSFORMS, Compose
+
+
+@DATASETS.register_module()
+class ARKitScenesLabelMakerConsensusDataset(Dataset):
+
+    label_key = "semantic_pseudo_gt_wn199"
+
+    def __init__(
+        self,
+        split="train",
+        data_root="data/alc",
+        transform=None,
+        ignore_index=-1,
+        test_mode=False,
+        test_cfg=None,
+        cache=False,
+        loop=1,
+    ):
+        super(ARKitScenesLabelMakerConsensusDataset, self).__init__()
+        self.get_class_to_id()
+
+        self.data_root = data_root
+        self.split = split
+        self.transform = Compose(transform)
+        self.cache = cache
+        self.loop = loop if not test_mode else 1  # force make loop = 1 while in test mode
+        self.test_mode = test_mode
+        self.test_cfg = test_cfg if test_mode else None
+
+        if test_mode:
+            self.test_voxelize = TRANSFORMS.build(self.test_cfg.voxelize)
+            self.test_crop = TRANSFORMS.build(self.test_cfg.crop) if self.test_cfg.crop else None
+            self.post_transform = Compose(self.test_cfg.post_transform)
+            self.aug_transform = [Compose(aug) for aug in self.test_cfg.aug_transform]
+
+        self.data_list = self.get_data_list()
+
+        self.ignore_index = ignore_index
+
+        logger = get_root_logger()
+        logger.info(
+            "Totally {} x {} samples in {} set.".format(
+                len(self.data_list),
+                self.loop,
+                split,
+            )
+        )
+
+    def get_class_to_id(self):
+        self.class2id = get_wordnet_compact_mapping()[0]
+
+    def get_data_list(self):
+        if isinstance(self.split, str):
+            data_list = glob.glob(os.path.join(self.data_root, self.split, "*.pth"))
+        elif isinstance(self.split, Sequence):
+            data_list = []
+            for split in self.split:
+                data_list += glob.glob(os.path.join(self.data_root, split, "*.pth"))
+        else:
+            raise NotImplementedError
+        return data_list
+
+    def get_data(self, idx):
+        data_path = self.data_list[idx % len(self.data_list)]
+
+        if not self.cache:
+            data = torch.load(data_path)
+        else:
+            data_name = data_path.replace(os.path.dirname(self.data_root), "").split(".")[0]
+            cache_name = "pointcept" + data_name.replace(os.path.sep, "-")
+            data = shared_dict(cache_name)
+
+        coord = data["coord"]
+        color = data["color"]
+        normal = data["normal"]
+        scene_id = data["scene_id"]
+        segment = data[self.label_key].reshape(-1)
+        instance = np.ones(coord.shape[0]) * -1
+
+        data_dict = dict(
+            coord=coord,
+            normal=normal,
+            color=color,
+            segment=segment,
+            instance=instance,
+            scene_id=scene_id,
+        )
+
+        return data_dict
+
+    def get_data_name(self, idx):
+        return os.path.basename(self.data_list[idx % len(self.data_list)]).split(".")[0]
+
+    def prepare_train_data(self, idx):
+        # load data
+        data_dict = self.get_data(idx)
+        data_dict = self.transform(data_dict)
+        return data_dict
+
+    def prepare_test_data(self, idx):
+        # load data
+        data_dict = self.get_data(idx)
+        segment = data_dict.pop("segment")
+        data_dict = self.transform(data_dict)
+        data_dict_list = []
+        for aug in self.aug_transform:
+            data_dict_list.append(aug(deepcopy(data_dict)))
+
+        input_dict_list = []
+        for data in data_dict_list:
+            data_part_list = self.test_voxelize(data)
+            for data_part in data_part_list:
+                if self.test_crop:
+                    data_part = self.test_crop(data_part)
+                else:
+                    data_part = [data_part]
+                input_dict_list += data_part
+
+        for i in range(len(input_dict_list)):
+            input_dict_list[i] = self.post_transform(input_dict_list[i])
+        data_dict = dict(fragment_list=input_dict_list, segment=segment, name=self.get_data_name(idx))
+        return data_dict
+
+    def __getitem__(self, idx):
+        if self.test_mode:
+            return self.prepare_test_data(idx)
+        else:
+            return self.prepare_train_data(idx)
+
+    def __len__(self):
+        return len(self.data_list) * self.loop
+
+
+@DATASETS.register_module()
+class ARKitScenesLabelMakerScanNet200Dataset(ARKitScenesLabelMakerConsensusDataset):
+    label_key = "semantic_pseudo_gt_scannet200"
+
+    def get_class_to_id(self):
+        self.class2id = np.array(VALID_CLASS_IDS_200)

pointcept/datasets/preprocessing/alc/preprocess_arkitscenes_labelmaker_consensus.py

@@ -0,0 +1,375 @@
+import warnings
+
+import torch
+
+warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+import argparse
+import glob
+import json
+import multiprocessing as mp
+import os
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import plyfile
+from labelmaker import label_mappings
+from labelmaker.label_data import get_wordnet
+from labelmaker.scannet_200_labels import VALID_CLASS_IDS_200
+from tqdm import tqdm
+
+IGNORE_INDEX = -1
+
+
+def get_wordnet_to_scannet200_mapping():
+    table = pd.read_csv(Path(os.path.dirname(os.path.realpath(label_mappings.__file__))) / "mappings" / "label_mapping.csv")
+    wordnet = get_wordnet()
+    wordnet_keys = [x["name"] for x in wordnet]
+    mapping = {}
+    for row in table.index:
+        if table["wnsynsetkey"][row] not in wordnet_keys:
+            continue
+        scannet_id = table.loc[row, "id"]
+        wordnet199_id = next(x for x in wordnet if x["name"] == table["wnsynsetkey"][row])["id"]
+
+        if scannet_id in VALID_CLASS_IDS_200:
+            mapping.setdefault(wordnet199_id, set()).add(scannet_id)
+
+    wn199_size = np.array([x["id"] for x in wordnet]).max() + 1
+    mapping_array = np.zeros(shape=(wn199_size,), dtype=np.uint16)
+    for wordnet199_id in mapping.keys():
+        mapping_array[wordnet199_id] = min(mapping[wordnet199_id])
+
+    return mapping_array
+
+
+def get_wordnet_compact_mapping():
+    wordnet_info = get_wordnet()[1:]
+    wordnet_info = sorted(wordnet_info, key=lambda x: x["id"])
+
+    class2id = np.array([item["id"] for item in wordnet_info])
+    id2class = np.array([IGNORE_INDEX] * (class2id.max() + 1))
+    for class_, id_ in enumerate(class2id):
+        id2class[id_] = class_
+
+    return class2id, id2class
+
+
+def get_scannet200_compact_mapping():
+    class2id = np.array(VALID_CLASS_IDS_200)
+    id2class = np.array([IGNORE_INDEX] * (class2id.max() + 1))
+    for class_, id_ in enumerate(VALID_CLASS_IDS_200):
+        id2class[id_] = class_
+
+    return class2id, id2class
+
+
+def get_wordnet_names():
+    wordnet_info = get_wordnet()[1:]
+    wordnet_info = sorted(wordnet_info, key=lambda x: x["id"])
+
+    names = [item["name"].split(".")[0].replace("_", " ") for item in wordnet_info]
+
+    return names
+
+
+def read_plypcd(filepath):
+    """Read ply file and return it as numpy array. Returns None if emtpy."""
+
+    with open(filepath, "rb") as f:
+        plydata = plyfile.PlyData.read(f)
+    if plydata.elements:
+        data = plydata.elements[0].data
+        coords = np.array([data["x"], data["y"], data["z"]], dtype=np.float32).T
+
+        colors = None
+        if ({"red", "green", "blue"} - set(data.dtype.names)) == set():
+            colors = np.array([data["red"], data["green"], data["blue"]], dtype=np.uint8).T
+
+        normals = None
+        if ({"nx", "ny", "nz"} - set(data.dtype.names)) == set():
+            normals = np.array([data["nx"], data["ny"], data["nz"]], dtype=np.float32).T
+
+        return coords, colors, normals
+
+
+def handle_process(
+    scene_dir: str,
+    output_path: str,
+    label_mapping,
+    wn199_id2class,
+    scannet200_id2class,
+):
+    scene_dir = Path(scene_dir)
+
+    print(f"Processing: {scene_dir.name} in {scene_dir.parent.name}")
+
+    coords, colors, normals = read_plypcd(str(scene_dir / "pcd_downsampled.ply"))
+    save_dict = dict(
+        coord=coords,
+        color=colors,
+        scene_id=scene_dir.name,
+        normal=normals,
+    )
+
+    label_file = scene_dir / "labels_downsampled.txt"
+    wordnet_label = np.loadtxt(str(label_file), dtype=np.uint8).reshape(-1, 1)
+    scannet200_label = label_mapping[wordnet_label]
+    save_dict["semantic_pseudo_gt_wn199"] = wn199_id2class[wordnet_label]
+    save_dict["semantic_pseudo_gt_scannet200"] = scannet200_id2class[scannet200_label]
+
+    torch.save(save_dict, output_path)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--dataset_root",
+        required=True,
+        help="Path to the ScanNet dataset containing scene folders",
+    )
+    parser.add_argument(
+        "--output_root",
+        required=True,
+        help="Output path where train/val folders will be located",
+    )
+    config = parser.parse_args()
+
+    # Create output directories
+    train_output_dir = os.path.join(config.output_root, "train")
+    os.makedirs(train_output_dir, exist_ok=True)
+    val_output_dir = os.path.join(config.output_root, "val")
+    os.makedirs(val_output_dir, exist_ok=True)
+
+    # Load label map
+    wn_scannet200_label_mapping = get_wordnet_to_scannet200_mapping()
+    _, wn199_id2class = get_wordnet_compact_mapping()
+    _, scannet200_id2class = get_scannet200_compact_mapping()
+
+    scene_dirs = []
+    output_paths = []
+
+    # Load train/val splits
+    train_folder = Path(config.dataset_root) / "Training"
+    train_scene_names = os.listdir(str(train_folder))
+    for scene in tqdm(train_scene_names):
+        file_path = train_folder / scene / "pcd_downsampled.ply"
+        if file_path.exists() and os.path.getsize(str(file_path)) <= 50 * 1024 * 1024:
+            scene_dirs.append(str(train_folder / scene))
+            output_paths.append(str(Path(config.output_root) / "train" / f"{scene}.pth"))
+
+    val_folder = Path(config.dataset_root) / "Validation"
+    val_scene_names = os.listdir(str(val_folder))
+    for scene in tqdm(val_scene_names):
+        file_path = val_folder / scene / "pcd_downsampled.ply"
+        if file_path.exists() and os.path.getsize(str(file_path)) <= 50 * 1024 * 1024:
+            scene_dirs.append(str(val_folder / scene))
+            output_paths.append(str(Path(config.output_root) / "val" / f"{scene}.pth"))
+
+    # Preprocess data.
+    print("Processing scenes...")
+    pool = ProcessPoolExecutor(max_workers=mp.cpu_count())
+    print(f"Using {mp.cpu_count()} cores")
+    # pool = ProcessPoolExecutor(max_workers=1)
+    _ = list(
+        pool.map(
+            handle_process,
+            scene_dirs,
+            output_paths,
+            repeat(wn_scannet200_label_mapping),
+            repeat(wn199_id2class),
+            repeat(scannet200_id2class),
+        )
+    )
+
+
+WORDNET_NAMES = (
+    "wall",
+    "chair",
+    "book",
+    "cabinet",
+    "door",
+    "floor",
+    "ashcan",
+    "table",
+    "window",
+    "bookshelf",
+    "display",
+    "cushion",
+    "box",
+    "picture",
+    "ceiling",
+    "doorframe",
+    "desk",
+    "swivel chair",
+    "towel",
+    "sofa",
+    "sink",
+    "backpack",
+    "lamp",
+    "chest of drawers",
+    "apparel",
+    "armchair",
+    "bed",
+    "curtain",
+    "mirror",
+    "plant",
+    "radiator",
+    "toilet tissue",
+    "shoe",
+    "bag",
+    "bottle",
+    "countertop",
+    "coffee table",
+    "toilet",
+    "computer keyboard",
+    "fridge",
+    "stool",
+    "computer",
+    "mug",
+    "telephone",
+    "light",
+    "jacket",
+    "bathtub",
+    "shower curtain",
+    "microwave",
+    "footstool",
+    "baggage",
+    "laptop",
+    "printer",
+    "shower stall",
+    "soap dispenser",
+    "stove",
+    "fan",
+    "paper",
+    "stand",
+    "bench",
+    "wardrobe",
+    "blanket",
+    "booth",
+    "duplicator",
+    "bar",
+    "soap dish",
+    "switch",
+    "coffee maker",
+    "decoration",
+    "range hood",
+    "blackboard",
+    "clock",
+    "railing",
+    "mat",
+    "seat",
+    "bannister",
+    "container",
+    "mouse",
+    "person",
+    "stairway",
+    "basket",
+    "dumbbell",
+    "column",
+    "bucket",
+    "windowsill",
+    "signboard",
+    "dishwasher",
+    "loudspeaker",
+    "washer",
+    "paper towel",
+    "clothes hamper",
+    "piano",
+    "sack",
+    "handcart",
+    "blind",
+    "dish rack",
+    "mailbox",
+    "bag",
+    "bicycle",
+    "ladder",
+    "rack",
+    "tray",
+    "toaster",
+    "paper cutter",
+    "plunger",
+    "dryer",
+    "guitar",
+    "fire extinguisher",
+    "pitcher",
+    "pipe",
+    "plate",
+    "vacuum",
+    "bowl",
+    "hat",
+    "rod",
+    "water cooler",
+    "kettle",
+    "oven",
+    "scale",
+    "broom",
+    "hand blower",
+    "coatrack",
+    "teddy",
+    "alarm clock",
+    "ironing board",
+    "fire alarm",
+    "machine",
+    "music stand",
+    "fireplace",
+    "furniture",
+    "vase",
+    "vent",
+    "candle",
+    "crate",
+    "dustpan",
+    "earphone",
+    "jar",
+    "projector",
+    "gat",
+    "step",
+    "step stool",
+    "vending machine",
+    "coat",
+    "coat hanger",
+    "drinking fountain",
+    "hamper",
+    "thermostat",
+    "banner",
+    "iron",
+    "soap",
+    "chopping board",
+    "kitchen island",
+    "shirt",
+    "sleeping bag",
+    "tire",
+    "toothbrush",
+    "bathrobe",
+    "faucet",
+    "slipper",
+    "thermos",
+    "tripod",
+    "dispenser",
+    "heater",
+    "pool table",
+    "remote control",
+    "stapler",
+    "treadmill",
+    "beanbag",
+    "dartboard",
+    "metronome",
+    "rope",
+    "sewing machine",
+    "shredder",
+    "toolbox",
+    "water heater",
+    "brush",
+    "control",
+    "dais",
+    "dollhouse",
+    "envelope",
+    "food",
+    "frying pan",
+    "helmet",
+    "tennis racket",
+    "umbrella",
+)