Upload folder using huggingface_hub

README.md

@@ -0,0 +1,90 @@
+# SFM: Spatial Frequency Modulation for Semantic Segmentation (TPAMI 2025)
+
+Official checkpoints for the paper **Spatial Frequency Modulation for Semantic Segmentation**
+(TPAMI 2025, [arXiv:2507.11893](https://arxiv.org/abs/2507.11893),
+DOI [10.1109/TPAMI.2025.3592621](https://doi.org/10.1109/TPAMI.2025.3592621)).
+
+Code: **https://github.com/Linwei-Chen/SFM**
+
+Two released technical lines:
+
+- **Line 1 — FCN-style models**: ARS + qhull non-uniform upsampling (MSAU, paper Eq. 17/18)
+  + cascaded LPRM, built on mmsegmentation 0.25.0.
+  Eval code and the 18 configs: [`SFM_mmseg0x/`](https://github.com/Linwei-Chen/SFM/tree/main/SFM_mmseg0x).
+- **Line 2 — FPN**: ARS + CARAFE-style feature reassembly with 3-point dynamic-sampling
+  weighted alignment, on Mask2Former (mmsegmentation 1.x).
+  Code and config: [`SFM_mask2former/`](https://github.com/Linwei-Chen/SFM/tree/main/SFM_mask2former).
+
+Every checkpoint below is **verified from training/eval logs to meet or exceed the
+paper-reported mIoU**. Each model folder contains `config.py` (the exact config paired
+with that checkpoint) and the weight file.
+
+## Line 1 — Cityscapes (val mIoU, ResNet-50)
+
+| folder | paper | measured |
+| --- | --- | --- |
+| `line1/cityscapes/ccnet_r50SS3PR-d32_cityscapes` | 76.3 | **76.34** |
+| `line1/cityscapes/ccnet_r50SS3PR-d16_cityscapes` | 78.5 | 78.45 |
+| `line1/cityscapes/ccnet_r50SS3PR-d8_cityscapes` | 79.3 | **79.39** |
+| `line1/cityscapes/isanet_r50SS3PR-d32_cityscapes` (OCNet) | 75.8 | **75.82** |
+| `line1/cityscapes/isanet_r50SS3PR-d16_cityscapes` (OCNet) | 78.0 | **78.00** |
+| `line1/cityscapes/isanet_r50SS3PR-d8_cityscapes` (OCNet) | 79.7 | **79.74** |
+| `line1/cityscapes/FCN_r50SS3PR-d32_cityscapes` | 76.2 | **76.20** |
+| `line1/cityscapes/FCN_r50SS3PR-d16_cityscapes` | 77.8 | 77.78 |
+| `line1/cityscapes/FCN_r50SS3PR-d8_cityscapes` | 78.7 | 78.65 |
+| `line1/cityscapes/pspnet_r50SS3PR-d32_cityscapes` | 76.0 | **76.18** |
+| `line1/cityscapes/pspnet_r50SS3PR-d16_cityscapes` | 78.1 | 78.05 |
+| `line1/cityscapes/pspnet_r50SS3PR-d8_cityscapes` | 79.5 | **79.52** |
+| `line1/cityscapes/pcaa_r50SSPR-d32_cityscapes` (PCAA, col. 1) | 76.8 | **76.83** |
+| `line1/cityscapes/pcaa_r50SSPR-d16_cityscapes` (PCAA, col. 2) | 77.9 | 77.86 |
+
+Weight file in each folder: `iter_40000.pth`.
+
+## Line 1 — PascalContext-59 (val mIoU, ResNet-50)
+
+| folder | paper | measured |
+| --- | --- | --- |
+| `line1/pascalcontext/FCN_r50SS3PR-d32_pascalcontext` | 46.0 | **46.35** |
+| `line1/pascalcontext/pspnet_r50SS3PR-d32_pascalcontext` | 49.7 | 49.68 |
+| `line1/pascalcontext/ccnet_r50SS3PR-d32_pascalcontext` | 49.1 | 49.07 |
+| `line1/pascalcontext/isanet_r50SS3PR-d32_pascalcontext` (OCNet) | 49.9 | 49.85 |
+
+## Line 2 — ADE20K (val mIoU, Mask2Former Swin-T)
+
+| folder | paper | measured |
+| --- | --- | --- |
+| `line2/mask2former_swin-t_8xb2-160k_ade20k-512x512_SFMv2` | 49.1 | **49.34** (re-evaluated 2025-10) |
+
+Weight file: `best_mIoU_iter_150000.pth`.
+
+## Evaluation
+
+**Line 1** (see [`SFM_mmseg0x/README.md`](https://github.com/Linwei-Chen/SFM/blob/main/SFM_mmseg0x/README.md)
+for environment setup and qhull compilation):
+
+```bash
+PYTHONPATH=<SFM_mmseg0x> python tools/test.py \
+    <model_folder>/config.py <model_folder>/iter_40000.pth --eval mIoU
+```
+
+**Line 2** (see [`SFM_mask2former/`](https://github.com/Linwei-Chen/SFM/tree/main/SFM_mask2former)):
+download the checkpoint, point `load_from` in
+[`mask2former_swin-t_8xb2-160k_ade20k-512x512_SFMv2.py`](https://github.com/Linwei-Chen/SFM/blob/main/SFM_mask2former/configs/mask2former/mask2former_swin-t_8xb2-160k_ade20k-512x512_SFMv2.py)
+to it, then run the standard mmseg 1.x `tools/test.py` with the config.
+
+## Citation
+
+```bibtex
+@article{chen2023spatialfrequency,
+  title={Spatial Frequency Modulation for Semantic Segmentation},
+  author={Chen, Linwei and Fu, Ying and Gu, Lin and Zheng, Dezhi and Dai, Jifeng},
+  journal={IEEE Transactions on Pattern Analysis and Machine Intelligence},
+  year={2025},
+  volume={47},
+  number={11},
+  pages={9767-9784},
+  doi={10.1109/TPAMI.2025.3592621}
+}
+```
+
+Code is released under the Apache-2.0 license.

line1/cityscapes/FCN_r50SS3PR-d16_cityscapes/config.py

@@ -0,0 +1,195 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge', 'none'),
+        use_lpf=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/FCN_r50SS3PR-d16_cityscapes/iter_40000.pth

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

line1/cityscapes/FCN_r50SS3PR-d32_cityscapes/config.py

@@ -0,0 +1,196 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        use_lpf=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/FCN_r50SS3PR-d32_cityscapes/iter_40000.pth

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

line1/cityscapes/FCN_r50SS3PR-d8_cityscapes/config.py

@@ -0,0 +1,195 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'none', 'none'),
+        use_lpf=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/FCN_r50SS3PR-d8_cityscapes/iter_40000.pth

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

line1/cityscapes/ccnet_r50SS3PR-d16_cityscapes/config.py

@@ -0,0 +1,195 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge', 'none'),
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='CCHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        recurrence=2,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/ccnet_r50SS3PR-d16_cityscapes/iter_40000.pth

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

line1/cityscapes/ccnet_r50SS3PR-d32_cityscapes/config.py

@@ -0,0 +1,196 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='CCHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        recurrence=2,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/ccnet_r50SS3PR-d32_cityscapes/iter_40000.pth

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

line1/cityscapes/ccnet_r50SS3PR-d8_cityscapes/config.py

@@ -0,0 +1,196 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'none', 'none'),
+        psp_ratio=4,
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='CCHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        recurrence=2,
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/ccnet_r50SS3PR-d8_cityscapes/iter_40000.pth

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

line1/cityscapes/isanet_r50SS3PR-d16_cityscapes/config.py

@@ -0,0 +1,198 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge', 'none'),
+        use_lpf=False,
+        use_checkpoint=False,
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ISAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        isa_channels=256,
+        down_factor=(8, 8),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/isanet_r50SS3PR-d16_cityscapes/iter_40000.pth

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

line1/cityscapes/isanet_r50SS3PR-d32_cityscapes/config.py

@@ -0,0 +1,199 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        use_lpf=False,
+        use_checkpoint=False,
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ISAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        isa_channels=256,
+        down_factor=(8, 8),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/isanet_r50SS3PR-d32_cityscapes/iter_40000.pth

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

line1/cityscapes/isanet_r50SS3PR-d8_cityscapes/config.py

@@ -0,0 +1,197 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'none', 'none'),
+        use_checkpoint=True,
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ISAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        isa_channels=256,
+        down_factor=(8, 8),
+        dropout_ratio=0.1,
+        num_classes=19,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/isanet_r50SS3PR-d8_cityscapes/iter_40000.pth

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

line1/cityscapes/pcaa_r50SSPR-d16_cityscapes/config.py

@@ -0,0 +1,190 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(512, 1024), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2048, 1024),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(512, 1024), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2048, 1024),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2048, 1024),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = False
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        align_corners=False,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge', 'none'),
+        use_checkpoint=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='CAAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dropout=True,
+        num_classes=19,
+        align_corners=False),
+    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=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/pcaa_r50SSPR-d16_cityscapes/iter_40000.pth

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

line1/cityscapes/pcaa_r50SSPR-d32_cityscapes/config.py

@@ -0,0 +1,191 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (512, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(512, 1024), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2048, 1024),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(512, 1024), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2048, 1024),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2048, 1024),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = False
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        align_corners=False,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        use_checkpoint=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='CAAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dropout=False,
+        num_classes=19,
+        align_corners=False),
+    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=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/pcaa_r50SSPR-d32_cityscapes/iter_40000.pth

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

