Add files using upload-large-folder tool

configs/_base_/datasets/grass.py

@@ -0,0 +1,50 @@
+dataset_type = 'GrassDataset'
+data_root = 'data/grass'
+
+crop_size = (256, 256)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomCrop', crop_size=crop_size),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=crop_size),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train',
+            seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/val',
+            seg_map_path='ann_dir/val'),
+        pipeline=test_pipeline))
+
+test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=["mIoU", "mDice", "mFscore"],)
+test_evaluator = val_evaluator

configs/_base_/datasets/l8_biome.py

@@ -0,0 +1,62 @@
+dataset_type = 'L8BIOMEDataset'
+data_root = 'data/l8_biome'
+
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='RandomCrop', crop_size=crop_size),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=crop_size),
+    # add loading annotation after ``Resize`` because ground truth
+    # does not need to do resize data transform
+    dict(type='LoadAnnotations'),
+    dict(type='PackSegInputs')
+]
+
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/train',
+            seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/test',
+            seg_map_path='ann_dir/test'),
+        pipeline=test_pipeline))
+
+test_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type=dataset_type,
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='img_dir/test',
+            seg_map_path='ann_dir/test'),
+        pipeline=test_pipeline))
+# test_dataloader = val_dataloader
+
+val_evaluator = dict(type='IoUMetric', iou_metrics=["mIoU", "mDice", "mFscore"],)
+test_evaluator = val_evaluator

configs/_base_/default_runtime.py

@@ -0,0 +1,15 @@
+default_scope = 'mmseg'
+env_cfg = dict(
+    cudnn_benchmark=True,
+    mp_cfg=dict(mp_start_method='fork', opencv_num_threads=0),
+    dist_cfg=dict(backend='nccl'),
+)
+vis_backends = [dict(type='LocalVisBackend')]
+visualizer = dict(
+    type='SegLocalVisualizer', vis_backends=vis_backends, name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None
+resume = False
+
+tta_model = dict(type='SegTTAModel')

configs/_base_/models/convnext_upernet.py

@@ -0,0 +1,52 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+custom_imports = dict(imports='mmpretrain.models', allow_failed_imports=False)
+checkpoint_file = 'checkpoints/convnext-base.pth'  # noqa
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='mmpretrain.ConvNeXt',
+        arch='base',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type='Pretrained', checkpoint=checkpoint_file,
+            prefix='backbone.')),
+    decode_head=dict(
+        type='UPerHead',
+        in_channels=[128, 256, 512, 1024],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=512,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))

configs/_base_/models/convnextv2_femto_vit_segformer_vegseg.py

@@ -0,0 +1,78 @@
+# model settings
+norm_cfg = dict(type="SyncBN", requires_grad=True)
+data_preprocessor = dict(
+    type="SegDataPreProcessor",
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+)
+
+model = dict(
+    type="DistillEncoderDecoder",
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    teach_backbone=dict(
+        type="mmpretrain.VisionTransformer",
+        arch="base",
+        frozen_stages=12,
+        img_size=256,
+        patch_size=14,
+        layer_scale_init_value=1e-5,
+        out_indices=(2, 5, 8, 11),
+        out_type="featmap",
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/dinov2-base.pth",
+            prefix="backbone",
+        ),
+    ),
+    backbone=dict(
+        type="mmpretrain.ConvNeXt",
+        arch='femto',
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.1,
+        layer_scale_init_value=0.,
+        gap_before_final_norm=False,
+        use_grn=True,
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/convnextv2_femote.pth",
+            prefix="backbone",
+        ),
+    ),
+    fam=dict(
+        type="FAM",
+        in_channels=[48, 96, 192, 384],
+        out_channels=768,
+        output_size=19,
+    ),
+    decode_head=dict(
+        type="SegformerHead",
+        in_channels=[768, 768, 768, 768],
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        dropout_ratio=0.1,
+        num_classes=5,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
+    ),
+    auxiliary_head=dict(
+        type="FCNHead",
+        in_channels=768,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=5,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=0.4),
+    ),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode="whole"),
+)

configs/_base_/models/deeplabv3_unet_s5-d16.py