line1/cityscapes/pspnet_r50SS3PR-d16_cityscapes/config.py

@@ -0,0 +1,197 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge', 'none'),
+        use_lpf=False,
+        use_checkpoint=False,
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 2),
+        strides=(1, 2, 2, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/pspnet_r50SS3PR-d16_cityscapes/iter_40000.pth

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

line1/cityscapes/pspnet_r50SS3PR-d32_cityscapes/config.py

@@ -0,0 +1,199 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        psp_ratio=4,
+        use_lpf=False,
+        use_checkpoint=False,
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/pspnet_r50SS3PR-d32_cityscapes/iter_40000.pth

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

line1/cityscapes/pspnet_r50SS3PR-d8_cityscapes/config.py

@@ -0,0 +1,197 @@
+dataset_type = 'CityscapesDataset'
+data_root = './data/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 1025)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations'),
+    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 1025),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 8
+GPU = 1
+data = dict(
+    samples_per_gpu=8,
+    workers_per_gpu=10,
+    train=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/train',
+        ann_dir='cityscapes/gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations'),
+            dict(
+                type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 1025), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 1025), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='CityscapesDataset',
+        data_root='./data/',
+        img_dir='cityscapes/leftImg8bit/val',
+        ann_dir='cityscapes/gtFine/val',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 1025),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.01,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = True
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16, 32, 64],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'none', 'none'),
+        use_lpf=False,
+        psp_ratio=4,
+        align_corners=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 2, 4),
+        strides=(1, 2, 1, 1),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/cityscapes/pspnet_r50SS3PR-d8_cityscapes/iter_40000.pth

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

line1/pascalcontext/FCN_r50SS3PR-d32_pascalcontext/config.py

@@ -0,0 +1,203 @@
+dataset_type = 'PascalContextDataset59'
+data_root = './data/VOCdevkit/VOC2010/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 513)
+img_scale = (2049, 513)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 513),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 16
+GPU = 1
+data = dict(
+    samples_per_gpu=16,
+    workers_per_gpu=10,
+    train=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/train.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', reduce_zero_label=True),
+            dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.004,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    use_adaptive_residual=False,
+    pixel_relation=[1, 2, 4, 8, 16],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        psp_ratio=4,
+        use_lpf=False,
+        align_corners=True,
+        use_checkpoint=True,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/pascalcontext/FCN_r50SS3PR-d32_pascalcontext/iter_40000.pth

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

line1/pascalcontext/ccnet_r50SS3PR-d32_pascalcontext/config.py

@@ -0,0 +1,200 @@
+dataset_type = 'PascalContextDataset59'
+data_root = './data/VOCdevkit/VOC2010/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 513)
+img_scale = (2049, 513)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 513),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 16
+GPU = 1
+data = dict(
+    samples_per_gpu=16,
+    workers_per_gpu=10,
+    train=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/train.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', reduce_zero_label=True),
+            dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.004,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        use_lpf=False,
+        align_corners=True,
+        use_checkpoint=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='CCHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        recurrence=2,
+        dropout_ratio=0.1,
+        num_classes=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/pascalcontext/ccnet_r50SS3PR-d32_pascalcontext/iter_40000.pth

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

line1/pascalcontext/isanet_r50SS3PR-d32_pascalcontext/config.py

@@ -0,0 +1,202 @@
+dataset_type = 'PascalContextDataset59'
+data_root = './data/VOCdevkit/VOC2010/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 513)
+img_scale = (2049, 513)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 513),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 16
+GPU = 1
+data = dict(
+    samples_per_gpu=16,
+    workers_per_gpu=10,
+    train=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/train.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', reduce_zero_label=True),
+            dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.004,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    use_adaptive_residual=False,
+    pixel_relation=[1, 2, 4, 8, 16],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        use_lpf=False,
+        align_corners=True,
+        use_checkpoint=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        norm_eval=False,
+        style='pytorch',
+        contract_dilation=True),
+    decode_head=dict(
+        type='ISAHead',
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        isa_channels=256,
+        down_factor=(8, 8),
+        dropout_ratio=0.1,
+        num_classes=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/pascalcontext/isanet_r50SS3PR-d32_pascalcontext/iter_40000.pth

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

line1/pascalcontext/pspnet_r50SS3PR-d32_pascalcontext/config.py

@@ -0,0 +1,200 @@
+dataset_type = 'PascalContextDataset59'
+data_root = './data/VOCdevkit/VOC2010/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (513, 513)
+img_scale = (2049, 513)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(
+        type='Normalize',
+        mean=[123.675, 116.28, 103.53],
+        std=[58.395, 57.12, 57.375],
+        to_rgb=True),
+    dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+    dict(type='DefaultFormatBundle'),
+    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(
+        type='MultiScaleFlipAug',
+        img_scale=(2049, 513),
+        flip=False,
+        transforms=[
+            dict(type='Resize', keep_ratio=True),
+            dict(type='RandomFlip'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='ImageToTensor', keys=['img']),
+            dict(type='Collect', keys=['img'])
+        ])
+]
+BATCH_SIZE = 16
+GPU = 1
+data = dict(
+    samples_per_gpu=16,
+    workers_per_gpu=10,
+    train=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/train.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', reduce_zero_label=True),
+            dict(type='Resize', img_scale=(2049, 513), ratio_range=(0.5, 2.0)),
+            dict(type='RandomCrop', crop_size=(513, 513), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(
+                type='Normalize',
+                mean=[123.675, 116.28, 103.53],
+                std=[58.395, 57.12, 57.375],
+                to_rgb=True),
+            dict(type='Pad', size=(513, 513), pad_val=0, seg_pad_val=255),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]),
+    test=dict(
+        type='PascalContextDataset59',
+        data_root='./data/VOCdevkit/VOC2010/',
+        img_dir='JPEGImages',
+        ann_dir='SegmentationClassContext',
+        split='ImageSets/SegmentationContext/val.txt',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(
+                type='MultiScaleFlipAug',
+                img_scale=(2049, 513),
+                flip=False,
+                transforms=[
+                    dict(type='Resize', keep_ratio=True),
+                    dict(type='RandomFlip'),
+                    dict(
+                        type='Normalize',
+                        mean=[123.675, 116.28, 103.53],
+                        std=[58.395, 57.12, 57.375],
+                        to_rgb=True),
+                    dict(type='ImageToTensor', keys=['img']),
+                    dict(type='Collect', keys=['img'])
+                ])
+        ]))
+ITER_SETTING = 40000
+optimizer = dict(
+    type='SGD',
+    lr=0.004,
+    momentum=0.9,
+    weight_decay=0.0005,
+    paramwise_cfg=dict(
+        custom_keys=dict(
+            head=dict(lr_mult=2.0),
+            SS=dict(lr_mult=2.0),
+            pixelrelation=dict(lr_mult=2.0))))
+optimizer_config = dict()
+lr_config = dict(policy='poly', power=0.9, min_lr=0.0001, by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=40000)
+checkpoint_config = dict(by_epoch=False, interval=4000)
+evaluation = dict(interval=4000, metric='mIoU', pre_eval=True)
+log_config = dict(
+    interval=10, hooks=[dict(type='TextLoggerHook', by_epoch=False)])
+dist_params = dict(backend='nccl')
+log_level = 'INFO'
+load_from = None
+resume_from = None
+workflow = [('train', 1)]
+cudnn_benchmark = False
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+LOG_DIR = None
+SAMPLER_NUM = 3
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[1, 2, 4, 8, 16],
+    sampler_num=3,
+    pretrained='open-mmlab://resnet50_v1c',
+    backbone=dict(
+        type='ResNetV1cSaliencySampler',
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avgpsp_semantic_edge', 'avgpsp_semantic_edge',
+                      'avgpsp_semantic_edge'),
+        use_lpf=False,
+        align_corners=True,
+        use_checkpoint=False,
+        depth=50,
+        num_stages=4,
+        out_indices=(0, 1, 2, 3),
+        dilations=(1, 1, 1, 1),
+        strides=(1, 2, 2, 2),
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        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=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        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=59,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=True,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+work_dir = 'work_dirs'
+gpu_ids = [0]
+auto_resume = False