@@ -0,0 +1,58 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='UNet',
+        in_channels=3,
+        base_channels=64,
+        num_stages=5,
+        strides=(1, 1, 1, 1, 1),
+        enc_num_convs=(2, 2, 2, 2, 2),
+        dec_num_convs=(2, 2, 2, 2),
+        downsamples=(True, True, True, True),
+        enc_dilations=(1, 1, 1, 1, 1),
+        dec_dilations=(1, 1, 1, 1),
+        with_cp=False,
+        conv_cfg=None,
+        norm_cfg=norm_cfg,
+        act_cfg=dict(type='ReLU'),
+        upsample_cfg=dict(type='InterpConv'),
+        norm_eval=False),
+    decode_head=dict(
+        type='ASPPHead',
+        in_channels=64,
+        in_index=4,
+        channels=16,
+        dilations=(1, 12, 24, 36),
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=128,
+        in_index=3,
+        channels=64,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=2,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))

configs/_base_/models/deeplabv3plus_r50-d8.py

@@ -0,0 +1,54 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='DepthwiseSeparableASPPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))

configs/_base_/models/dinov2_upernet.py

@@ -0,0 +1,64 @@
+# model settings
+norm_cfg = dict(type="SyncBN", requires_grad=True)
+data_preprocessor = dict(
+    type="SegDataPreProcessor",
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+)
+model = dict(
+    type="EncoderDecoder",
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type="mmpretrain.VisionTransformer",
+        arch="base",
+        frozen_stages=12,
+        img_size=256,
+        patch_size=14,
+        layer_scale_init_value=1e-5,
+        out_indices=(2, 5, 8, 11),
+        out_type = 'featmap',
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/dinov2-base.pth",
+            prefix="backbone",
+        ),
+    ),
+    neck=dict(
+        type="MultiLevelNeck",
+        in_channels=[768, 768, 768, 768],
+        out_channels=768,
+        scales=[4, 2, 1, 0.5],
+    ),
+    decode_head=dict(
+        type="UPerHead",
+        in_channels=[768, 768, 768, 768],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
+    ),
+    auxiliary_head=dict(
+        type="FCNHead",
+        in_channels=768,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=0.4),
+    ),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode="whole"),
+)

configs/_base_/models/fcn_r50-d8.py

@@ -0,0 +1,53 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='FCNHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        num_convs=2,
+        concat_input=True,
+        dropout_ratio=0.1,
+        num_classes=5,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))

configs/_base_/models/ktda.py

@@ -0,0 +1,84 @@
+# model settings
+norm_cfg = dict(type="SyncBN", requires_grad=True)
+data_preprocessor = dict(
+    type="SegDataPreProcessor",
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+)
+
+model = dict(
+    type="DistillEncoderDecoder",
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    teach_backbone=dict(
+        type="mmpretrain.VisionTransformer",
+        arch="base",
+        frozen_stages=12,
+        img_size=256,
+        patch_size=14,
+        layer_scale_init_value=1e-5,
+        out_indices=(2, 5, 8, 11),
+        out_type="featmap",
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/dinov2-base.pth",
+            prefix="backbone",
+        ),
+    ),
+    backbone=dict(
+        type="mmpretrain.ConvNeXt",
+        arch="base",
+        out_indices=[0, 1, 2, 3],
+        drop_path_rate=0.4,
+        layer_scale_init_value=1.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/convnext-base.pth",
+            prefix="backbone.",
+        ),
+    ),
+    fam=dict(
+        type="FAM",
+        in_channels=[128, 256, 512, 1024],
+        out_channels=768,
+        output_size=19,
+    ),
+    neck=dict(
+        type="MultiLevelNeck",
+        in_channels=[768, 768, 768, 768],
+        out_channels=768,
+        scales=[4, 2, 1, 0.5],
+    ),
+    decode_head=dict(
+        type="UPerHead",
+        in_channels=[768, 768, 768, 768],
+        in_index=[0, 1, 2, 3],
+        pool_scales=(1, 2, 3, 6),
+        channels=512,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
+    ),
+    auxiliary_head=dict(
+        type="FCNHead",
+        in_channels=768,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=0.4),
+    ),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode="whole"),
+)

configs/_base_/models/mask2former_r50_8xb2.py

@@ -0,0 +1,131 @@
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=(256,256),
+    test_cfg=dict(size_divisor=32))
+num_classes = 5
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type='ResNet',
+        depth=50,
+        deep_stem=False,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        frozen_stages=-1,
+        norm_cfg=dict(type='SyncBN', requires_grad=False),
+        style='pytorch',
+        init_cfg=dict(type='Pretrained', checkpoint='torchvision://resnet50')),
+    decode_head=dict(
+        type='Mask2FormerHead',
+        in_channels=[256, 512, 1024, 2048],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=num_classes,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type='mmdet.MSDeformAttnPixelDecoder',
+            num_outs=3,
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(  # DeformableDetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4,
+                        im2col_step=64,
+                        dropout=0.0,
+                        batch_first=True,
+                        norm_cfg=None,
+                        init_cfg=None),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        num_fcs=2,
+                        ffn_drop=0.0,
+                        act_cfg=dict(type='ReLU', inplace=True))),
+                init_cfg=None),
+            positional_encoding=dict(  # SinePositionalEncoding
+                num_feats=128, normalize=True),
+            init_cfg=None),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True),
+        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type='ReLU', inplace=True),
+                    ffn_drop=0.0,
+                    dropout_layer=None,
+                    add_identity=True)),
+            init_cfg=None),
+        loss_cls=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=2.0,
+            reduction='mean',
+            class_weight=[1.0] * num_classes + [0.1]),
+        loss_mask=dict(
+            type='mmdet.CrossEntropyLoss',
+            use_sigmoid=True,
+            reduction='mean',
+            loss_weight=5.0),
+        loss_dice=dict(
+            type='mmdet.DiceLoss',
+            use_sigmoid=True,
+            activate=True,
+            reduction='mean',
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=5.0),
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type='mmdet.HungarianAssigner',
+                match_costs=[
+                    dict(type='mmdet.ClassificationCost', weight=2.0),
+                    dict(
+                        type='mmdet.CrossEntropyLossCost',
+                        weight=5.0,
+                        use_sigmoid=True),
+                    dict(
+                        type='mmdet.DiceCost',
+                        weight=5.0,
+                        pred_act=True,
+                        eps=1.0)
+                ]),
+            sampler=dict(type='mmdet.MaskPseudoSampler'))),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))

configs/_base_/models/mask2former_swin-b.py