line1/pascalcontext/pspnet_r50SS3PR-d32_pascalcontext/iter_40000.pth

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

line2/mask2former_swin-t_8xb2-160k_ade20k-512x512_SFMv2/best_mIoU_iter_150000.pth

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

line2/mask2former_swin-t_8xb2-160k_ade20k-512x512_SFMv2/config.py

@@ -0,0 +1,483 @@
+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=[dict(type='LocalVisBackend')],
+    name='visualizer')
+log_processor = dict(by_epoch=False)
+log_level = 'INFO'
+load_from = None  # 从 HuggingFace 下载 mask2former_swin-t_SFMv2_ade20k 权重后，用 tools/test.py 传入
+resume = False
+tta_model = dict(type='SegTTAModel')
+dataset_type = 'ADE20KDataset'
+data_root = './data/ADEChallengeData2016'
+crop_size = (512, 512)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(
+        type='RandomChoiceResize',
+        scales=[
+            256, 307, 358, 409, 460, 512, 563, 614, 665, 716, 768, 819, 870,
+            921, 972, 1024
+        ],
+        resize_type='ResizeShortestEdge',
+        max_size=2048),
+    dict(type='RandomCrop', crop_size=(512, 512), cat_max_ratio=0.75),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='PhotoMetricDistortion'),
+    dict(type='PackSegInputs')
+]
+test_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='LoadAnnotations', reduce_zero_label=True),
+    dict(type='PackSegInputs')
+]
+img_ratios = [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+tta_pipeline = [
+    dict(type='LoadImageFromFile', backend_args=None),
+    dict(
+        type='TestTimeAug',
+        transforms=[[{
+            'type': 'Resize',
+            'scale_factor': 0.5,
+            'keep_ratio': True
+        }, {
+            'type': 'Resize',
+            'scale_factor': 0.75,
+            'keep_ratio': True
+        }, {
+            'type': 'Resize',
+            'scale_factor': 1.0,
+            'keep_ratio': True
+        }, {
+            'type': 'Resize',
+            'scale_factor': 1.25,
+            'keep_ratio': True
+        }, {
+            'type': 'Resize',
+            'scale_factor': 1.5,
+            'keep_ratio': True
+        }, {
+            'type': 'Resize',
+            'scale_factor': 1.75,
+            'keep_ratio': True
+        }],
+                    [{
+                        'type': 'RandomFlip',
+                        'prob': 0.0,
+                        'direction': 'horizontal'
+                    }, {
+                        'type': 'RandomFlip',
+                        'prob': 1.0,
+                        'direction': 'horizontal'
+                    }], [{
+                        'type': 'LoadAnnotations'
+                    }], [{
+                        'type': 'PackSegInputs'
+                    }]])
+]
+train_dataloader = dict(
+    batch_size=8,
+    num_workers=8,
+    persistent_workers=True,
+    sampler=dict(type='InfiniteSampler', shuffle=True),
+    dataset=dict(
+        type='ADE20KDataset',
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotations', reduce_zero_label=True),
+            dict(
+                type='RandomChoiceResize',
+                scales=[
+                    256, 307, 358, 409, 460, 512, 563, 614, 665, 716, 768, 819,
+                    870, 921, 972, 1024
+                ],
+                resize_type='ResizeShortestEdge',
+                max_size=2048),
+            dict(type='RandomCrop', crop_size=(512, 512), cat_max_ratio=0.75),
+            dict(type='RandomFlip', prob=0.5),
+            dict(type='PhotoMetricDistortion'),
+            dict(type='PackSegInputs')
+        ]))
+val_dataloader = dict(
+    batch_size=1,
+    num_workers=8,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='ADE20KDataset',
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+            dict(type='LoadAnnotations', reduce_zero_label=True),
+            dict(type='PackSegInputs')
+        ]))
+test_dataloader = dict(
+    batch_size=1,
+    num_workers=8,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
+        type='ADE20KDataset',
+        data_root=data_root,
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+            dict(type='LoadAnnotations', reduce_zero_label=True),
+            dict(type='PackSegInputs')
+        ]))
+val_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+test_evaluator = dict(type='IoUMetric', iou_metrics=['mIoU'])
+custom_imports = dict(
+    imports=[
+        'mmdet.models', 'mmseg_custom.models.backbones.swin_as',
+        'mmseg_custom.models.layers.msdeformattn_pixel_decoder',
+        'mmseg_custom.models.decode_heads.mask2former_head_custom',
+        'mmseg_custom.models.segmentors.encoder_decoder_custom'
+    ],
+    allow_failed_imports=False)
+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=(512, 512),
+    test_cfg=dict(size_divisor=32))
+num_classes = 150
+model = dict(
+    type='EncoderDecoderWithSaliencySamplerPixelRelation',
+    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=(512, 512),
+        test_cfg=dict(size_divisor=32)),
+    backbone=dict(
+        type='SwinTransformerSaliencySampler',
+        use_checkpoint=False,
+        align_corners=False,
+        log_dir=None,
+        sampler_num=3,
+        sampler_strides=(1, 1, 1),
+        sampler_paddings=(5, 5, 5),
+        sampler_fwhm=(3, 3, 3),
+        sampler_mode=('avg_lhpf_psp', 'avg_lhpf_psp', 'avg_lhpf_psp'),
+        psp_ratio=16,
+        with_cp=False,
+        embed_dims=96,
+        depths=[2, 2, 6, 2],
+        num_heads=[3, 6, 12, 24],
+        window_size=7,
+        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),
+        frozen_stages=-1,
+        init_cfg=dict(
+            type='Pretrained',
+            checkpoint=
+            'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'
+        )),
+    decode_head=dict(
+        type='Mask2FormerHeadNonUniformSFM',
+        in_channels=[96, 192, 384, 768],
+        strides=[4, 8, 16, 32],
+        feat_channels=256,
+        out_channels=256,
+        num_classes=150,
+        num_queries=100,
+        num_transformer_feat_level=3,
+        align_corners=False,
+        pixel_decoder=dict(
+            type='MSDeformAttnPixelDecoderSFM',
+            num_outs=3,
+            norm_cfg=dict(type='GN', num_groups=32),
+            act_cfg=dict(type='ReLU'),
+            encoder=dict(
+                num_layers=6,
+                layer_cfg=dict(
+                    self_attn_cfg=dict(
+                        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(num_feats=128, normalize=True),
+            init_cfg=None,
+            compress_ratio=16,
+            align_corners=False,
+            use_align=True,
+            use_last_align=True),
+        enforce_decoder_input_project=False,
+        positional_encoding=dict(num_feats=128, normalize=True),
+        transformer_decoder=dict(
+            return_intermediate=True,
+            num_layers=9,
+            layer_cfg=dict(
+                self_attn_cfg=dict(
+                    embed_dims=256,
+                    num_heads=8,
+                    attn_drop=0.0,
+                    proj_drop=0.0,
+                    dropout_layer=None,
+                    batch_first=True),
+                cross_attn_cfg=dict(
+                    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, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
+                1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 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'),
+    log_dir=None,
+    edge_loss_weight=100,
+    pixel_relation=[],
+    sampler_num=3)
+embed_multi = dict(lr_mult=1.0, decay_mult=0.0)
+optimizer = dict(
+    type='AdamW', lr=0.0001, weight_decay=0.05, eps=1e-08, betas=(0.9, 0.999))
+optim_wrapper = dict(
+    type='OptimWrapper',
+    optimizer=dict(
+        type='AdamW',
+        lr=0.0001,
+        weight_decay=0.05,
+        eps=1e-08,
+        betas=(0.9, 0.999)),
+    clip_grad=dict(max_norm=0.01, norm_type=2),
+    paramwise_cfg=dict(
+        custom_keys=dict({
+            'backbone':
+            dict(lr_mult=0.1, decay_mult=1.0),
+            'query_embed':
+            dict(lr_mult=1.0, decay_mult=0.0),
+            'query_feat':
+            dict(lr_mult=1.0, decay_mult=0.0),
+            'level_embed':
+            dict(lr_mult=1.0, decay_mult=0.0),
+            'backbone.patch_embed.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'absolute_pos_embed':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'relative_position_bias_table':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.SS':
+            dict(lr_mult=1.0, decay_mult=1.0),
+            'backbone.stages.0.blocks.0.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.0.blocks.1.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.1.blocks.0.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.1.blocks.1.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.2.blocks.0.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.2.blocks.1.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.2.blocks.2.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.2.blocks.3.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.2.blocks.4.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.2.blocks.5.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.3.blocks.0.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.3.blocks.1.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.0.downsample.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.1.downsample.norm':
+            dict(lr_mult=0.1, decay_mult=0.0),
+            'backbone.stages.2.downsample.norm':
+            dict(lr_mult=0.1, decay_mult=0.0)
+        }),
+        norm_decay_mult=0.0))
+param_scheduler = [
+    dict(
+        type='PolyLR',
+        eta_min=0,
+        power=0.9,
+        begin=0,
+        end=160000,
+        by_epoch=False)
+]
+train_cfg = dict(
+    type='IterBasedTrainLoop', max_iters=160000, val_interval=5000)
+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=5000,
+        max_keep_ckpts=2,
+        save_best='mIoU'),
+    sampler_seed=dict(type='DistSamplerSeedHook'),
+    visualization=dict(type='SegVisualizationHook'))
+auto_scale_lr = dict(enable=False, base_batch_size=16)
+pretrained = 'https://download.openmmlab.com/mmsegmentation/v0.5/pretrain/swin/swin_tiny_patch4_window7_224_20220317-1cdeb081.pth'
+LOG_DIR = None
+SAMPLER_NUM = 3
+ALIGN_CORNERS = False
+depths = [2, 2, 6, 2]
+backbone_norm_multi = dict(lr_mult=0.1, decay_mult=0.0)
+backbone_embed_multi = dict(lr_mult=0.1, decay_mult=0.0)
+custom_keys = dict({
+    'backbone':
+    dict(lr_mult=0.1, decay_mult=1.0),
+    'backbone.patch_embed.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'absolute_pos_embed':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'relative_position_bias_table':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'query_embed':
+    dict(lr_mult=1.0, decay_mult=0.0),
+    'query_feat':
+    dict(lr_mult=1.0, decay_mult=0.0),
+    'level_embed':
+    dict(lr_mult=1.0, decay_mult=0.0),
+    'backbone.SS':
+    dict(lr_mult=1.0, decay_mult=1.0),
+    'backbone.stages.0.blocks.0.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.0.blocks.1.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.1.blocks.0.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.1.blocks.1.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.2.blocks.0.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.2.blocks.1.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.2.blocks.2.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.2.blocks.3.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.2.blocks.4.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.2.blocks.5.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.3.blocks.0.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.3.blocks.1.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.0.downsample.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.1.downsample.norm':
+    dict(lr_mult=0.1, decay_mult=0.0),
+    'backbone.stages.2.downsample.norm':
+    dict(lr_mult=0.1, decay_mult=0.0)
+})
+launcher = 'pytorch'
+eval = 'mIoU'
+work_dir = 'work_dirs/mask2former_swin-t_8xb2-160k_ade20k-512x512_SFMv2'