@@ -0,0 +1,158 @@
+pretrained = "https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_base_patch4_window12_384_20220317-55b0104a.pth"  # noqa
+
+data_preprocessor = dict(
+    type="SegDataPreProcessor",
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+    size=(256, 256),
+)
+num_classes = 150
+
+depths = [2, 2, 18, 2]
+model = dict(
+    type="EncoderDecoder",
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        type="SwinTransformer",
+        pretrain_img_size=384,
+        embed_dims=128,
+        depths=depths,
+        num_heads=[4, 8, 16, 32],
+        window_size=12,
+        mlp_ratio=4,
+        qkv_bias=True,
+        qk_scale=None,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.3,
+        patch_norm=True,
+        out_indices=(0, 1, 2, 3),
+        with_cp=False,
+        frozen_stages=-1,
+        init_cfg=dict(type="Pretrained", checkpoint=pretrained),
+    ),
+    decode_head=dict(
+        type="Mask2FormerHead",
+        in_channels=[128, 256, 512, 1024],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=num_classes,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type="mmdet.MSDeformAttnPixelDecoder",
+            num_outs=3,
+            norm_cfg=dict(type="GN", num_groups=32),
+            act_cfg=dict(type="ReLU"),
+            encoder=dict(  # DeformableDetrTransformerEncoder
+                num_layers=6,
+                layer_cfg=dict(  # DeformableDetrTransformerEncoderLayer
+                    self_attn_cfg=dict(  # MultiScaleDeformableAttention
+                        embed_dims=256,
+                        num_heads=8,
+                        num_levels=3,
+                        num_points=4,
+                        im2col_step=64,
+                        dropout=0.0,
+                        batch_first=True,
+                        norm_cfg=None,
+                        init_cfg=None,
+                    ),
+                    ffn_cfg=dict(
+                        embed_dims=256,
+                        feedforward_channels=1024,
+                        num_fcs=2,
+                        ffn_drop=0.0,
+                        act_cfg=dict(type="ReLU", inplace=True),
+                    ),
+                ),
+                init_cfg=None,
+            ),
+            positional_encoding=dict(  # SinePositionalEncoding
+                num_feats=128, normalize=True
+            ),
+            init_cfg=None,
+        ),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(  # SinePositionalEncoding
+            num_feats=128, normalize=True
+        ),
+        transformer_decoder=dict(  # Mask2FormerTransformerDecoder
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(  # Mask2FormerTransformerDecoderLayer
+                self_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True,
+                ),
+                cross_attn_cfg=dict(  # MultiheadAttention
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True,
+                ),
+                ffn_cfg=dict(
+                    embed_dims=256,
+                    feedforward_channels=2048,
+                    num_fcs=2,
+                    act_cfg=dict(type="ReLU", inplace=True),
+                    ffn_drop=0.0,
+                    dropout_layer=None,
+                    add_identity=True,
+                ),
+            ),
+            init_cfg=None,
+        ),
+        loss_cls=dict(
+            type="mmdet.CrossEntropyLoss",
+            use_sigmoid=False,
+            loss_weight=2.0,
+            reduction="mean",
+            class_weight=[1.0] * num_classes + [0.1],
+        ),
+        loss_mask=dict(
+            type="mmdet.CrossEntropyLoss",
+            use_sigmoid=True,
+            reduction="mean",
+            loss_weight=5.0,
+        ),
+        loss_dice=dict(
+            type="mmdet.DiceLoss",
+            use_sigmoid=True,
+            activate=True,
+            reduction="mean",
+            naive_dice=True,
+            eps=1.0,
+            loss_weight=5.0,
+        ),
+        train_cfg=dict(
+            num_points=12544,
+            oversample_ratio=3.0,
+            importance_sample_ratio=0.75,
+            assigner=dict(
+                type="mmdet.HungarianAssigner",
+                match_costs=[
+                    dict(type="mmdet.ClassificationCost", weight=2.0),
+                    dict(
+                        type="mmdet.CrossEntropyLossCost", weight=5.0, use_sigmoid=True
+                    ),
+                    dict(type="mmdet.DiceCost", weight=5.0, pred_act=True, eps=1.0),
+                ],
+            ),
+            sampler=dict(type="mmdet.MaskPseudoSampler"),
+        ),
+    ),
+    train_cfg=dict(),
+    test_cfg=dict(mode="whole"),
+)

configs/_base_/models/pspnet_r50-d8.py

@@ -0,0 +1,52 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1c',
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=norm_cfg,
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='PSPHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        pool_scales=(1, 2, 3, 6),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=dict(
+        type='FCNHead',
+        in_channels=1024,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))

configs/_base_/models/segformer_mit-b0.py

@@ -0,0 +1,42 @@
+# model settings
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+data_preprocessor = dict(
+    type='SegDataPreProcessor',
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255)
+model = dict(
+    type='EncoderDecoder',
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    backbone=dict(
+        type='MixVisionTransformer',
+        in_channels=3,
+        embed_dims=32,
+        num_stages=4,
+        num_layers=[2, 2, 2, 2],
+        num_heads=[1, 2, 5, 8],
+        patch_sizes=[7, 3, 3, 3],
+        sr_ratios=[8, 4, 2, 1],
+        out_indices=(0, 1, 2, 3),
+        mlp_ratio=4,
+        qkv_bias=True,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.1),
+    decode_head=dict(
+        type='SegformerHead',
+        in_channels=[32, 64, 160, 256],
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))

configs/_base_/models/tiny_vit_segformer_vegseg.py

@@ -0,0 +1,78 @@
+# model settings
+norm_cfg = dict(type="SyncBN", requires_grad=True)
+data_preprocessor = dict(
+    type="SegDataPreProcessor",
+    mean=[123.675, 116.28, 103.53],
+    std=[58.395, 57.12, 57.375],
+    bgr_to_rgb=True,
+    pad_val=0,
+    seg_pad_val=255,
+)
+
+model = dict(
+    type="DistillEncoderDecoder",
+    data_preprocessor=data_preprocessor,
+    pretrained=None,
+    teach_backbone=dict(
+        type="mmpretrain.VisionTransformer",
+        arch="base",
+        frozen_stages=12,
+        img_size=256,
+        patch_size=14,
+        layer_scale_init_value=1e-5,
+        out_indices=(2, 5, 8, 11),
+        out_type="featmap",
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/dinov2-base.pth",
+            prefix="backbone",
+        ),
+    ),
+    backbone=dict(
+        type="mmpretrain.TinyViT",
+        arch="5m",
+        img_size=(256, 256),
+        window_size=[7, 7, 14, 7],
+        out_indices=(0, 1, 2, 3),
+        drop_path_rate=0.0,
+        gap_before_final_norm=False,
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/tiny_vit_5m_imagenet.pth",
+            prefix="backbone",
+        ),
+    ),
+    fam=dict(
+        type="FAM",
+        in_channels=[128, 160, 320, 320],
+        out_channels=768,
+        output_size=19,
+    ),
+    decode_head=dict(
+        type="SegformerHead",
+        in_channels=[768, 768, 768, 768],
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        dropout_ratio=0.1,
+        num_classes=5,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
+    ),
+    auxiliary_head=dict(
+        type="FCNHead",
+        in_channels=768,
+        in_index=2,
+        channels=256,
+        num_convs=1,
+        concat_input=False,
+        dropout_ratio=0.1,
+        num_classes=5,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        loss_decode=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=0.4),
+    ),
+    # model training and testing settings
+    train_cfg=dict(),
+    test_cfg=dict(mode="whole"),
+)

configs/_base_/schedules/grass_schedule.py

@@ -0,0 +1,43 @@
+# optimizer
+optim_wrapper = dict(
+    type="OptimWrapper",
+    optimizer=dict(type="AdamW", lr=0.0006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            "absolute_pos_embed": dict(decay_mult=0.0),
+            "relative_position_bias_table": dict(decay_mult=0.0),
+            "norm": dict(decay_mult=0.0),
+        }
+    ),
+)
+# learning policy
+param_scheduler = [
+    dict(type="LinearLR", start_factor=1e-3, by_epoch=False, begin=0, end=230*5),
+    dict(
+        type="PolyLR",
+        eta_min=0.0,
+        power=0.9,
+        begin=230*5,
+        end=23000,
+        by_epoch=False,
+    ),
+]
+# training schedule for 40k
+train_cfg = dict(type="IterBasedTrainLoop", max_iters=23000, val_interval=230)
+val_cfg = dict(type="ValLoop")
+test_cfg = dict(type="TestLoop")
+default_hooks = dict(
+    timer=dict(type="IterTimerHook"),
+    logger=dict(type="LoggerHook", interval=230, log_metric_by_epoch=False),
+    param_scheduler=dict(type="ParamSchedulerHook"),
+    checkpoint=dict(
+        type="CheckpointHook",
+        by_epoch=False,
+        interval=230,
+        save_best=["mIoU"],
+        rule=["greater"],
+        max_keep_ckpts=1,
+    ),
+    sampler_seed=dict(type="DistSamplerSeedHook"),
+    visualization=dict(type="SegVisualizationHook"),
+)

configs/_base_/schedules/other_dataset_scedule.py

@@ -0,0 +1,43 @@
+# optimizer
+optim_wrapper = dict(
+    type="OptimWrapper",
+    optimizer=dict(type="AdamW", lr=0.0006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            "absolute_pos_embed": dict(decay_mult=0.0),
+            "relative_position_bias_table": dict(decay_mult=0.0),
+            "norm": dict(decay_mult=0.0),
+        }
+    ),
+)
+# learning policy
+param_scheduler = [
+    dict(type="LinearLR", start_factor=1e-3, by_epoch=False, begin=0, end=2000),
+    dict(
+        type="PolyLR",
+        eta_min=0.0,
+        power=0.9,
+        begin=1000,
+        end=80000,
+        by_epoch=False,
+    ),
+]
+# training schedule for 40k
+train_cfg = dict(type="IterBasedTrainLoop", max_iters=80000, val_interval=1000)
+val_cfg = dict(type="ValLoop")
+test_cfg = dict(type="TestLoop")
+default_hooks = dict(
+    timer=dict(type="IterTimerHook"),
+    logger=dict(type="LoggerHook", interval=1000, log_metric_by_epoch=False),
+    param_scheduler=dict(type="ParamSchedulerHook"),
+    checkpoint=dict(
+        type="CheckpointHook",
+        by_epoch=False,
+        interval=1000,
+        save_best=["mIoU"],
+        rule=["greater"],
+        max_keep_ckpts=1,
+    ),
+    sampler_seed=dict(type="DistSamplerSeedHook"),
+    visualization=dict(type="SegVisualizationHook"),
+)

configs/_base_/schedules/schedule_160k.py

@@ -0,0 +1,25 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=160000,
+        by_epoch=False)
+]
+# training schedule for 160k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=160000, val_interval=16000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=16000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))

configs/_base_/schedules/schedule_20k.py

@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=20000,
+        by_epoch=False)
+]
+# training schedule for 20k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=20000, val_interval=2000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))

configs/_base_/schedules/schedule_240k.py

@@ -0,0 +1,25 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=240000,
+        by_epoch=False)
+]
+# training schedule for 240k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=240000, val_interval=24000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=24000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))

configs/_base_/schedules/schedule_25k.py

@@ -0,0 +1,28 @@
+# optimizer
+optimizer = dict(type='AdamW', lr=0.001, weight_decay=0.1)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='LinearLR', start_factor=3e-2, begin=0, end=12000,
+        by_epoch=False),
+    dict(
+        type='PolyLRRatio',
+        eta_min_ratio=3e-2,
+        power=0.9,
+        begin=12000,
+        end=24000,
+        by_epoch=False),
+    dict(type='ConstantLR', by_epoch=False, factor=1, begin=24000, end=25000)
+]
+# training schedule for 25k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=25000, val_interval=1000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=2000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))

configs/_base_/schedules/schedule_320k.py

@@ -0,0 +1,25 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=320000,
+        by_epoch=False)
+]
+# training schedule for 320k
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=320000, val_interval=32000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=32000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))

configs/_base_/schedules/schedule_40k.py

@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=40000,
+        by_epoch=False)
+]
+# training schedule for 40k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=40000, val_interval=4000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=4000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))

configs/_base_/schedules/schedule_80k.py

@@ -0,0 +1,24 @@
+# optimizer
+optimizer = dict(type='SGD', lr=0.01, momentum=0.9, weight_decay=0.0005)
+optim_wrapper = dict(type='OptimWrapper', optimizer=optimizer, clip_grad=None)
+# learning policy
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=1e-4,
+        power=0.9,
+        begin=0,
+        end=80000,
+        by_epoch=False)
+]
+# training schedule for 80k
+train_cfg = dict(type='IterBasedTrainLoop', max_iters=80000, val_interval=8000)
+val_cfg = dict(type='ValLoop')
+test_cfg = dict(type='TestLoop')
+default_hooks = dict(
+    timer=dict(type='IterTimerHook'),
+    logger=dict(type='LoggerHook', interval=50, log_metric_by_epoch=False),
+    param_scheduler=dict(type='ParamSchedulerHook'),
+    checkpoint=dict(type='CheckpointHook', by_epoch=False, interval=8000),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))

configs/_base_/schedules/water_schedule.py

@@ -0,0 +1,43 @@
+# optimizer
+optim_wrapper = dict(
+    type="OptimWrapper",
+    optimizer=dict(type="AdamW", lr=0.0006, betas=(0.9, 0.999), weight_decay=0.01),
+    paramwise_cfg=dict(
+        custom_keys={
+            "absolute_pos_embed": dict(decay_mult=0.0),
+            "relative_position_bias_table": dict(decay_mult=0.0),
+            "norm": dict(decay_mult=0.0),
+        }
+    ),
+)
+# learning policy
+param_scheduler = [
+    dict(type="LinearLR", start_factor=1e-3, by_epoch=False, begin=0, end=760*5),
+    dict(
+        type="PolyLR",
+        eta_min=0.0,
+        power=0.9,
+        begin=760*5,
+        end=76000,
+        by_epoch=False,
+    ),
+]
+# training schedule for 40k
+train_cfg = dict(type="IterBasedTrainLoop", max_iters=76000, val_interval=760)
+val_cfg = dict(type="ValLoop")
+test_cfg = dict(type="TestLoop")
+default_hooks = dict(
+    timer=dict(type="IterTimerHook"),
+    logger=dict(type="LoggerHook", interval=760, log_metric_by_epoch=False),
+    param_scheduler=dict(type="ParamSchedulerHook"),
+    checkpoint=dict(
+        type="CheckpointHook",
+        by_epoch=False,
+        interval=760,
+        save_best=["mIoU"],
+        rule=["greater"],
+        max_keep_ckpts=1,
+    ),
+    sampler_seed=dict(type="DistSamplerSeedHook"),
+    visualization=dict(type="SegVisualizationHook"),
+)

configs/convnext/convnext-v2-femto_upernet.py

@@ -0,0 +1,13 @@
+_base_ = [
+    "../_base_/models/convnext_upernet.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5)
+)

configs/convnext/convnext_b_upernet.py

@@ -0,0 +1,13 @@
+_base_ = [
+    "../_base_/models/convnext_upernet.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5)
+)

configs/deeplabv3plus/deeplabv3plus_r101.py

@@ -0,0 +1,15 @@
+_base_ = [
+    "../_base_/models/deeplabv3plus_r50-d8.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c', 
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5)
+)

configs/deeplabv3plus/deeplabv3plus_r101_water.py

@@ -0,0 +1,15 @@
+_base_ = [
+    "../_base_/models/deeplabv3plus_r50-d8.py",
+    "../_base_/datasets/water.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/water_schedule.py",
+]
+
+data_preprocessor = dict(size=(512, 512))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c', 
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6)
+)

configs/dinov2/dinov2_upernet.py

@@ -0,0 +1,13 @@
+_base_ = [
+    "../_base_/models/dinov2_upernet.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5)
+)

configs/dinov2/dinov2_upernet_focal_loss.py

@@ -0,0 +1,31 @@
+_base_ = [
+    "../_base_/models/dinov2_upernet.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=5,
+        loss_decode=[
+            dict(type="FocalLoss", use_sigmoid=True, loss_weight=1.0),
+            dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
+        ],
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="work_dirs/dinov2_b_frozen-simpleAdapter/head.pth",
+            prefix="decode_head",
+        ),
+    ),
+    auxiliary_head=dict(
+        num_classes=5,
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="work_dirs/dinov2_b_frozen-simpleAdapter/auxiliary_head.pth",
+            prefix="auxiliary_head",
+        ),
+    ),
+)

configs/dinov2/full_dinov2_upernet.py

@@ -0,0 +1,16 @@
+_base_ = [
+    "../_base_/models/dinov2_upernet.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    backbone=dict(
+        frozen_stages=-1
+    ),
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5)
+)

configs/fcn/fcn_r101.py

@@ -0,0 +1,15 @@
+_base_ = [
+    "../_base_/models/fcn_r50-d8.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    pretrained='open-mmlab://resnet101_v1c', 
+    backbone=dict(depth=101),
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5)
+)

configs/fcn/fcn_r50.py

@@ -0,0 +1,13 @@
+_base_ = [
+    "../_base_/models/fcn_r50-d8.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5)
+)

configs/fcn/fcn_r50_water.py

@@ -0,0 +1,13 @@
+_base_ = [
+    "../_base_/models/fcn_r50-d8.py",
+    "../_base_/datasets/water.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/water_schedule.py",
+]
+
+data_preprocessor = dict(size=(512, 512))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=6),
+    auxiliary_head=dict(num_classes=6)
+)

configs/ktda/convnextv2_femote_student_adapter_segmormer_head.py

@@ -0,0 +1,13 @@
+_base_ = [
+    "../_base_/models/convnextv2_femto_vit_segformer_vegseg.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5),
+)

configs/ktda/dinov2_b_frozen-fam-fmm_focallLoss.py

@@ -0,0 +1,22 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(
+        num_classes=5,
+        loss_decode=[
+            dict(type="FocalLoss", use_sigmoid=True, loss_weight=1.0),
+            dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
+        ],
+    ),
+    auxiliary_head=dict(
+        num_classes=5,
+    ),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768]),
+)

configs/ktda/dinov2_b_frozen-fam-fmm_frozen_stu.py

@@ -0,0 +1,22 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    student_training=False,
+    backbone=dict(
+        frozen_stages=4,
+    ),
+    decode_head=dict(
+        num_classes=5,
+    ),
+    auxiliary_head=dict(
+        num_classes=5,
+    ),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768]),
+)

configs/ktda/dinov2_b_frozen-fam-fmm_not_distill.py

@@ -0,0 +1,19 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    student_training=False,
+    decode_head=dict(
+        num_classes=5,
+    ),
+    auxiliary_head=dict(
+        num_classes=5,
+    ),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768]),
+)

configs/ktda/experiment_ab.py

@@ -0,0 +1,46 @@
+_base_ = [
+    "../_base_/models/tiny_vit_segformer_vegseg.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    teach_backbone=dict(
+        type="mmpretrain.VisionTransformer",
+        arch="large",
+        frozen_stages=24,
+        img_size=256,
+        patch_size=14,
+        layer_scale_init_value=1e-5,
+        out_indices=(7, 11, 15, 23),
+        out_type="featmap",
+        init_cfg=dict(
+            type="Pretrained",
+            checkpoint="checkpoints/dinov2-large.pth",
+            prefix="backbone",
+        ),
+    ),
+    fam=dict(out_channels=1024),
+    decode_head=dict(in_channels=[1024, 1024, 1024, 1024], num_classes=5),
+    data_preprocessor=data_preprocessor,
+    auxiliary_head=[
+        dict(
+            type="FCNHead",
+            in_channels=1024,
+            in_index=i,
+            channels=256,
+            num_convs=1,
+            concat_input=False,
+            dropout_ratio=0.1,
+            num_classes=5,
+            norm_cfg=dict(type="SyncBN", requires_grad=True),
+            align_corners=False,
+            loss_decode=dict(
+                type="CrossEntropyLoss", use_sigmoid=False, loss_weight=0.4
+            ),
+        )
+        for i in range(4)
+    ],
+)

configs/ktda/experiment_c.py

@@ -0,0 +1,14 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768]),
+)

configs/ktda/experiment_d.py

@@ -0,0 +1,13 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=None
+)

configs/ktda/experiment_e.py

@@ -0,0 +1,15 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    alpha=0,
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768]),
+)

configs/ktda/experiment_f.py

@@ -0,0 +1,15 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    alpha=1,
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768]),
+)

configs/ktda/experiment_g.py

@@ -0,0 +1,18 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    teach_backbone=dict(out_indices=(11)),
+    backbone=dict(out_indices=(3)),
+    fam=dict(in_channels=[1024]),
+    neck=dict(in_channels=[768], scales=[1]),
+    decode_head=dict(num_classes=5,in_channels=[768],in_index=[0]),
+    auxiliary_head=dict(num_classes=5,in_index=0),
+    fmm=dict(type="FMM", in_channels=[768]),
+)

configs/ktda/experiment_h.py

@@ -0,0 +1,16 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    fuse=True,
+    neck=dict(in_channels=[768], scales=[1]),
+    decode_head=dict(num_classes=5,in_channels=[768],in_index=[0]),
+    auxiliary_head=dict(num_classes=5,in_index=0),
+    fmm=dict(type="FMM", in_channels=[768]),
+)

configs/ktda/experiment_i.py

@@ -0,0 +1,14 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768],mlp_nums=2),
+)

configs/ktda/experiment_j.py

@@ -0,0 +1,14 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5),
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768],mlp_nums=3),
+)

configs/ktda/experiment_l.py

@@ -0,0 +1,14 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=None,
+    fmm=dict(type="FMM", in_channels=[768, 768, 768, 768]),
+)

configs/ktda/experiment_m.py

@@ -0,0 +1,16 @@
+_base_ = [
+    "../_base_/models/ktda.py",
+    "../_base_/datasets/grass.py",
+    "../_base_/default_runtime.py",
+    "../_base_/schedules/grass_schedule.py",
+]
+
+data_preprocessor = dict(size=(256, 256))
+model = dict(
+    data_preprocessor=data_preprocessor,
+    decode_head=dict(num_classes=5),
+    auxiliary_head=dict(num_classes=5),
+    fmm=dict(
+        type="FMM", in_channels=[768, 768, 768, 768], model_type="vitBlock"
+    ),
+)