upload

cityscapes/deeplabv3plus_r101_multistep/best_mIoU_iter_144000.pth

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

cityscapes/deeplabv3plus_r101_multistep/deeplabv3plus_r101-d8_aspp_head_unet_fc_multi_step_ade_pretrained_freeze_embed_160k_cityscapes20_finetune.py

@@ -0,0 +1,191 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoderDiffusion',
+    pretrained=
+    'work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20/latest.pth',
+    backbone=dict(
+        type='ResNetV1cCustomInitWeights',
+        depth=101,
+        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='DepthwiseSeparableASPPHeadUnetFCHeadMultiStep',
+        pretrained=
+        'work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20/latest.pth',
+        dim=128,
+        out_dim=256,
+        unet_channels=528,
+        dim_mults=[1, 1, 1],
+        cat_embedding_dim=16,
+        ignore_index=0,
+        diffusion_timesteps=100,
+        collect_timesteps=[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 99],
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=20,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=None,
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'),
+    freeze_parameters=['backbone', 'decode_head'])
+dataset_type = 'Cityscapes20Dataset'
+data_root = 'data/cityscapes/'
+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='LoadAnnotationsCityscapes20'),
+    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=0),
+    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'])
+        ])
+]
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/train',
+        ann_dir='gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotationsCityscapes20'),
+            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=0),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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'])
+                ])
+        ]))
+log_config = dict(
+    interval=50, 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 = True
+optimizer = dict(
+    type='AdamW', lr=0.00015, betas=[0.9, 0.96], weight_decay=0.045)
+optimizer_config = dict()
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1e-06,
+    step=20000,
+    gamma=0.5,
+    min_lr=1e-06,
+    by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=160000)
+checkpoint_config = dict(by_epoch=False, interval=16000, max_keep_ckpts=1)
+evaluation = dict(
+    interval=16000, metric='mIoU', pre_eval=True, save_best='mIoU')
+checkpoint = 'work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20/latest.pth'
+custom_hooks = [
+    dict(
+        type='ConstantMomentumEMAHook',
+        momentum=0.01,
+        interval=25,
+        eval_interval=16000,
+        auto_resume=True,
+        priority=49)
+]
+work_dir = './work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_multi_step_ade_pretrained_freeze_embed_160k_cityscapes20_finetune'
+gpu_ids = range(0, 8)
+auto_resume = True

cityscapes/deeplabv3plus_r101_multistep/iter_160000.pth

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

cityscapes/deeplabv3plus_r101_multistep/latest.pth

@@ -0,0 +1 @@
+iter_160000.pth

cityscapes/deeplabv3plus_r101_singlestep/20230303_203832.log

@@ -0,0 +1,1095 @@
+2023-03-03 20:38:32,836 - mmseg - INFO - Multi-processing start method is `None`
+2023-03-03 20:38:32,858 - mmseg - INFO - OpenCV num_threads is `128
+2023-03-03 20:38:32,858 - mmseg - INFO - OMP num threads is 1
+2023-03-03 20:38:32,925 - mmseg - INFO - Environment info:
+------------------------------------------------------------
+sys.platform: linux
+Python: 3.7.16 (default, Jan 17 2023, 22:20:44) [GCC 11.2.0]
+CUDA available: True
+GPU 0,1,2,3,4,5,6,7: NVIDIA A100-SXM4-80GB
+CUDA_HOME: /mnt/petrelfs/laizeqiang/miniconda3/envs/torch
+NVCC: Cuda compilation tools, release 11.6, V11.6.124
+GCC: gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-44)
+PyTorch: 1.13.1
+PyTorch compiling details: PyTorch built with:
+  - GCC 9.3
+  - C++ Version: 201402
+  - Intel(R) oneAPI Math Kernel Library Version 2021.4-Product Build 20210904 for Intel(R) 64 architecture applications
+  - Intel(R) MKL-DNN v2.6.0 (Git Hash 52b5f107dd9cf10910aaa19cb47f3abf9b349815)
+  - OpenMP 201511 (a.k.a. OpenMP 4.5)
+  - LAPACK is enabled (usually provided by MKL)
+  - NNPACK is enabled
+  - CPU capability usage: AVX2
+  - CUDA Runtime 11.6
+  - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_61,code=sm_61;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_37,code=compute_37
+  - CuDNN 8.3.2  (built against CUDA 11.5)
+  - Magma 2.6.1
+  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.6, CUDNN_VERSION=8.3.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -fabi-version=11 -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_KINETO -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -DEDGE_PROFILER_USE_KINETO -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wunused-local-typedefs -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_VERSION=1.13.1, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, 
+
+TorchVision: 0.14.1
+OpenCV: 4.7.0
+MMCV: 1.7.1
+MMCV Compiler: GCC 9.3
+MMCV CUDA Compiler: 11.6
+MMSegmentation: 0.30.0+c844fc6
+------------------------------------------------------------
+
+2023-03-03 20:38:32,925 - mmseg - INFO - Distributed training: True
+2023-03-03 20:38:33,574 - mmseg - INFO - Config:
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoderFreeze',
+    pretrained=
+    'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth',
+    backbone=dict(
+        type='ResNetV1cCustomInitWeights',
+        depth=101,
+        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='DepthwiseSeparableASPPHeadUnetFCHeadSingleStep',
+        pretrained=
+        'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth',
+        dim=256,
+        out_dim=256,
+        unet_channels=528,
+        dim_mults=[1, 1, 1],
+        cat_embedding_dim=16,
+        ignore_index=0,
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=20,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=None,
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'),
+    freeze_parameters=['backbone', 'decode_head'])
+dataset_type = 'Cityscapes20Dataset'
+data_root = 'data/cityscapes/'
+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='LoadAnnotationsCityscapes20'),
+    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=0),
+    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'])
+        ])
+]
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/train',
+        ann_dir='gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotationsCityscapes20'),
+            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=0),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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'])
+                ])
+        ]))
+log_config = dict(
+    interval=50, 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 = True
+optimizer = dict(
+    type='AdamW', lr=0.00015, betas=[0.9, 0.96], weight_decay=0.045)
+optimizer_config = dict()
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1e-06,
+    step=10000,
+    gamma=0.5,
+    min_lr=1e-06,
+    by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=80000)
+checkpoint_config = dict(by_epoch=False, interval=8000, max_keep_ckpts=1)
+evaluation = dict(
+    interval=8000, metric='mIoU', pre_eval=True, save_best='mIoU')
+checkpoint = 'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth'
+work_dir = './work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20'
+gpu_ids = range(0, 8)
+auto_resume = True
+
+2023-03-03 20:38:37,967 - mmseg - INFO - Set random seed to 835892801, deterministic: False
+2023-03-03 20:38:39,336 - mmseg - INFO - Parameters in backbone freezed!
+2023-03-03 20:38:39,337 - mmseg - INFO - Trainable parameters in DepthwiseSeparableASPPHeadUnetFCHeadSingleStep: ['unet.init_conv.weight', 'unet.init_conv.bias', 'unet.time_mlp.1.weight', 'unet.time_mlp.1.bias', 'unet.time_mlp.3.weight', 'unet.time_mlp.3.bias', 'unet.downs.0.0.mlp.1.weight', 'unet.downs.0.0.mlp.1.bias', 'unet.downs.0.0.block1.proj.weight', 'unet.downs.0.0.block1.proj.bias', 'unet.downs.0.0.block1.norm.weight', 'unet.downs.0.0.block1.norm.bias', 'unet.downs.0.0.block2.proj.weight', 'unet.downs.0.0.block2.proj.bias', 'unet.downs.0.0.block2.norm.weight', 'unet.downs.0.0.block2.norm.bias', 'unet.downs.0.1.mlp.1.weight', 'unet.downs.0.1.mlp.1.bias', 'unet.downs.0.1.block1.proj.weight', 'unet.downs.0.1.block1.proj.bias', 'unet.downs.0.1.block1.norm.weight', 'unet.downs.0.1.block1.norm.bias', 'unet.downs.0.1.block2.proj.weight', 'unet.downs.0.1.block2.proj.bias', 'unet.downs.0.1.block2.norm.weight', 'unet.downs.0.1.block2.norm.bias', 'unet.downs.0.2.fn.fn.to_qkv.weight', 'unet.downs.0.2.fn.fn.to_out.0.weight', 'unet.downs.0.2.fn.fn.to_out.0.bias', 'unet.downs.0.2.fn.fn.to_out.1.g', 'unet.downs.0.2.fn.norm.g', 'unet.downs.0.3.weight', 'unet.downs.0.3.bias', 'unet.downs.1.0.mlp.1.weight', 'unet.downs.1.0.mlp.1.bias', 'unet.downs.1.0.block1.proj.weight', 'unet.downs.1.0.block1.proj.bias', 'unet.downs.1.0.block1.norm.weight', 'unet.downs.1.0.block1.norm.bias', 'unet.downs.1.0.block2.proj.weight', 'unet.downs.1.0.block2.proj.bias', 'unet.downs.1.0.block2.norm.weight', 'unet.downs.1.0.block2.norm.bias', 'unet.downs.1.1.mlp.1.weight', 'unet.downs.1.1.mlp.1.bias', 'unet.downs.1.1.block1.proj.weight', 'unet.downs.1.1.block1.proj.bias', 'unet.downs.1.1.block1.norm.weight', 'unet.downs.1.1.block1.norm.bias', 'unet.downs.1.1.block2.proj.weight', 'unet.downs.1.1.block2.proj.bias', 'unet.downs.1.1.block2.norm.weight', 'unet.downs.1.1.block2.norm.bias', 'unet.downs.1.2.fn.fn.to_qkv.weight', 'unet.downs.1.2.fn.fn.to_out.0.weight', 'unet.downs.1.2.fn.fn.to_out.0.bias', 'unet.downs.1.2.fn.fn.to_out.1.g', 'unet.downs.1.2.fn.norm.g', 'unet.downs.1.3.weight', 'unet.downs.1.3.bias', 'unet.downs.2.0.mlp.1.weight', 'unet.downs.2.0.mlp.1.bias', 'unet.downs.2.0.block1.proj.weight', 'unet.downs.2.0.block1.proj.bias', 'unet.downs.2.0.block1.norm.weight', 'unet.downs.2.0.block1.norm.bias', 'unet.downs.2.0.block2.proj.weight', 'unet.downs.2.0.block2.proj.bias', 'unet.downs.2.0.block2.norm.weight', 'unet.downs.2.0.block2.norm.bias', 'unet.downs.2.1.mlp.1.weight', 'unet.downs.2.1.mlp.1.bias', 'unet.downs.2.1.block1.proj.weight', 'unet.downs.2.1.block1.proj.bias', 'unet.downs.2.1.block1.norm.weight', 'unet.downs.2.1.block1.norm.bias', 'unet.downs.2.1.block2.proj.weight', 'unet.downs.2.1.block2.proj.bias', 'unet.downs.2.1.block2.norm.weight', 'unet.downs.2.1.block2.norm.bias', 'unet.downs.2.2.fn.fn.to_qkv.weight', 'unet.downs.2.2.fn.fn.to_out.0.weight', 'unet.downs.2.2.fn.fn.to_out.0.bias', 'unet.downs.2.2.fn.fn.to_out.1.g', 'unet.downs.2.2.fn.norm.g', 'unet.downs.2.3.weight', 'unet.downs.2.3.bias', 'unet.ups.0.0.mlp.1.weight', 'unet.ups.0.0.mlp.1.bias', 'unet.ups.0.0.block1.proj.weight', 'unet.ups.0.0.block1.proj.bias', 'unet.ups.0.0.block1.norm.weight', 'unet.ups.0.0.block1.norm.bias', 'unet.ups.0.0.block2.proj.weight', 'unet.ups.0.0.block2.proj.bias', 'unet.ups.0.0.block2.norm.weight', 'unet.ups.0.0.block2.norm.bias', 'unet.ups.0.0.res_conv.weight', 'unet.ups.0.0.res_conv.bias', 'unet.ups.0.1.mlp.1.weight', 'unet.ups.0.1.mlp.1.bias', 'unet.ups.0.1.block1.proj.weight', 'unet.ups.0.1.block1.proj.bias', 'unet.ups.0.1.block1.norm.weight', 'unet.ups.0.1.block1.norm.bias', 'unet.ups.0.1.block2.proj.weight', 'unet.ups.0.1.block2.proj.bias', 'unet.ups.0.1.block2.norm.weight', 'unet.ups.0.1.block2.norm.bias', 'unet.ups.0.1.res_conv.weight', 'unet.ups.0.1.res_conv.bias', 'unet.ups.0.2.fn.fn.to_qkv.weight', 'unet.ups.0.2.fn.fn.to_out.0.weight', 'unet.ups.0.2.fn.fn.to_out.0.bias', 'unet.ups.0.2.fn.fn.to_out.1.g', 'unet.ups.0.2.fn.norm.g', 'unet.ups.0.3.1.weight', 'unet.ups.0.3.1.bias', 'unet.ups.1.0.mlp.1.weight', 'unet.ups.1.0.mlp.1.bias', 'unet.ups.1.0.block1.proj.weight', 'unet.ups.1.0.block1.proj.bias', 'unet.ups.1.0.block1.norm.weight', 'unet.ups.1.0.block1.norm.bias', 'unet.ups.1.0.block2.proj.weight', 'unet.ups.1.0.block2.proj.bias', 'unet.ups.1.0.block2.norm.weight', 'unet.ups.1.0.block2.norm.bias', 'unet.ups.1.0.res_conv.weight', 'unet.ups.1.0.res_conv.bias', 'unet.ups.1.1.mlp.1.weight', 'unet.ups.1.1.mlp.1.bias', 'unet.ups.1.1.block1.proj.weight', 'unet.ups.1.1.block1.proj.bias', 'unet.ups.1.1.block1.norm.weight', 'unet.ups.1.1.block1.norm.bias', 'unet.ups.1.1.block2.proj.weight', 'unet.ups.1.1.block2.proj.bias', 'unet.ups.1.1.block2.norm.weight', 'unet.ups.1.1.block2.norm.bias', 'unet.ups.1.1.res_conv.weight', 'unet.ups.1.1.res_conv.bias', 'unet.ups.1.2.fn.fn.to_qkv.weight', 'unet.ups.1.2.fn.fn.to_out.0.weight', 'unet.ups.1.2.fn.fn.to_out.0.bias', 'unet.ups.1.2.fn.fn.to_out.1.g', 'unet.ups.1.2.fn.norm.g', 'unet.ups.1.3.1.weight', 'unet.ups.1.3.1.bias', 'unet.ups.2.0.mlp.1.weight', 'unet.ups.2.0.mlp.1.bias', 'unet.ups.2.0.block1.proj.weight', 'unet.ups.2.0.block1.proj.bias', 'unet.ups.2.0.block1.norm.weight', 'unet.ups.2.0.block1.norm.bias', 'unet.ups.2.0.block2.proj.weight', 'unet.ups.2.0.block2.proj.bias', 'unet.ups.2.0.block2.norm.weight', 'unet.ups.2.0.block2.norm.bias', 'unet.ups.2.0.res_conv.weight', 'unet.ups.2.0.res_conv.bias', 'unet.ups.2.1.mlp.1.weight', 'unet.ups.2.1.mlp.1.bias', 'unet.ups.2.1.block1.proj.weight', 'unet.ups.2.1.block1.proj.bias', 'unet.ups.2.1.block1.norm.weight', 'unet.ups.2.1.block1.norm.bias', 'unet.ups.2.1.block2.proj.weight', 'unet.ups.2.1.block2.proj.bias', 'unet.ups.2.1.block2.norm.weight', 'unet.ups.2.1.block2.norm.bias', 'unet.ups.2.1.res_conv.weight', 'unet.ups.2.1.res_conv.bias', 'unet.ups.2.2.fn.fn.to_qkv.weight', 'unet.ups.2.2.fn.fn.to_out.0.weight', 'unet.ups.2.2.fn.fn.to_out.0.bias', 'unet.ups.2.2.fn.fn.to_out.1.g', 'unet.ups.2.2.fn.norm.g', 'unet.ups.2.3.weight', 'unet.ups.2.3.bias', 'unet.mid_block1.mlp.1.weight', 'unet.mid_block1.mlp.1.bias', 'unet.mid_block1.block1.proj.weight', 'unet.mid_block1.block1.proj.bias', 'unet.mid_block1.block1.norm.weight', 'unet.mid_block1.block1.norm.bias', 'unet.mid_block1.block2.proj.weight', 'unet.mid_block1.block2.proj.bias', 'unet.mid_block1.block2.norm.weight', 'unet.mid_block1.block2.norm.bias', 'unet.mid_attn.fn.fn.to_qkv.weight', 'unet.mid_attn.fn.fn.to_out.weight', 'unet.mid_attn.fn.fn.to_out.bias', 'unet.mid_attn.fn.norm.g', 'unet.mid_block2.mlp.1.weight', 'unet.mid_block2.mlp.1.bias', 'unet.mid_block2.block1.proj.weight', 'unet.mid_block2.block1.proj.bias', 'unet.mid_block2.block1.norm.weight', 'unet.mid_block2.block1.norm.bias', 'unet.mid_block2.block2.proj.weight', 'unet.mid_block2.block2.proj.bias', 'unet.mid_block2.block2.norm.weight', 'unet.mid_block2.block2.norm.bias', 'unet.final_res_block.mlp.1.weight', 'unet.final_res_block.mlp.1.bias', 'unet.final_res_block.block1.proj.weight', 'unet.final_res_block.block1.proj.bias', 'unet.final_res_block.block1.norm.weight', 'unet.final_res_block.block1.norm.bias', 'unet.final_res_block.block2.proj.weight', 'unet.final_res_block.block2.proj.bias', 'unet.final_res_block.block2.norm.weight', 'unet.final_res_block.block2.norm.bias', 'unet.final_res_block.res_conv.weight', 'unet.final_res_block.res_conv.bias', 'unet.final_conv.weight', 'unet.final_conv.bias', 'conv_seg_new.weight', 'conv_seg_new.bias']
+2023-03-03 20:38:39,337 - mmseg - INFO - Parameters in decode_head freezed!
+2023-03-03 20:38:39,389 - mmseg - INFO - load checkpoint from local path: pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth
+2023-03-03 20:38:39,920 - mmseg - WARNING - The model and loaded state dict do not match exactly
+
+unexpected key in source state_dict: decode_head.conv_seg.weight, decode_head.conv_seg.bias, decode_head.image_pool.1.conv.weight, decode_head.image_pool.1.bn.weight, decode_head.image_pool.1.bn.bias, decode_head.image_pool.1.bn.running_mean, decode_head.image_pool.1.bn.running_var, decode_head.image_pool.1.bn.num_batches_tracked, decode_head.aspp_modules.0.conv.weight, decode_head.aspp_modules.0.bn.weight, decode_head.aspp_modules.0.bn.bias, decode_head.aspp_modules.0.bn.running_mean, decode_head.aspp_modules.0.bn.running_var, decode_head.aspp_modules.0.bn.num_batches_tracked, decode_head.aspp_modules.1.depthwise_conv.conv.weight, decode_head.aspp_modules.1.depthwise_conv.bn.weight, decode_head.aspp_modules.1.depthwise_conv.bn.bias, decode_head.aspp_modules.1.depthwise_conv.bn.running_mean, decode_head.aspp_modules.1.depthwise_conv.bn.running_var, decode_head.aspp_modules.1.depthwise_conv.bn.num_batches_tracked, decode_head.aspp_modules.1.pointwise_conv.conv.weight, decode_head.aspp_modules.1.pointwise_conv.bn.weight, decode_head.aspp_modules.1.pointwise_conv.bn.bias, decode_head.aspp_modules.1.pointwise_conv.bn.running_mean, decode_head.aspp_modules.1.pointwise_conv.bn.running_var, decode_head.aspp_modules.1.pointwise_conv.bn.num_batches_tracked, decode_head.aspp_modules.2.depthwise_conv.conv.weight, decode_head.aspp_modules.2.depthwise_conv.bn.weight, decode_head.aspp_modules.2.depthwise_conv.bn.bias, decode_head.aspp_modules.2.depthwise_conv.bn.running_mean, decode_head.aspp_modules.2.depthwise_conv.bn.running_var, decode_head.aspp_modules.2.depthwise_conv.bn.num_batches_tracked, decode_head.aspp_modules.2.pointwise_conv.conv.weight, decode_head.aspp_modules.2.pointwise_conv.bn.weight, decode_head.aspp_modules.2.pointwise_conv.bn.bias, decode_head.aspp_modules.2.pointwise_conv.bn.running_mean, decode_head.aspp_modules.2.pointwise_conv.bn.running_var, decode_head.aspp_modules.2.pointwise_conv.bn.num_batches_tracked, decode_head.aspp_modules.3.depthwise_conv.conv.weight, decode_head.aspp_modules.3.depthwise_conv.bn.weight, decode_head.aspp_modules.3.depthwise_conv.bn.bias, decode_head.aspp_modules.3.depthwise_conv.bn.running_mean, decode_head.aspp_modules.3.depthwise_conv.bn.running_var, decode_head.aspp_modules.3.depthwise_conv.bn.num_batches_tracked, decode_head.aspp_modules.3.pointwise_conv.conv.weight, decode_head.aspp_modules.3.pointwise_conv.bn.weight, decode_head.aspp_modules.3.pointwise_conv.bn.bias, decode_head.aspp_modules.3.pointwise_conv.bn.running_mean, decode_head.aspp_modules.3.pointwise_conv.bn.running_var, decode_head.aspp_modules.3.pointwise_conv.bn.num_batches_tracked, decode_head.bottleneck.conv.weight, decode_head.bottleneck.bn.weight, decode_head.bottleneck.bn.bias, decode_head.bottleneck.bn.running_mean, decode_head.bottleneck.bn.running_var, decode_head.bottleneck.bn.num_batches_tracked, decode_head.c1_bottleneck.conv.weight, decode_head.c1_bottleneck.bn.weight, decode_head.c1_bottleneck.bn.bias, decode_head.c1_bottleneck.bn.running_mean, decode_head.c1_bottleneck.bn.running_var, decode_head.c1_bottleneck.bn.num_batches_tracked, decode_head.sep_bottleneck.0.depthwise_conv.conv.weight, decode_head.sep_bottleneck.0.depthwise_conv.bn.weight, decode_head.sep_bottleneck.0.depthwise_conv.bn.bias, decode_head.sep_bottleneck.0.depthwise_conv.bn.running_mean, decode_head.sep_bottleneck.0.depthwise_conv.bn.running_var, decode_head.sep_bottleneck.0.depthwise_conv.bn.num_batches_tracked, decode_head.sep_bottleneck.0.pointwise_conv.conv.weight, decode_head.sep_bottleneck.0.pointwise_conv.bn.weight, decode_head.sep_bottleneck.0.pointwise_conv.bn.bias, decode_head.sep_bottleneck.0.pointwise_conv.bn.running_mean, decode_head.sep_bottleneck.0.pointwise_conv.bn.running_var, decode_head.sep_bottleneck.0.pointwise_conv.bn.num_batches_tracked, decode_head.sep_bottleneck.1.depthwise_conv.conv.weight, decode_head.sep_bottleneck.1.depthwise_conv.bn.weight, decode_head.sep_bottleneck.1.depthwise_conv.bn.bias, decode_head.sep_bottleneck.1.depthwise_conv.bn.running_mean, decode_head.sep_bottleneck.1.depthwise_conv.bn.running_var, decode_head.sep_bottleneck.1.depthwise_conv.bn.num_batches_tracked, decode_head.sep_bottleneck.1.pointwise_conv.conv.weight, decode_head.sep_bottleneck.1.pointwise_conv.bn.weight, decode_head.sep_bottleneck.1.pointwise_conv.bn.bias, decode_head.sep_bottleneck.1.pointwise_conv.bn.running_mean, decode_head.sep_bottleneck.1.pointwise_conv.bn.running_var, decode_head.sep_bottleneck.1.pointwise_conv.bn.num_batches_tracked, auxiliary_head.conv_seg.weight, auxiliary_head.conv_seg.bias, auxiliary_head.convs.0.conv.weight, auxiliary_head.convs.0.bn.weight, auxiliary_head.convs.0.bn.bias, auxiliary_head.convs.0.bn.running_mean, auxiliary_head.convs.0.bn.running_var, auxiliary_head.convs.0.bn.num_batches_tracked
+
+2023-03-03 20:38:39,948 - mmseg - INFO - load checkpoint from local path: pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth
+2023-03-03 20:38:40,463 - mmseg - WARNING - The model and loaded state dict do not match exactly
+
+unexpected key in source state_dict: backbone.stem.0.weight, backbone.stem.1.weight, backbone.stem.1.bias, backbone.stem.1.running_mean, backbone.stem.1.running_var, backbone.stem.1.num_batches_tracked, backbone.stem.3.weight, backbone.stem.4.weight, backbone.stem.4.bias, backbone.stem.4.running_mean, backbone.stem.4.running_var, backbone.stem.4.num_batches_tracked, backbone.stem.6.weight, backbone.stem.7.weight, backbone.stem.7.bias, backbone.stem.7.running_mean, backbone.stem.7.running_var, backbone.stem.7.num_batches_tracked, backbone.layer1.0.conv1.weight, backbone.layer1.0.bn1.weight, backbone.layer1.0.bn1.bias, backbone.layer1.0.bn1.running_mean, backbone.layer1.0.bn1.running_var, backbone.layer1.0.bn1.num_batches_tracked, backbone.layer1.0.conv2.weight, backbone.layer1.0.bn2.weight, backbone.layer1.0.bn2.bias, backbone.layer1.0.bn2.running_mean, backbone.layer1.0.bn2.running_var, backbone.layer1.0.bn2.num_batches_tracked, backbone.layer1.0.conv3.weight, backbone.layer1.0.bn3.weight, backbone.layer1.0.bn3.bias, backbone.layer1.0.bn3.running_mean, backbone.layer1.0.bn3.running_var, backbone.layer1.0.bn3.num_batches_tracked, backbone.layer1.0.downsample.0.weight, backbone.layer1.0.downsample.1.weight, backbone.layer1.0.downsample.1.bias, backbone.layer1.0.downsample.1.running_mean, backbone.layer1.0.downsample.1.running_var, backbone.layer1.0.downsample.1.num_batches_tracked, backbone.layer1.1.conv1.weight, backbone.layer1.1.bn1.weight, backbone.layer1.1.bn1.bias, backbone.layer1.1.bn1.running_mean, backbone.layer1.1.bn1.running_var, backbone.layer1.1.bn1.num_batches_tracked, backbone.layer1.1.conv2.weight, backbone.layer1.1.bn2.weight, backbone.layer1.1.bn2.bias, backbone.layer1.1.bn2.running_mean, backbone.layer1.1.bn2.running_var, backbone.layer1.1.bn2.num_batches_tracked, backbone.layer1.1.conv3.weight, backbone.layer1.1.bn3.weight, backbone.layer1.1.bn3.bias, backbone.layer1.1.bn3.running_mean, backbone.layer1.1.bn3.running_var, backbone.layer1.1.bn3.num_batches_tracked, backbone.layer1.2.conv1.weight, backbone.layer1.2.bn1.weight, backbone.layer1.2.bn1.bias, backbone.layer1.2.bn1.running_mean, backbone.layer1.2.bn1.running_var, backbone.layer1.2.bn1.num_batches_tracked, backbone.layer1.2.conv2.weight, backbone.layer1.2.bn2.weight, backbone.layer1.2.bn2.bias, backbone.layer1.2.bn2.running_mean, backbone.layer1.2.bn2.running_var, backbone.layer1.2.bn2.num_batches_tracked, backbone.layer1.2.conv3.weight, backbone.layer1.2.bn3.weight, backbone.layer1.2.bn3.bias, backbone.layer1.2.bn3.running_mean, backbone.layer1.2.bn3.running_var, backbone.layer1.2.bn3.num_batches_tracked, backbone.layer2.0.conv1.weight, backbone.layer2.0.bn1.weight, backbone.layer2.0.bn1.bias, backbone.layer2.0.bn1.running_mean, backbone.layer2.0.bn1.running_var, backbone.layer2.0.bn1.num_batches_tracked, backbone.layer2.0.conv2.weight, backbone.layer2.0.bn2.weight, backbone.layer2.0.bn2.bias, backbone.layer2.0.bn2.running_mean, backbone.layer2.0.bn2.running_var, backbone.layer2.0.bn2.num_batches_tracked, backbone.layer2.0.conv3.weight, backbone.layer2.0.bn3.weight, backbone.layer2.0.bn3.bias, backbone.layer2.0.bn3.running_mean, backbone.layer2.0.bn3.running_var, backbone.layer2.0.bn3.num_batches_tracked, backbone.layer2.0.downsample.0.weight, backbone.layer2.0.downsample.1.weight, backbone.layer2.0.downsample.1.bias, backbone.layer2.0.downsample.1.running_mean, backbone.layer2.0.downsample.1.running_var, backbone.layer2.0.downsample.1.num_batches_tracked, backbone.layer2.1.conv1.weight, backbone.layer2.1.bn1.weight, backbone.layer2.1.bn1.bias, backbone.layer2.1.bn1.running_mean, backbone.layer2.1.bn1.running_var, backbone.layer2.1.bn1.num_batches_tracked, backbone.layer2.1.conv2.weight, backbone.layer2.1.bn2.weight, backbone.layer2.1.bn2.bias, backbone.layer2.1.bn2.running_mean, backbone.layer2.1.bn2.running_var, backbone.layer2.1.bn2.num_batches_tracked, backbone.layer2.1.conv3.weight, backbone.layer2.1.bn3.weight, backbone.layer2.1.bn3.bias, backbone.layer2.1.bn3.running_mean, backbone.layer2.1.bn3.running_var, backbone.layer2.1.bn3.num_batches_tracked, backbone.layer2.2.conv1.weight, backbone.layer2.2.bn1.weight, backbone.layer2.2.bn1.bias, backbone.layer2.2.bn1.running_mean, backbone.layer2.2.bn1.running_var, backbone.layer2.2.bn1.num_batches_tracked, backbone.layer2.2.conv2.weight, backbone.layer2.2.bn2.weight, backbone.layer2.2.bn2.bias, backbone.layer2.2.bn2.running_mean, backbone.layer2.2.bn2.running_var, backbone.layer2.2.bn2.num_batches_tracked, backbone.layer2.2.conv3.weight, backbone.layer2.2.bn3.weight, backbone.layer2.2.bn3.bias, backbone.layer2.2.bn3.running_mean, backbone.layer2.2.bn3.running_var, backbone.layer2.2.bn3.num_batches_tracked, backbone.layer2.3.conv1.weight, backbone.layer2.3.bn1.weight, backbone.layer2.3.bn1.bias, backbone.layer2.3.bn1.running_mean, backbone.layer2.3.bn1.running_var, backbone.layer2.3.bn1.num_batches_tracked, backbone.layer2.3.conv2.weight, backbone.layer2.3.bn2.weight, backbone.layer2.3.bn2.bias, backbone.layer2.3.bn2.running_mean, backbone.layer2.3.bn2.running_var, backbone.layer2.3.bn2.num_batches_tracked, backbone.layer2.3.conv3.weight, backbone.layer2.3.bn3.weight, backbone.layer2.3.bn3.bias, backbone.layer2.3.bn3.running_mean, backbone.layer2.3.bn3.running_var, backbone.layer2.3.bn3.num_batches_tracked, backbone.layer3.0.conv1.weight, backbone.layer3.0.bn1.weight, backbone.layer3.0.bn1.bias, backbone.layer3.0.bn1.running_mean, backbone.layer3.0.bn1.running_var, backbone.layer3.0.bn1.num_batches_tracked, backbone.layer3.0.conv2.weight, backbone.layer3.0.bn2.weight, backbone.layer3.0.bn2.bias, backbone.layer3.0.bn2.running_mean, backbone.layer3.0.bn2.running_var, backbone.layer3.0.bn2.num_batches_tracked, backbone.layer3.0.conv3.weight, backbone.layer3.0.bn3.weight, backbone.layer3.0.bn3.bias, backbone.layer3.0.bn3.running_mean, backbone.layer3.0.bn3.running_var, backbone.layer3.0.bn3.num_batches_tracked, backbone.layer3.0.downsample.0.weight, backbone.layer3.0.downsample.1.weight, backbone.layer3.0.downsample.1.bias, backbone.layer3.0.downsample.1.running_mean, backbone.layer3.0.downsample.1.running_var, backbone.layer3.0.downsample.1.num_batches_tracked, backbone.layer3.1.conv1.weight, backbone.layer3.1.bn1.weight, backbone.layer3.1.bn1.bias, backbone.layer3.1.bn1.running_mean, backbone.layer3.1.bn1.running_var, backbone.layer3.1.bn1.num_batches_tracked, backbone.layer3.1.conv2.weight, backbone.layer3.1.bn2.weight, backbone.layer3.1.bn2.bias, backbone.layer3.1.bn2.running_mean, backbone.layer3.1.bn2.running_var, backbone.layer3.1.bn2.num_batches_tracked, backbone.layer3.1.conv3.weight, backbone.layer3.1.bn3.weight, backbone.layer3.1.bn3.bias, backbone.layer3.1.bn3.running_mean, backbone.layer3.1.bn3.running_var, backbone.layer3.1.bn3.num_batches_tracked, backbone.layer3.2.conv1.weight, backbone.layer3.2.bn1.weight, backbone.layer3.2.bn1.bias, backbone.layer3.2.bn1.running_mean, backbone.layer3.2.bn1.running_var, backbone.layer3.2.bn1.num_batches_tracked, backbone.layer3.2.conv2.weight, backbone.layer3.2.bn2.weight, backbone.layer3.2.bn2.bias, backbone.layer3.2.bn2.running_mean, backbone.layer3.2.bn2.running_var, backbone.layer3.2.bn2.num_batches_tracked, backbone.layer3.2.conv3.weight, backbone.layer3.2.bn3.weight, backbone.layer3.2.bn3.bias, backbone.layer3.2.bn3.running_mean, backbone.layer3.2.bn3.running_var, backbone.layer3.2.bn3.num_batches_tracked, backbone.layer3.3.conv1.weight, backbone.layer3.3.bn1.weight, backbone.layer3.3.bn1.bias, backbone.layer3.3.bn1.running_mean, backbone.layer3.3.bn1.running_var, backbone.layer3.3.bn1.num_batches_tracked, backbone.layer3.3.conv2.weight, backbone.layer3.3.bn2.weight, backbone.layer3.3.bn2.bias, backbone.layer3.3.bn2.running_mean, backbone.layer3.3.bn2.running_var, backbone.layer3.3.bn2.num_batches_tracked, backbone.layer3.3.conv3.weight, backbone.layer3.3.bn3.weight, backbone.layer3.3.bn3.bias, backbone.layer3.3.bn3.running_mean, backbone.layer3.3.bn3.running_var, backbone.layer3.3.bn3.num_batches_tracked, backbone.layer3.4.conv1.weight, backbone.layer3.4.bn1.weight, backbone.layer3.4.bn1.bias, backbone.layer3.4.bn1.running_mean, backbone.layer3.4.bn1.running_var, backbone.layer3.4.bn1.num_batches_tracked, backbone.layer3.4.conv2.weight, backbone.layer3.4.bn2.weight, backbone.layer3.4.bn2.bias, backbone.layer3.4.bn2.running_mean, backbone.layer3.4.bn2.running_var, backbone.layer3.4.bn2.num_batches_tracked, backbone.layer3.4.conv3.weight, backbone.layer3.4.bn3.weight, backbone.layer3.4.bn3.bias, backbone.layer3.4.bn3.running_mean, backbone.layer3.4.bn3.running_var, backbone.layer3.4.bn3.num_batches_tracked, backbone.layer3.5.conv1.weight, backbone.layer3.5.bn1.weight, backbone.layer3.5.bn1.bias, backbone.layer3.5.bn1.running_mean, backbone.layer3.5.bn1.running_var, backbone.layer3.5.bn1.num_batches_tracked, backbone.layer3.5.conv2.weight, backbone.layer3.5.bn2.weight, backbone.layer3.5.bn2.bias, backbone.layer3.5.bn2.running_mean, backbone.layer3.5.bn2.running_var, backbone.layer3.5.bn2.num_batches_tracked, backbone.layer3.5.conv3.weight, backbone.layer3.5.bn3.weight, backbone.layer3.5.bn3.bias, backbone.layer3.5.bn3.running_mean, backbone.layer3.5.bn3.running_var, backbone.layer3.5.bn3.num_batches_tracked, backbone.layer3.6.conv1.weight, backbone.layer3.6.bn1.weight, backbone.layer3.6.bn1.bias, backbone.layer3.6.bn1.running_mean, backbone.layer3.6.bn1.running_var, backbone.layer3.6.bn1.num_batches_tracked, backbone.layer3.6.conv2.weight, backbone.layer3.6.bn2.weight, backbone.layer3.6.bn2.bias, backbone.layer3.6.bn2.running_mean, backbone.layer3.6.bn2.running_var, backbone.layer3.6.bn2.num_batches_tracked, backbone.layer3.6.conv3.weight, backbone.layer3.6.bn3.weight, backbone.layer3.6.bn3.bias, backbone.layer3.6.bn3.running_mean, backbone.layer3.6.bn3.running_var, backbone.layer3.6.bn3.num_batches_tracked, backbone.layer3.7.conv1.weight, backbone.layer3.7.bn1.weight, backbone.layer3.7.bn1.bias, backbone.layer3.7.bn1.running_mean, backbone.layer3.7.bn1.running_var, backbone.layer3.7.bn1.num_batches_tracked, backbone.layer3.7.conv2.weight, backbone.layer3.7.bn2.weight, backbone.layer3.7.bn2.bias, backbone.layer3.7.bn2.running_mean, backbone.layer3.7.bn2.running_var, backbone.layer3.7.bn2.num_batches_tracked, backbone.layer3.7.conv3.weight, backbone.layer3.7.bn3.weight, backbone.layer3.7.bn3.bias, backbone.layer3.7.bn3.running_mean, backbone.layer3.7.bn3.running_var, backbone.layer3.7.bn3.num_batches_tracked, backbone.layer3.8.conv1.weight, backbone.layer3.8.bn1.weight, backbone.layer3.8.bn1.bias, backbone.layer3.8.bn1.running_mean, backbone.layer3.8.bn1.running_var, backbone.layer3.8.bn1.num_batches_tracked, backbone.layer3.8.conv2.weight, backbone.layer3.8.bn2.weight, backbone.layer3.8.bn2.bias, backbone.layer3.8.bn2.running_mean, backbone.layer3.8.bn2.running_var, backbone.layer3.8.bn2.num_batches_tracked, backbone.layer3.8.conv3.weight, backbone.layer3.8.bn3.weight, backbone.layer3.8.bn3.bias, backbone.layer3.8.bn3.running_mean, backbone.layer3.8.bn3.running_var, backbone.layer3.8.bn3.num_batches_tracked, backbone.layer3.9.conv1.weight, backbone.layer3.9.bn1.weight, backbone.layer3.9.bn1.bias, backbone.layer3.9.bn1.running_mean, backbone.layer3.9.bn1.running_var, backbone.layer3.9.bn1.num_batches_tracked, backbone.layer3.9.conv2.weight, backbone.layer3.9.bn2.weight, backbone.layer3.9.bn2.bias, backbone.layer3.9.bn2.running_mean, backbone.layer3.9.bn2.running_var, backbone.layer3.9.bn2.num_batches_tracked, backbone.layer3.9.conv3.weight, backbone.layer3.9.bn3.weight, backbone.layer3.9.bn3.bias, backbone.layer3.9.bn3.running_mean, backbone.layer3.9.bn3.running_var, backbone.layer3.9.bn3.num_batches_tracked, backbone.layer3.10.conv1.weight, backbone.layer3.10.bn1.weight, backbone.layer3.10.bn1.bias, backbone.layer3.10.bn1.running_mean, backbone.layer3.10.bn1.running_var, backbone.layer3.10.bn1.num_batches_tracked, backbone.layer3.10.conv2.weight, backbone.layer3.10.bn2.weight, backbone.layer3.10.bn2.bias, backbone.layer3.10.bn2.running_mean, backbone.layer3.10.bn2.running_var, backbone.layer3.10.bn2.num_batches_tracked, backbone.layer3.10.conv3.weight, backbone.layer3.10.bn3.weight, backbone.layer3.10.bn3.bias, backbone.layer3.10.bn3.running_mean, backbone.layer3.10.bn3.running_var, backbone.layer3.10.bn3.num_batches_tracked, backbone.layer3.11.conv1.weight, backbone.layer3.11.bn1.weight, backbone.layer3.11.bn1.bias, backbone.layer3.11.bn1.running_mean, backbone.layer3.11.bn1.running_var, backbone.layer3.11.bn1.num_batches_tracked, backbone.layer3.11.conv2.weight, backbone.layer3.11.bn2.weight, backbone.layer3.11.bn2.bias, backbone.layer3.11.bn2.running_mean, backbone.layer3.11.bn2.running_var, backbone.layer3.11.bn2.num_batches_tracked, backbone.layer3.11.conv3.weight, backbone.layer3.11.bn3.weight, backbone.layer3.11.bn3.bias, backbone.layer3.11.bn3.running_mean, backbone.layer3.11.bn3.running_var, backbone.layer3.11.bn3.num_batches_tracked, backbone.layer3.12.conv1.weight, backbone.layer3.12.bn1.weight, backbone.layer3.12.bn1.bias, backbone.layer3.12.bn1.running_mean, backbone.layer3.12.bn1.running_var, backbone.layer3.12.bn1.num_batches_tracked, backbone.layer3.12.conv2.weight, backbone.layer3.12.bn2.weight, backbone.layer3.12.bn2.bias, backbone.layer3.12.bn2.running_mean, backbone.layer3.12.bn2.running_var, backbone.layer3.12.bn2.num_batches_tracked, backbone.layer3.12.conv3.weight, backbone.layer3.12.bn3.weight, backbone.layer3.12.bn3.bias, backbone.layer3.12.bn3.running_mean, backbone.layer3.12.bn3.running_var, backbone.layer3.12.bn3.num_batches_tracked, backbone.layer3.13.conv1.weight, backbone.layer3.13.bn1.weight, backbone.layer3.13.bn1.bias, backbone.layer3.13.bn1.running_mean, backbone.layer3.13.bn1.running_var, backbone.layer3.13.bn1.num_batches_tracked, backbone.layer3.13.conv2.weight, backbone.layer3.13.bn2.weight, backbone.layer3.13.bn2.bias, backbone.layer3.13.bn2.running_mean, backbone.layer3.13.bn2.running_var, backbone.layer3.13.bn2.num_batches_tracked, backbone.layer3.13.conv3.weight, backbone.layer3.13.bn3.weight, backbone.layer3.13.bn3.bias, backbone.layer3.13.bn3.running_mean, backbone.layer3.13.bn3.running_var, backbone.layer3.13.bn3.num_batches_tracked, backbone.layer3.14.conv1.weight, backbone.layer3.14.bn1.weight, backbone.layer3.14.bn1.bias, backbone.layer3.14.bn1.running_mean, backbone.layer3.14.bn1.running_var, backbone.layer3.14.bn1.num_batches_tracked, backbone.layer3.14.conv2.weight, backbone.layer3.14.bn2.weight, backbone.layer3.14.bn2.bias, backbone.layer3.14.bn2.running_mean, backbone.layer3.14.bn2.running_var, backbone.layer3.14.bn2.num_batches_tracked, backbone.layer3.14.conv3.weight, backbone.layer3.14.bn3.weight, backbone.layer3.14.bn3.bias, backbone.layer3.14.bn3.running_mean, backbone.layer3.14.bn3.running_var, backbone.layer3.14.bn3.num_batches_tracked, backbone.layer3.15.conv1.weight, backbone.layer3.15.bn1.weight, backbone.layer3.15.bn1.bias, backbone.layer3.15.bn1.running_mean, backbone.layer3.15.bn1.running_var, backbone.layer3.15.bn1.num_batches_tracked, backbone.layer3.15.conv2.weight, backbone.layer3.15.bn2.weight, backbone.layer3.15.bn2.bias, backbone.layer3.15.bn2.running_mean, backbone.layer3.15.bn2.running_var, backbone.layer3.15.bn2.num_batches_tracked, backbone.layer3.15.conv3.weight, backbone.layer3.15.bn3.weight, backbone.layer3.15.bn3.bias, backbone.layer3.15.bn3.running_mean, backbone.layer3.15.bn3.running_var, backbone.layer3.15.bn3.num_batches_tracked, backbone.layer3.16.conv1.weight, backbone.layer3.16.bn1.weight, backbone.layer3.16.bn1.bias, backbone.layer3.16.bn1.running_mean, backbone.layer3.16.bn1.running_var, backbone.layer3.16.bn1.num_batches_tracked, backbone.layer3.16.conv2.weight, backbone.layer3.16.bn2.weight, backbone.layer3.16.bn2.bias, backbone.layer3.16.bn2.running_mean, backbone.layer3.16.bn2.running_var, backbone.layer3.16.bn2.num_batches_tracked, backbone.layer3.16.conv3.weight, backbone.layer3.16.bn3.weight, backbone.layer3.16.bn3.bias, backbone.layer3.16.bn3.running_mean, backbone.layer3.16.bn3.running_var, backbone.layer3.16.bn3.num_batches_tracked, backbone.layer3.17.conv1.weight, backbone.layer3.17.bn1.weight, backbone.layer3.17.bn1.bias, backbone.layer3.17.bn1.running_mean, backbone.layer3.17.bn1.running_var, backbone.layer3.17.bn1.num_batches_tracked, backbone.layer3.17.conv2.weight, backbone.layer3.17.bn2.weight, backbone.layer3.17.bn2.bias, backbone.layer3.17.bn2.running_mean, backbone.layer3.17.bn2.running_var, backbone.layer3.17.bn2.num_batches_tracked, backbone.layer3.17.conv3.weight, backbone.layer3.17.bn3.weight, backbone.layer3.17.bn3.bias, backbone.layer3.17.bn3.running_mean, backbone.layer3.17.bn3.running_var, backbone.layer3.17.bn3.num_batches_tracked, backbone.layer3.18.conv1.weight, backbone.layer3.18.bn1.weight, backbone.layer3.18.bn1.bias, backbone.layer3.18.bn1.running_mean, backbone.layer3.18.bn1.running_var, backbone.layer3.18.bn1.num_batches_tracked, backbone.layer3.18.conv2.weight, backbone.layer3.18.bn2.weight, backbone.layer3.18.bn2.bias, backbone.layer3.18.bn2.running_mean, backbone.layer3.18.bn2.running_var, backbone.layer3.18.bn2.num_batches_tracked, backbone.layer3.18.conv3.weight, backbone.layer3.18.bn3.weight, backbone.layer3.18.bn3.bias, backbone.layer3.18.bn3.running_mean, backbone.layer3.18.bn3.running_var, backbone.layer3.18.bn3.num_batches_tracked, backbone.layer3.19.conv1.weight, backbone.layer3.19.bn1.weight, backbone.layer3.19.bn1.bias, backbone.layer3.19.bn1.running_mean, backbone.layer3.19.bn1.running_var, backbone.layer3.19.bn1.num_batches_tracked, backbone.layer3.19.conv2.weight, backbone.layer3.19.bn2.weight, backbone.layer3.19.bn2.bias, backbone.layer3.19.bn2.running_mean, backbone.layer3.19.bn2.running_var, backbone.layer3.19.bn2.num_batches_tracked, backbone.layer3.19.conv3.weight, backbone.layer3.19.bn3.weight, backbone.layer3.19.bn3.bias, backbone.layer3.19.bn3.running_mean, backbone.layer3.19.bn3.running_var, backbone.layer3.19.bn3.num_batches_tracked, backbone.layer3.20.conv1.weight, backbone.layer3.20.bn1.weight, backbone.layer3.20.bn1.bias, backbone.layer3.20.bn1.running_mean, backbone.layer3.20.bn1.running_var, backbone.layer3.20.bn1.num_batches_tracked, backbone.layer3.20.conv2.weight, backbone.layer3.20.bn2.weight, backbone.layer3.20.bn2.bias, backbone.layer3.20.bn2.running_mean, backbone.layer3.20.bn2.running_var, backbone.layer3.20.bn2.num_batches_tracked, backbone.layer3.20.conv3.weight, backbone.layer3.20.bn3.weight, backbone.layer3.20.bn3.bias, backbone.layer3.20.bn3.running_mean, backbone.layer3.20.bn3.running_var, backbone.layer3.20.bn3.num_batches_tracked, backbone.layer3.21.conv1.weight, backbone.layer3.21.bn1.weight, backbone.layer3.21.bn1.bias, backbone.layer3.21.bn1.running_mean, backbone.layer3.21.bn1.running_var, backbone.layer3.21.bn1.num_batches_tracked, backbone.layer3.21.conv2.weight, backbone.layer3.21.bn2.weight, backbone.layer3.21.bn2.bias, backbone.layer3.21.bn2.running_mean, backbone.layer3.21.bn2.running_var, backbone.layer3.21.bn2.num_batches_tracked, backbone.layer3.21.conv3.weight, backbone.layer3.21.bn3.weight, backbone.layer3.21.bn3.bias, backbone.layer3.21.bn3.running_mean, backbone.layer3.21.bn3.running_var, backbone.layer3.21.bn3.num_batches_tracked, backbone.layer3.22.conv1.weight, backbone.layer3.22.bn1.weight, backbone.layer3.22.bn1.bias, backbone.layer3.22.bn1.running_mean, backbone.layer3.22.bn1.running_var, backbone.layer3.22.bn1.num_batches_tracked, backbone.layer3.22.conv2.weight, backbone.layer3.22.bn2.weight, backbone.layer3.22.bn2.bias, backbone.layer3.22.bn2.running_mean, backbone.layer3.22.bn2.running_var, backbone.layer3.22.bn2.num_batches_tracked, backbone.layer3.22.conv3.weight, backbone.layer3.22.bn3.weight, backbone.layer3.22.bn3.bias, backbone.layer3.22.bn3.running_mean, backbone.layer3.22.bn3.running_var, backbone.layer3.22.bn3.num_batches_tracked, backbone.layer4.0.conv1.weight, backbone.layer4.0.bn1.weight, backbone.layer4.0.bn1.bias, backbone.layer4.0.bn1.running_mean, backbone.layer4.0.bn1.running_var, backbone.layer4.0.bn1.num_batches_tracked, backbone.layer4.0.conv2.weight, backbone.layer4.0.bn2.weight, backbone.layer4.0.bn2.bias, backbone.layer4.0.bn2.running_mean, backbone.layer4.0.bn2.running_var, backbone.layer4.0.bn2.num_batches_tracked, backbone.layer4.0.conv3.weight, backbone.layer4.0.bn3.weight, backbone.layer4.0.bn3.bias, backbone.layer4.0.bn3.running_mean, backbone.layer4.0.bn3.running_var, backbone.layer4.0.bn3.num_batches_tracked, backbone.layer4.0.downsample.0.weight, backbone.layer4.0.downsample.1.weight, backbone.layer4.0.downsample.1.bias, backbone.layer4.0.downsample.1.running_mean, backbone.layer4.0.downsample.1.running_var, backbone.layer4.0.downsample.1.num_batches_tracked, backbone.layer4.1.conv1.weight, backbone.layer4.1.bn1.weight, backbone.layer4.1.bn1.bias, backbone.layer4.1.bn1.running_mean, backbone.layer4.1.bn1.running_var, backbone.layer4.1.bn1.num_batches_tracked, backbone.layer4.1.conv2.weight, backbone.layer4.1.bn2.weight, backbone.layer4.1.bn2.bias, backbone.layer4.1.bn2.running_mean, backbone.layer4.1.bn2.running_var, backbone.layer4.1.bn2.num_batches_tracked, backbone.layer4.1.conv3.weight, backbone.layer4.1.bn3.weight, backbone.layer4.1.bn3.bias, backbone.layer4.1.bn3.running_mean, backbone.layer4.1.bn3.running_var, backbone.layer4.1.bn3.num_batches_tracked, backbone.layer4.2.conv1.weight, backbone.layer4.2.bn1.weight, backbone.layer4.2.bn1.bias, backbone.layer4.2.bn1.running_mean, backbone.layer4.2.bn1.running_var, backbone.layer4.2.bn1.num_batches_tracked, backbone.layer4.2.conv2.weight, backbone.layer4.2.bn2.weight, backbone.layer4.2.bn2.bias, backbone.layer4.2.bn2.running_mean, backbone.layer4.2.bn2.running_var, backbone.layer4.2.bn2.num_batches_tracked, backbone.layer4.2.conv3.weight, backbone.layer4.2.bn3.weight, backbone.layer4.2.bn3.bias, backbone.layer4.2.bn3.running_mean, backbone.layer4.2.bn3.running_var, backbone.layer4.2.bn3.num_batches_tracked, auxiliary_head.conv_seg.weight, auxiliary_head.conv_seg.bias, auxiliary_head.convs.0.conv.weight, auxiliary_head.convs.0.bn.weight, auxiliary_head.convs.0.bn.bias, auxiliary_head.convs.0.bn.running_mean, auxiliary_head.convs.0.bn.running_var, auxiliary_head.convs.0.bn.num_batches_tracked
+
+missing keys in source state_dict: unet.init_conv.weight, unet.init_conv.bias, unet.time_mlp.1.weight, unet.time_mlp.1.bias, unet.time_mlp.3.weight, unet.time_mlp.3.bias, unet.downs.0.0.mlp.1.weight, unet.downs.0.0.mlp.1.bias, unet.downs.0.0.block1.proj.weight, unet.downs.0.0.block1.proj.bias, unet.downs.0.0.block1.norm.weight, unet.downs.0.0.block1.norm.bias, unet.downs.0.0.block2.proj.weight, unet.downs.0.0.block2.proj.bias, unet.downs.0.0.block2.norm.weight, unet.downs.0.0.block2.norm.bias, unet.downs.0.1.mlp.1.weight, unet.downs.0.1.mlp.1.bias, unet.downs.0.1.block1.proj.weight, unet.downs.0.1.block1.proj.bias, unet.downs.0.1.block1.norm.weight, unet.downs.0.1.block1.norm.bias, unet.downs.0.1.block2.proj.weight, unet.downs.0.1.block2.proj.bias, unet.downs.0.1.block2.norm.weight, unet.downs.0.1.block2.norm.bias, unet.downs.0.2.fn.fn.to_qkv.weight, unet.downs.0.2.fn.fn.to_out.0.weight, unet.downs.0.2.fn.fn.to_out.0.bias, unet.downs.0.2.fn.fn.to_out.1.g, unet.downs.0.2.fn.norm.g, unet.downs.0.3.weight, unet.downs.0.3.bias, unet.downs.1.0.mlp.1.weight, unet.downs.1.0.mlp.1.bias, unet.downs.1.0.block1.proj.weight, unet.downs.1.0.block1.proj.bias, unet.downs.1.0.block1.norm.weight, unet.downs.1.0.block1.norm.bias, unet.downs.1.0.block2.proj.weight, unet.downs.1.0.block2.proj.bias, unet.downs.1.0.block2.norm.weight, unet.downs.1.0.block2.norm.bias, unet.downs.1.1.mlp.1.weight, unet.downs.1.1.mlp.1.bias, unet.downs.1.1.block1.proj.weight, unet.downs.1.1.block1.proj.bias, unet.downs.1.1.block1.norm.weight, unet.downs.1.1.block1.norm.bias, unet.downs.1.1.block2.proj.weight, unet.downs.1.1.block2.proj.bias, unet.downs.1.1.block2.norm.weight, unet.downs.1.1.block2.norm.bias, unet.downs.1.2.fn.fn.to_qkv.weight, unet.downs.1.2.fn.fn.to_out.0.weight, unet.downs.1.2.fn.fn.to_out.0.bias, unet.downs.1.2.fn.fn.to_out.1.g, unet.downs.1.2.fn.norm.g, unet.downs.1.3.weight, unet.downs.1.3.bias, unet.downs.2.0.mlp.1.weight, unet.downs.2.0.mlp.1.bias, unet.downs.2.0.block1.proj.weight, unet.downs.2.0.block1.proj.bias, unet.downs.2.0.block1.norm.weight, unet.downs.2.0.block1.norm.bias, unet.downs.2.0.block2.proj.weight, unet.downs.2.0.block2.proj.bias, unet.downs.2.0.block2.norm.weight, unet.downs.2.0.block2.norm.bias, unet.downs.2.1.mlp.1.weight, unet.downs.2.1.mlp.1.bias, unet.downs.2.1.block1.proj.weight, unet.downs.2.1.block1.proj.bias, unet.downs.2.1.block1.norm.weight, unet.downs.2.1.block1.norm.bias, unet.downs.2.1.block2.proj.weight, unet.downs.2.1.block2.proj.bias, unet.downs.2.1.block2.norm.weight, unet.downs.2.1.block2.norm.bias, unet.downs.2.2.fn.fn.to_qkv.weight, unet.downs.2.2.fn.fn.to_out.0.weight, unet.downs.2.2.fn.fn.to_out.0.bias, unet.downs.2.2.fn.fn.to_out.1.g, unet.downs.2.2.fn.norm.g, unet.downs.2.3.weight, unet.downs.2.3.bias, unet.ups.0.0.mlp.1.weight, unet.ups.0.0.mlp.1.bias, unet.ups.0.0.block1.proj.weight, unet.ups.0.0.block1.proj.bias, unet.ups.0.0.block1.norm.weight, unet.ups.0.0.block1.norm.bias, unet.ups.0.0.block2.proj.weight, unet.ups.0.0.block2.proj.bias, unet.ups.0.0.block2.norm.weight, unet.ups.0.0.block2.norm.bias, unet.ups.0.0.res_conv.weight, unet.ups.0.0.res_conv.bias, unet.ups.0.1.mlp.1.weight, unet.ups.0.1.mlp.1.bias, unet.ups.0.1.block1.proj.weight, unet.ups.0.1.block1.proj.bias, unet.ups.0.1.block1.norm.weight, unet.ups.0.1.block1.norm.bias, unet.ups.0.1.block2.proj.weight, unet.ups.0.1.block2.proj.bias, unet.ups.0.1.block2.norm.weight, unet.ups.0.1.block2.norm.bias, unet.ups.0.1.res_conv.weight, unet.ups.0.1.res_conv.bias, unet.ups.0.2.fn.fn.to_qkv.weight, unet.ups.0.2.fn.fn.to_out.0.weight, unet.ups.0.2.fn.fn.to_out.0.bias, unet.ups.0.2.fn.fn.to_out.1.g, unet.ups.0.2.fn.norm.g, unet.ups.0.3.1.weight, unet.ups.0.3.1.bias, unet.ups.1.0.mlp.1.weight, unet.ups.1.0.mlp.1.bias, unet.ups.1.0.block1.proj.weight, unet.ups.1.0.block1.proj.bias, unet.ups.1.0.block1.norm.weight, unet.ups.1.0.block1.norm.bias, unet.ups.1.0.block2.proj.weight, unet.ups.1.0.block2.proj.bias, unet.ups.1.0.block2.norm.weight, unet.ups.1.0.block2.norm.bias, unet.ups.1.0.res_conv.weight, unet.ups.1.0.res_conv.bias, unet.ups.1.1.mlp.1.weight, unet.ups.1.1.mlp.1.bias, unet.ups.1.1.block1.proj.weight, unet.ups.1.1.block1.proj.bias, unet.ups.1.1.block1.norm.weight, unet.ups.1.1.block1.norm.bias, unet.ups.1.1.block2.proj.weight, unet.ups.1.1.block2.proj.bias, unet.ups.1.1.block2.norm.weight, unet.ups.1.1.block2.norm.bias, unet.ups.1.1.res_conv.weight, unet.ups.1.1.res_conv.bias, unet.ups.1.2.fn.fn.to_qkv.weight, unet.ups.1.2.fn.fn.to_out.0.weight, unet.ups.1.2.fn.fn.to_out.0.bias, unet.ups.1.2.fn.fn.to_out.1.g, unet.ups.1.2.fn.norm.g, unet.ups.1.3.1.weight, unet.ups.1.3.1.bias, unet.ups.2.0.mlp.1.weight, unet.ups.2.0.mlp.1.bias, unet.ups.2.0.block1.proj.weight, unet.ups.2.0.block1.proj.bias, unet.ups.2.0.block1.norm.weight, unet.ups.2.0.block1.norm.bias, unet.ups.2.0.block2.proj.weight, unet.ups.2.0.block2.proj.bias, unet.ups.2.0.block2.norm.weight, unet.ups.2.0.block2.norm.bias, unet.ups.2.0.res_conv.weight, unet.ups.2.0.res_conv.bias, unet.ups.2.1.mlp.1.weight, unet.ups.2.1.mlp.1.bias, unet.ups.2.1.block1.proj.weight, unet.ups.2.1.block1.proj.bias, unet.ups.2.1.block1.norm.weight, unet.ups.2.1.block1.norm.bias, unet.ups.2.1.block2.proj.weight, unet.ups.2.1.block2.proj.bias, unet.ups.2.1.block2.norm.weight, unet.ups.2.1.block2.norm.bias, unet.ups.2.1.res_conv.weight, unet.ups.2.1.res_conv.bias, unet.ups.2.2.fn.fn.to_qkv.weight, unet.ups.2.2.fn.fn.to_out.0.weight, unet.ups.2.2.fn.fn.to_out.0.bias, unet.ups.2.2.fn.fn.to_out.1.g, unet.ups.2.2.fn.norm.g, unet.ups.2.3.weight, unet.ups.2.3.bias, unet.mid_block1.mlp.1.weight, unet.mid_block1.mlp.1.bias, unet.mid_block1.block1.proj.weight, unet.mid_block1.block1.proj.bias, unet.mid_block1.block1.norm.weight, unet.mid_block1.block1.norm.bias, unet.mid_block1.block2.proj.weight, unet.mid_block1.block2.proj.bias, unet.mid_block1.block2.norm.weight, unet.mid_block1.block2.norm.bias, unet.mid_attn.fn.fn.to_qkv.weight, unet.mid_attn.fn.fn.to_out.weight, unet.mid_attn.fn.fn.to_out.bias, unet.mid_attn.fn.norm.g, unet.mid_block2.mlp.1.weight, unet.mid_block2.mlp.1.bias, unet.mid_block2.block1.proj.weight, unet.mid_block2.block1.proj.bias, unet.mid_block2.block1.norm.weight, unet.mid_block2.block1.norm.bias, unet.mid_block2.block2.proj.weight, unet.mid_block2.block2.proj.bias, unet.mid_block2.block2.norm.weight, unet.mid_block2.block2.norm.bias, unet.final_res_block.mlp.1.weight, unet.final_res_block.mlp.1.bias, unet.final_res_block.block1.proj.weight, unet.final_res_block.block1.proj.bias, unet.final_res_block.block1.norm.weight, unet.final_res_block.block1.norm.bias, unet.final_res_block.block2.proj.weight, unet.final_res_block.block2.proj.bias, unet.final_res_block.block2.norm.weight, unet.final_res_block.block2.norm.bias, unet.final_res_block.res_conv.weight, unet.final_res_block.res_conv.bias, unet.final_conv.weight, unet.final_conv.bias, conv_seg_new.weight, conv_seg_new.bias, embed.weight
+
+2023-03-03 20:38:40,512 - mmseg - INFO - EncoderDecoderFreeze(
+  (backbone): ResNetV1cCustomInitWeights(
+    (stem): Sequential(
+      (0): Conv2d(3, 32, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+      (1): SyncBatchNorm(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (2): ReLU(inplace=True)
+      (3): Conv2d(32, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+      (4): SyncBatchNorm(32, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (5): ReLU(inplace=True)
+      (6): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+      (7): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (8): ReLU(inplace=True)
+    )
+    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
+    (layer1): ResLayer(
+      (0): Bottleneck(
+        (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+        (downsample): Sequential(
+          (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        )
+      )
+      (1): Bottleneck(
+        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (2): Bottleneck(
+        (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+    )
+    (layer2): ResLayer(
+      (0): Bottleneck(
+        (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+        (downsample): Sequential(
+          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
+          (1): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        )
+      )
+      (1): Bottleneck(
+        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (2): Bottleneck(
+        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (3): Bottleneck(
+        (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+    )
+    (layer3): ResLayer(
+      (0): Bottleneck(
+        (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+        (downsample): Sequential(
+          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (1): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        )
+      )
+      (1): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (2): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (3): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (4): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (5): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (6): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (7): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (8): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (9): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (10): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (11): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (12): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (13): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (14): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (15): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (16): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (17): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (18): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (19): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (20): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (21): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (22): Bottleneck(
+        (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+    )
+    (layer4): ResLayer(
+      (0): Bottleneck(
+        (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(2, 2), dilation=(2, 2), bias=False)
+        (bn2): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+        (downsample): Sequential(
+          (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (1): SyncBatchNorm(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        )
+      )
+      (1): Bottleneck(
+        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(4, 4), dilation=(4, 4), bias=False)
+        (bn2): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+      (2): Bottleneck(
+        (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn1): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(4, 4), dilation=(4, 4), bias=False)
+        (bn2): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn3): SyncBatchNorm(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (relu): ReLU(inplace=True)
+      )
+    )
+  )
+  init_cfg={'type': 'Pretrained', 'checkpoint': 'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth'}
+  (decode_head): DepthwiseSeparableASPPHeadUnetFCHeadSingleStep(
+    input_transform=None, ignore_index=0, align_corners=False
+    (loss_decode): CrossEntropyLoss(avg_non_ignore=False)
+    (conv_seg): None
+    (dropout): Dropout2d(p=0.1, inplace=False)
+    (image_pool): Sequential(
+      (0): AdaptiveAvgPool2d(output_size=1)
+      (1): ConvModule(
+        (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (activate): ReLU(inplace=True)
+      )
+    )
+    (aspp_modules): DepthwiseSeparableASPPModule(
+      (0): ConvModule(
+        (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+        (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+        (activate): ReLU(inplace=True)
+      )
+      (1): DepthwiseSeparableConvModule(
+        (depthwise_conv): ConvModule(
+          (conv): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(12, 12), dilation=(12, 12), groups=2048, bias=False)
+          (bn): SyncBatchNorm(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+        (pointwise_conv): ConvModule(
+          (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+      )
+      (2): DepthwiseSeparableConvModule(
+        (depthwise_conv): ConvModule(
+          (conv): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(24, 24), dilation=(24, 24), groups=2048, bias=False)
+          (bn): SyncBatchNorm(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+        (pointwise_conv): ConvModule(
+          (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+      )
+      (3): DepthwiseSeparableConvModule(
+        (depthwise_conv): ConvModule(
+          (conv): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(36, 36), dilation=(36, 36), groups=2048, bias=False)
+          (bn): SyncBatchNorm(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+        (pointwise_conv): ConvModule(
+          (conv): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+      )
+    )
+    (bottleneck): ConvModule(
+      (conv): Conv2d(2560, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
+      (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (activate): ReLU(inplace=True)
+    )
+    (c1_bottleneck): ConvModule(
+      (conv): Conv2d(256, 48, kernel_size=(1, 1), stride=(1, 1), bias=False)
+      (bn): SyncBatchNorm(48, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+      (activate): ReLU(inplace=True)
+    )
+    (sep_bottleneck): Sequential(
+      (0): DepthwiseSeparableConvModule(
+        (depthwise_conv): ConvModule(
+          (conv): Conv2d(560, 560, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=560, bias=False)
+          (bn): SyncBatchNorm(560, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+        (pointwise_conv): ConvModule(
+          (conv): Conv2d(560, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+      )
+      (1): DepthwiseSeparableConvModule(
+        (depthwise_conv): ConvModule(
+          (conv): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=512, bias=False)
+          (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+        (pointwise_conv): ConvModule(
+          (conv): Conv2d(512, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)
+          (bn): SyncBatchNorm(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
+          (activate): ReLU(inplace=True)
+        )
+      )
+    )
+    (unet): Unet(
+      (init_conv): Conv2d(528, 256, kernel_size=(7, 7), stride=(1, 1), padding=(3, 3))
+      (time_mlp): Sequential(
+        (0): SinusoidalPosEmb()
+        (1): Linear(in_features=256, out_features=1024, bias=True)
+        (2): GELU(approximate='none')
+        (3): Linear(in_features=1024, out_features=1024, bias=True)
+      )
+      (downs): ModuleList(
+        (0): ModuleList(
+          (0): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Identity()
+          )
+          (1): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Identity()
+          )
+          (2): Residual(
+            (fn): PreNorm(
+              (fn): LinearAttention(
+                (to_qkv): Conv2d(256, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
+                (to_out): Sequential(
+                  (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))
+                  (1): LayerNorm()
+                )
+              )
+              (norm): LayerNorm()
+            )
+          )
+          (3): Conv2d(256, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))
+        )
+        (1): ModuleList(
+          (0): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Identity()
+          )
+          (1): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Identity()
+          )
+          (2): Residual(
+            (fn): PreNorm(
+              (fn): LinearAttention(
+                (to_qkv): Conv2d(256, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
+                (to_out): Sequential(
+                  (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))
+                  (1): LayerNorm()
+                )
+              )
+              (norm): LayerNorm()
+            )
+          )
+          (3): Conv2d(256, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))
+        )
+        (2): ModuleList(
+          (0): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Identity()
+          )
+          (1): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Identity()
+          )
+          (2): Residual(
+            (fn): PreNorm(
+              (fn): LinearAttention(
+                (to_qkv): Conv2d(256, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
+                (to_out): Sequential(
+                  (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))
+                  (1): LayerNorm()
+                )
+              )
+              (norm): LayerNorm()
+            )
+          )
+          (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        )
+      )
+      (ups): ModuleList(
+        (0): ModuleList(
+          (0): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
+          )
+          (1): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
+          )
+          (2): Residual(
+            (fn): PreNorm(
+              (fn): LinearAttention(
+                (to_qkv): Conv2d(256, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
+                (to_out): Sequential(
+                  (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))
+                  (1): LayerNorm()
+                )
+              )
+              (norm): LayerNorm()
+            )
+          )
+          (3): Sequential(
+            (0): Upsample(scale_factor=2.0, mode=nearest)
+            (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          )
+        )
+        (1): ModuleList(
+          (0): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
+          )
+          (1): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
+          )
+          (2): Residual(
+            (fn): PreNorm(
+              (fn): LinearAttention(
+                (to_qkv): Conv2d(256, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
+                (to_out): Sequential(
+                  (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))
+                  (1): LayerNorm()
+                )
+              )
+              (norm): LayerNorm()
+            )
+          )
+          (3): Sequential(
+            (0): Upsample(scale_factor=2.0, mode=nearest)
+            (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          )
+        )
+        (2): ModuleList(
+          (0): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
+          )
+          (1): ResnetBlock(
+            (mlp): Sequential(
+              (0): SiLU()
+              (1): Linear(in_features=1024, out_features=512, bias=True)
+            )
+            (block1): Block(
+              (proj): WeightStandardizedConv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (block2): Block(
+              (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+              (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+              (act): SiLU()
+            )
+            (res_conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
+          )
+          (2): Residual(
+            (fn): PreNorm(
+              (fn): LinearAttention(
+                (to_qkv): Conv2d(256, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
+                (to_out): Sequential(
+                  (0): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))
+                  (1): LayerNorm()
+                )
+              )
+              (norm): LayerNorm()
+            )
+          )
+          (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+        )
+      )
+      (mid_block1): ResnetBlock(
+        (mlp): Sequential(
+          (0): SiLU()
+          (1): Linear(in_features=1024, out_features=512, bias=True)
+        )
+        (block1): Block(
+          (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+          (act): SiLU()
+        )
+        (block2): Block(
+          (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+          (act): SiLU()
+        )
+        (res_conv): Identity()
+      )
+      (mid_attn): Residual(
+        (fn): PreNorm(
+          (fn): Attention(
+            (to_qkv): Conv2d(256, 384, kernel_size=(1, 1), stride=(1, 1), bias=False)
+            (to_out): Conv2d(128, 256, kernel_size=(1, 1), stride=(1, 1))
+          )
+          (norm): LayerNorm()
+        )
+      )
+      (mid_block2): ResnetBlock(
+        (mlp): Sequential(
+          (0): SiLU()
+          (1): Linear(in_features=1024, out_features=512, bias=True)
+        )
+        (block1): Block(
+          (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+          (act): SiLU()
+        )
+        (block2): Block(
+          (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+          (act): SiLU()
+        )
+        (res_conv): Identity()
+      )
+      (final_res_block): ResnetBlock(
+        (mlp): Sequential(
+          (0): SiLU()
+          (1): Linear(in_features=1024, out_features=512, bias=True)
+        )
+        (block1): Block(
+          (proj): WeightStandardizedConv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+          (act): SiLU()
+        )
+        (block2): Block(
+          (proj): WeightStandardizedConv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))
+          (norm): GroupNorm(8, 256, eps=1e-05, affine=True)
+          (act): SiLU()
+        )
+        (res_conv): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))
+      )
+      (final_conv): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))
+    )
+    (conv_seg_new): Conv2d(256, 20, kernel_size=(1, 1), stride=(1, 1))
+    (embed): Embedding(20, 16)
+  )
+  init_cfg={'type': 'Pretrained', 'checkpoint': 'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth'}
+)
+2023-03-03 20:38:40,578 - mmseg - INFO - Loaded 2975 images
+2023-03-03 20:38:41,636 - mmseg - INFO - Loaded 500 images
+2023-03-03 20:38:41,642 - mmseg - INFO - Start running, host: laizeqiang@SH-IDC1-10-140-37-151, work_dir: /mnt/petrelfs/laizeqiang/mmseg-baseline/work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20
+2023-03-03 20:38:41,642 - mmseg - INFO - Hooks will be executed in the following order:
+before_run:
+(VERY_HIGH   ) StepLrUpdaterHook                  
+(NORMAL      ) CheckpointHook                     
+(LOW         ) DistEvalHookMultiSteps             
+(VERY_LOW    ) TextLoggerHook                     
+ -------------------- 
+before_train_epoch:
+(VERY_HIGH   ) StepLrUpdaterHook                  
+(LOW         ) IterTimerHook                      
+(LOW         ) DistEvalHookMultiSteps             
+(VERY_LOW    ) TextLoggerHook                     
+ -------------------- 
+before_train_iter:
+(VERY_HIGH   ) StepLrUpdaterHook                  
+(LOW         ) IterTimerHook                      
+(LOW         ) DistEvalHookMultiSteps             
+ -------------------- 
+after_train_iter:
+(ABOVE_NORMAL) OptimizerHook                      
+(NORMAL      ) CheckpointHook                     
+(LOW         ) IterTimerHook                      
+(LOW         ) DistEvalHookMultiSteps             
+(VERY_LOW    ) TextLoggerHook                     
+ -------------------- 
+after_train_epoch:
+(NORMAL      ) CheckpointHook                     
+(LOW         ) DistEvalHookMultiSteps             
+(VERY_LOW    ) TextLoggerHook                     
+ -------------------- 
+before_val_epoch:
+(LOW         ) IterTimerHook                      
+(VERY_LOW    ) TextLoggerHook                     
+ -------------------- 
+before_val_iter:
+(LOW         ) IterTimerHook                      
+ -------------------- 
+after_val_iter:
+(LOW         ) IterTimerHook                      
+ -------------------- 
+after_val_epoch:
+(VERY_LOW    ) TextLoggerHook                     
+ -------------------- 
+after_run:
+(VERY_LOW    ) TextLoggerHook                     
+ -------------------- 
+2023-03-03 20:38:41,642 - mmseg - INFO - workflow: [('train', 1)], max: 80000 iters
+2023-03-03 20:38:41,642 - mmseg - INFO - Checkpoints will be saved to /mnt/petrelfs/laizeqiang/mmseg-baseline/work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20 by HardDiskBackend.
+2023-03-03 20:39:26,258 - mmseg - INFO - Iter [50/80000]	lr: 7.350e-06, eta: 14:40:40, time: 0.661, data_time: 0.014, memory: 67605, decode.loss_ce: 1.8576, decode.acc_seg: 63.8241, loss: 1.8576

cityscapes/deeplabv3plus_r101_singlestep/20230303_203832.log.json

@@ -0,0 +1,2 @@
+{"env_info": "sys.platform: linux\nPython: 3.7.16 (default, Jan 17 2023, 22:20:44) [GCC 11.2.0]\nCUDA available: True\nGPU 0,1,2,3,4,5,6,7: NVIDIA A100-SXM4-80GB\nCUDA_HOME: /mnt/petrelfs/laizeqiang/miniconda3/envs/torch\nNVCC: Cuda compilation tools, release 11.6, V11.6.124\nGCC: gcc (GCC) 4.8.5 20150623 (Red Hat 4.8.5-44)\nPyTorch: 1.13.1\nPyTorch compiling details: PyTorch built with:\n  - GCC 9.3\n  - C++ Version: 201402\n  - Intel(R) oneAPI Math Kernel Library Version 2021.4-Product Build 20210904 for Intel(R) 64 architecture applications\n  - Intel(R) MKL-DNN v2.6.0 (Git Hash 52b5f107dd9cf10910aaa19cb47f3abf9b349815)\n  - OpenMP 201511 (a.k.a. OpenMP 4.5)\n  - LAPACK is enabled (usually provided by MKL)\n  - NNPACK is enabled\n  - CPU capability usage: AVX2\n  - CUDA Runtime 11.6\n  - NVCC architecture flags: -gencode;arch=compute_37,code=sm_37;-gencode;arch=compute_50,code=sm_50;-gencode;arch=compute_60,code=sm_60;-gencode;arch=compute_61,code=sm_61;-gencode;arch=compute_70,code=sm_70;-gencode;arch=compute_75,code=sm_75;-gencode;arch=compute_80,code=sm_80;-gencode;arch=compute_86,code=sm_86;-gencode;arch=compute_37,code=compute_37\n  - CuDNN 8.3.2  (built against CUDA 11.5)\n  - Magma 2.6.1\n  - Build settings: BLAS_INFO=mkl, BUILD_TYPE=Release, CUDA_VERSION=11.6, CUDNN_VERSION=8.3.2, CXX_COMPILER=/opt/rh/devtoolset-9/root/usr/bin/c++, CXX_FLAGS= -fabi-version=11 -Wno-deprecated -fvisibility-inlines-hidden -DUSE_PTHREADPOOL -fopenmp -DNDEBUG -DUSE_KINETO -DUSE_FBGEMM -DUSE_QNNPACK -DUSE_PYTORCH_QNNPACK -DUSE_XNNPACK -DSYMBOLICATE_MOBILE_DEBUG_HANDLE -DEDGE_PROFILER_USE_KINETO -O2 -fPIC -Wno-narrowing -Wall -Wextra -Werror=return-type -Werror=non-virtual-dtor -Wno-missing-field-initializers -Wno-type-limits -Wno-array-bounds -Wno-unknown-pragmas -Wunused-local-typedefs -Wno-unused-parameter -Wno-unused-function -Wno-unused-result -Wno-strict-overflow -Wno-strict-aliasing -Wno-error=deprecated-declarations -Wno-stringop-overflow -Wno-psabi -Wno-error=pedantic -Wno-error=redundant-decls -Wno-error=old-style-cast -fdiagnostics-color=always -faligned-new -Wno-unused-but-set-variable -Wno-maybe-uninitialized -fno-math-errno -fno-trapping-math -Werror=format -Werror=cast-function-type -Wno-stringop-overflow, LAPACK_INFO=mkl, PERF_WITH_AVX=1, PERF_WITH_AVX2=1, PERF_WITH_AVX512=1, TORCH_VERSION=1.13.1, USE_CUDA=ON, USE_CUDNN=ON, USE_EXCEPTION_PTR=1, USE_GFLAGS=OFF, USE_GLOG=OFF, USE_MKL=ON, USE_MKLDNN=ON, USE_MPI=OFF, USE_NCCL=ON, USE_NNPACK=ON, USE_OPENMP=ON, USE_ROCM=OFF, \n\nTorchVision: 0.14.1\nOpenCV: 4.7.0\nMMCV: 1.7.1\nMMCV Compiler: GCC 9.3\nMMCV CUDA Compiler: 11.6\nMMSegmentation: 0.30.0+c844fc6", "seed": 835892801, "exp_name": "deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20.py", "mmseg_version": "0.30.0+c844fc6", "config": "norm_cfg = dict(type='SyncBN', requires_grad=True)\nmodel = dict(\n    type='EncoderDecoderFreeze',\n    pretrained=\n    'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth',\n    backbone=dict(\n        type='ResNetV1cCustomInitWeights',\n        depth=101,\n        num_stages=4,\n        out_indices=(0, 1, 2, 3),\n        dilations=(1, 1, 2, 4),\n        strides=(1, 2, 1, 1),\n        norm_cfg=dict(type='SyncBN', requires_grad=True),\n        norm_eval=False,\n        style='pytorch',\n        contract_dilation=True,\n        pretrained=\n        'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth'\n    ),\n    decode_head=dict(\n        type='DepthwiseSeparableASPPHeadUnetFCHeadSingleStep',\n        pretrained=\n        'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth',\n        dim=256,\n        out_dim=256,\n        unet_channels=528,\n        dim_mults=[1, 1, 1],\n        cat_embedding_dim=16,\n        ignore_index=0,\n        in_channels=2048,\n        in_index=3,\n        channels=512,\n        dilations=(1, 12, 24, 36),\n        c1_in_channels=256,\n        c1_channels=48,\n        dropout_ratio=0.1,\n        num_classes=20,\n        norm_cfg=dict(type='SyncBN', requires_grad=True),\n        align_corners=False,\n        loss_decode=dict(\n            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),\n    auxiliary_head=None,\n    train_cfg=dict(),\n    test_cfg=dict(mode='whole'),\n    freeze_parameters=['backbone', 'decode_head'])\ndataset_type = 'Cityscapes20Dataset'\ndata_root = 'data/cityscapes/'\nimg_norm_cfg = dict(\n    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)\ncrop_size = (512, 1024)\ntrain_pipeline = [\n    dict(type='LoadImageFromFile'),\n    dict(type='LoadAnnotationsCityscapes20'),\n    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),\n    dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),\n    dict(type='RandomFlip', prob=0.5),\n    dict(type='PhotoMetricDistortion'),\n    dict(\n        type='Normalize',\n        mean=[123.675, 116.28, 103.53],\n        std=[58.395, 57.12, 57.375],\n        to_rgb=True),\n    dict(type='Pad', size=(512, 1024), pad_val=0, seg_pad_val=0),\n    dict(type='DefaultFormatBundle'),\n    dict(type='Collect', keys=['img', 'gt_semantic_seg'])\n]\ntest_pipeline = [\n    dict(type='LoadImageFromFile'),\n    dict(\n        type='MultiScaleFlipAug',\n        img_scale=(2048, 1024),\n        flip=False,\n        transforms=[\n            dict(type='Resize', keep_ratio=True),\n            dict(type='RandomFlip'),\n            dict(\n                type='Normalize',\n                mean=[123.675, 116.28, 103.53],\n                std=[58.395, 57.12, 57.375],\n                to_rgb=True),\n            dict(type='ImageToTensor', keys=['img']),\n            dict(type='Collect', keys=['img'])\n        ])\n]\ndata = dict(\n    samples_per_gpu=2,\n    workers_per_gpu=2,\n    train=dict(\n        type='Cityscapes20Dataset',\n        data_root='data/cityscapes/',\n        img_dir='leftImg8bit/train',\n        ann_dir='gtFine/train',\n        pipeline=[\n            dict(type='LoadImageFromFile'),\n            dict(type='LoadAnnotationsCityscapes20'),\n            dict(\n                type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),\n            dict(type='RandomCrop', crop_size=(512, 1024), cat_max_ratio=0.75),\n            dict(type='RandomFlip', prob=0.5),\n            dict(type='PhotoMetricDistortion'),\n            dict(\n                type='Normalize',\n                mean=[123.675, 116.28, 103.53],\n                std=[58.395, 57.12, 57.375],\n                to_rgb=True),\n            dict(type='Pad', size=(512, 1024), pad_val=0, seg_pad_val=0),\n            dict(type='DefaultFormatBundle'),\n            dict(type='Collect', keys=['img', 'gt_semantic_seg'])\n        ]),\n    val=dict(\n        type='Cityscapes20Dataset',\n        data_root='data/cityscapes/',\n        img_dir='leftImg8bit/val',\n        ann_dir='gtFine/val',\n        pipeline=[\n            dict(type='LoadImageFromFile'),\n            dict(\n                type='MultiScaleFlipAug',\n                img_scale=(2048, 1024),\n                flip=False,\n                transforms=[\n                    dict(type='Resize', keep_ratio=True),\n                    dict(type='RandomFlip'),\n                    dict(\n                        type='Normalize',\n                        mean=[123.675, 116.28, 103.53],\n                        std=[58.395, 57.12, 57.375],\n                        to_rgb=True),\n                    dict(type='ImageToTensor', keys=['img']),\n                    dict(type='Collect', keys=['img'])\n                ])\n        ]),\n    test=dict(\n        type='Cityscapes20Dataset',\n        data_root='data/cityscapes/',\n        img_dir='leftImg8bit/val',\n        ann_dir='gtFine/val',\n        pipeline=[\n            dict(type='LoadImageFromFile'),\n            dict(\n                type='MultiScaleFlipAug',\n                img_scale=(2048, 1024),\n                flip=False,\n                transforms=[\n                    dict(type='Resize', keep_ratio=True),\n                    dict(type='RandomFlip'),\n                    dict(\n                        type='Normalize',\n                        mean=[123.675, 116.28, 103.53],\n                        std=[58.395, 57.12, 57.375],\n                        to_rgb=True),\n                    dict(type='ImageToTensor', keys=['img']),\n                    dict(type='Collect', keys=['img'])\n                ])\n        ]))\nlog_config = dict(\n    interval=50, hooks=[dict(type='TextLoggerHook', by_epoch=False)])\ndist_params = dict(backend='nccl')\nlog_level = 'INFO'\nload_from = None\nresume_from = None\nworkflow = [('train', 1)]\ncudnn_benchmark = True\noptimizer = dict(\n    type='AdamW', lr=0.00015, betas=[0.9, 0.96], weight_decay=0.045)\noptimizer_config = dict()\nlr_config = dict(\n    policy='step',\n    warmup='linear',\n    warmup_iters=1000,\n    warmup_ratio=1e-06,\n    step=10000,\n    gamma=0.5,\n    min_lr=1e-06,\n    by_epoch=False)\nrunner = dict(type='IterBasedRunner', max_iters=80000)\ncheckpoint_config = dict(by_epoch=False, interval=8000, max_keep_ckpts=1)\nevaluation = dict(\n    interval=8000, metric='mIoU', pre_eval=True, save_best='mIoU')\ncheckpoint = 'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth'\nwork_dir = './work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20'\ngpu_ids = range(0, 8)\nauto_resume = True\ndevice = 'cuda'\nseed = 835892801\n", "CLASSES": ["background", "road", "sidewalk", "building", "wall", "fence", "pole", "traffic light", "traffic sign", "vegetation", "terrain", "sky", "person", "rider", "car", "truck", "bus", "train", "motorcycle", "bicycle"], "PALETTE": [[0, 0, 0], [128, 64, 128], [244, 35, 232], [70, 70, 70], [102, 102, 156], [190, 153, 153], [153, 153, 153], [250, 170, 30], [220, 220, 0], [107, 142, 35], [152, 251, 152], [70, 130, 180], [220, 20, 60], [255, 0, 0], [0, 0, 142], [0, 0, 70], [0, 60, 100], [0, 80, 100], [0, 0, 230], [119, 11, 32]], "hook_msgs": {}}
+{"mode": "train", "epoch": 1, "iter": 50, "lr": 1e-05, "memory": 67605, "data_time": 0.01446, "decode.loss_ce": 1.8576, "decode.acc_seg": 63.82413, "loss": 1.8576, "time": 0.66091}

cityscapes/deeplabv3plus_r101_singlestep/best_mIoU_iter_64000.pth

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

cityscapes/deeplabv3plus_r101_singlestep/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20.py

@@ -0,0 +1,180 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoderFreeze',
+    pretrained=
+    'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth',
+    backbone=dict(
+        type='ResNetV1cCustomInitWeights',
+        depth=101,
+        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='DepthwiseSeparableASPPHeadUnetFCHeadSingleStep',
+        pretrained=
+        'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth',
+        dim=256,
+        out_dim=256,
+        unet_channels=528,
+        dim_mults=[1, 1, 1],
+        cat_embedding_dim=16,
+        ignore_index=0,
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=20,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=None,
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'),
+    freeze_parameters=['backbone', 'decode_head'])
+dataset_type = 'Cityscapes20Dataset'
+data_root = 'data/cityscapes/'
+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='LoadAnnotationsCityscapes20'),
+    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=0),
+    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'])
+        ])
+]
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/train',
+        ann_dir='gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotationsCityscapes20'),
+            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=0),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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'])
+                ])
+        ]))
+log_config = dict(
+    interval=50, 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 = True
+optimizer = dict(
+    type='AdamW', lr=0.00015, betas=[0.9, 0.96], weight_decay=0.045)
+optimizer_config = dict()
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1e-06,
+    step=10000,
+    gamma=0.5,
+    min_lr=1e-06,
+    by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=80000)
+checkpoint_config = dict(by_epoch=False, interval=8000, max_keep_ckpts=1)
+evaluation = dict(
+    interval=8000, metric='mIoU', pre_eval=True, save_best='mIoU')
+checkpoint = 'pretrained/deeplabv3plus_r101-d8_512x1024_80k_cityscapes_20200606_114143-068fcfe9.pth'
+work_dir = './work_dirs2/deeplabv3plus_r101-d8_aspp_head_unet_fc_small_single_step_cityscapes_pretrained_freeze_embed_80k_cityscapes20'
+gpu_ids = range(0, 8)
+auto_resume = True

cityscapes/deeplabv3plus_r101_singlestep/iter_80000.pth

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

cityscapes/deeplabv3plus_r101_singlestep/latest.pth

@@ -0,0 +1 @@
+iter_80000.pth

cityscapes/deeplabv3plus_r50_multistep/best_mIoU_iter_96000.pth

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

cityscapes/deeplabv3plus_r50_multistep/deeplabv3plus_r50-d8_aspp_head_unet_fc_multi_step_ade_pretrained_freeze_embed_160k_cityscapes20_finetune.py

@@ -0,0 +1,191 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoderDiffusion',
+    pretrained=
+    'work_dirs2/deeplabv3plus_r50-d8_aspp_head_unet_fc_single_step_ade_pretrained_freeze_embed_80k_cityscapes20/best_mIoU_iter_72000.pth',
+    backbone=dict(
+        type='ResNetV1cCustomInitWeights',
+        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='DepthwiseSeparableASPPHeadUnetFCHeadMultiStep',
+        pretrained=
+        'work_dirs2/deeplabv3plus_r50-d8_aspp_head_unet_fc_single_step_ade_pretrained_freeze_embed_80k_cityscapes20/best_mIoU_iter_72000.pth',
+        dim=128,
+        out_dim=256,
+        unet_channels=528,
+        dim_mults=[1, 1, 1],
+        cat_embedding_dim=16,
+        ignore_index=0,
+        diffusion_timesteps=100,
+        collect_timesteps=[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 99],
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=20,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=None,
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'),
+    freeze_parameters=['backbone', 'decode_head'])
+dataset_type = 'Cityscapes20Dataset'
+data_root = 'data/cityscapes/'
+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='LoadAnnotationsCityscapes20'),
+    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=0),
+    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'])
+        ])
+]
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/train',
+        ann_dir='gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotationsCityscapes20'),
+            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=0),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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'])
+                ])
+        ]))
+log_config = dict(
+    interval=50, 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 = True
+optimizer = dict(
+    type='AdamW', lr=0.00015, betas=[0.9, 0.96], weight_decay=0.045)
+optimizer_config = dict()
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1e-06,
+    step=20000,
+    gamma=0.5,
+    min_lr=1e-06,
+    by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=160000)
+checkpoint_config = dict(by_epoch=False, interval=16000, max_keep_ckpts=1)
+evaluation = dict(
+    interval=16000, metric='mIoU', pre_eval=True, save_best='mIoU')
+checkpoint = 'work_dirs2/deeplabv3plus_r50-d8_aspp_head_unet_fc_single_step_ade_pretrained_freeze_embed_80k_cityscapes20/best_mIoU_iter_72000.pth'
+custom_hooks = [
+    dict(
+        type='ConstantMomentumEMAHook',
+        momentum=0.01,
+        interval=25,
+        eval_interval=16000,
+        auto_resume=True,
+        priority=49)
+]
+work_dir = './work_dirs2/deeplabv3plus_r50-d8_aspp_head_unet_fc_multi_step_ade_pretrained_freeze_embed_160k_cityscapes20_finetune'
+gpu_ids = range(0, 8)
+auto_resume = True

cityscapes/deeplabv3plus_r50_multistep/iter_160000.pth

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

cityscapes/deeplabv3plus_r50_multistep/latest.pth

@@ -0,0 +1 @@
+iter_160000.pth

cityscapes/deeplabv3plus_r50_singlestep/best_mIoU_iter_72000.pth

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

cityscapes/deeplabv3plus_r50_singlestep/deeplabv3plus_r50-d8_aspp_head_unet_fc_single_step_ade_pretrained_freeze_embed_80k_cityscapes20.py

@@ -0,0 +1,180 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+model = dict(
+    type='EncoderDecoderFreeze',
+    pretrained=
+    'pretrained/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth',
+    backbone=dict(
+        type='ResNetV1cCustomInitWeights',
+        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='DepthwiseSeparableASPPHeadUnetFCHeadSingleStep',
+        pretrained=
+        'pretrained/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth',
+        dim=128,
+        out_dim=256,
+        unet_channels=528,
+        dim_mults=[1, 1, 1],
+        cat_embedding_dim=16,
+        ignore_index=0,
+        in_channels=2048,
+        in_index=3,
+        channels=512,
+        dilations=(1, 12, 24, 36),
+        c1_in_channels=256,
+        c1_channels=48,
+        dropout_ratio=0.1,
+        num_classes=20,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    auxiliary_head=None,
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'),
+    freeze_parameters=['backbone', 'decode_head'])
+dataset_type = 'Cityscapes20Dataset'
+data_root = 'data/cityscapes/'
+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='LoadAnnotationsCityscapes20'),
+    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=0),
+    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'])
+        ])
+]
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/train',
+        ann_dir='gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotationsCityscapes20'),
+            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=0),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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'])
+                ])
+        ]))
+log_config = dict(
+    interval=50, 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 = True
+optimizer = dict(
+    type='AdamW', lr=0.00015, betas=[0.9, 0.96], weight_decay=0.045)
+optimizer_config = dict()
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1e-06,
+    step=10000,
+    gamma=0.5,
+    min_lr=1e-06,
+    by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=80000)
+checkpoint_config = dict(by_epoch=False, interval=8000, max_keep_ckpts=1)
+evaluation = dict(
+    interval=8000, metric='mIoU', pre_eval=True, save_best='mIoU')
+checkpoint = 'pretrained/deeplabv3plus_r50-d8_512x1024_80k_cityscapes_20200606_114049-f9fb496d.pth'
+work_dir = './work_dirs2/deeplabv3plus_r50-d8_aspp_head_unet_fc_single_step_ade_pretrained_freeze_embed_80k_cityscapes20'
+gpu_ids = range(0, 8)
+auto_resume = True

cityscapes/deeplabv3plus_r50_singlestep/iter_80000.pth

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

cityscapes/deeplabv3plus_r50_singlestep/latest.pth

@@ -0,0 +1 @@
+iter_80000.pth

cityscapes/segformer_b0_multistep/best_mIoU_iter_144000.pth

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

cityscapes/segformer_b0_multistep/segformer_mit_b0_segformer_head_unet_fc_single_step_ade_pretrained_freeze_embed_80k_cityscapes20_finetune_cfg.py

@@ -0,0 +1,68 @@
+_base_ = [
+    '../_base_/models/segformer_mit-b2_segformer_head_unet_fc.py',
+    '../_base_/datasets/cityscapes20_1024x1024.py',
+    '../_base_/default_runtime.py',
+    '../_base_/schedules/schedule_160k.py'
+
+]
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+checkpoint = 'work_dirs/segformer_mit_b0_segformer_head_unet_fc_single_step_ade_pretrained_freeze_embed_80k_cityscapes20/best_mIoU_iter_48000.pth'
+# model settings
+model = dict(
+    type='EncoderDecoderDiffusion',
+    freeze_parameters=['backbone', 'decode_head'],
+    pretrained=checkpoint,
+    backbone=dict(
+        type='MixVisionTransformerCustomInitWeights',
+        embed_dims=32,
+        num_layers=[2, 2, 2, 2],
+        num_heads=[1, 2, 5, 8],
+    ),
+    decode_head=dict(
+        _delete_=True,
+        type='SegformerHeadUnetFCHeadMultiStep',
+        # unet params
+        pretrained=checkpoint,
+        dim=128,
+        out_dim=256,
+        unet_channels=272,
+        dim_mults=[1,1,1],
+        cat_embedding_dim=16,
+        diffusion_timesteps=20,
+        # collect_timesteps=[19,18,17,16,15,10,5,0],
+        collect_timesteps=[i for i in range(20)],
+        guidance_scale=1,
+        # decode head params
+        in_channels=[32, 64, 160, 256],
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        dropout_ratio=0.1,
+        num_classes=20,
+        norm_cfg=norm_cfg,
+        align_corners=False,
+        ignore_index=0,  # ignore background
+        loss_decode=dict(
+            type='CrossEntropyLoss',
+            use_sigmoid=False,
+            loss_weight=1.0)
+    )
+)
+
+optimizer = dict(_delete_=True, type='AdamW', lr=1.5e-4, betas=[0.9, 0.96], weight_decay=0.045)
+lr_config = dict(_delete_=True, policy='step',
+                 warmup='linear',
+                 warmup_iters=1000,
+                 warmup_ratio=1e-6,
+                 step=20000, gamma=0.5, min_lr=1.0e-6, by_epoch=False)
+
+
+custom_hooks = [dict(
+        type='ConstantMomentumEMAHook',
+        momentum=0.01,
+        interval=25,
+        eval_interval=16000,
+        auto_resume=True,
+        priority=49)
+]
+
+# evaluation = dict(interval=100, metric='mIoU', pre_eval=True, save_best='mIoU')

cityscapes/segformer_b2_multistep/best_mIoU_iter_128000.pth

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

cityscapes/segformer_b2_multistep/iter_160000.pth

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

cityscapes/segformer_b2_multistep/latest.pth

@@ -0,0 +1 @@
+iter_160000.pth

cityscapes/segformer_b2_multistep/segformer_mit_b2_segformer_head_unet_fc_small_multi_step_ade_pretrained_freeze_embed_160k_cityscapes20_finetune_ema.py

@@ -0,0 +1,195 @@
+norm_cfg = dict(type='SyncBN', requires_grad=True)
+checkpoint = 'work_dirs/segformer_mit_b2_segformer_head_unet_fc_small_single_step_ade_pretrained_freeze_embed_80k_cityscapes20/best_mIoU_iter_64000.pth'
+model = dict(
+    type='EncoderDecoderDiffusion',
+    freeze_parameters=['backbone', 'decode_head'],
+    pretrained=
+    'work_dirs/segformer_mit_b2_segformer_head_unet_fc_small_single_step_ade_pretrained_freeze_embed_80k_cityscapes20/best_mIoU_iter_64000.pth',
+    backbone=dict(
+        type='MixVisionTransformerCustomInitWeights',
+        in_channels=3,
+        embed_dims=64,
+        num_stages=4,
+        num_layers=[3, 4, 6, 3],
+        num_heads=[1, 2, 5, 8],
+        patch_sizes=[7, 3, 3, 3],
+        sr_ratios=[8, 4, 2, 1],
+        out_indices=(0, 1, 2, 3),
+        mlp_ratio=4,
+        qkv_bias=True,
+        drop_rate=0.0,
+        attn_drop_rate=0.0,
+        drop_path_rate=0.1),
+    decode_head=dict(
+        type='SegformerHeadUnetFCHeadMultiStep',
+        pretrained=
+        'work_dirs/segformer_mit_b2_segformer_head_unet_fc_small_single_step_ade_pretrained_freeze_embed_80k_cityscapes20/best_mIoU_iter_64000.pth',
+        dim=256,
+        out_dim=256,
+        unet_channels=272,
+        dim_mults=[1, 1, 1],
+        cat_embedding_dim=16,
+        diffusion_timesteps=20,
+        collect_timesteps=[
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+            19
+        ],
+        in_channels=[64, 128, 320, 512],
+        in_index=[0, 1, 2, 3],
+        channels=256,
+        dropout_ratio=0.1,
+        num_classes=20,
+        norm_cfg=dict(type='SyncBN', requires_grad=True),
+        align_corners=False,
+        ignore_index=0,
+        loss_decode=dict(
+            type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
+    train_cfg=dict(),
+    test_cfg=dict(mode='whole'))
+dataset_type = 'Cityscapes20Dataset'
+data_root = 'data/cityscapes/'
+img_norm_cfg = dict(
+    mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
+crop_size = (1024, 1024)
+train_pipeline = [
+    dict(type='LoadImageFromFile'),
+    dict(type='LoadAnnotationsCityscapes20'),
+    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomCrop', crop_size=(1024, 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=(1024, 1024), pad_val=0, seg_pad_val=0),
+    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'])
+        ])
+]
+data = dict(
+    samples_per_gpu=2,
+    workers_per_gpu=2,
+    train=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/train',
+        ann_dir='gtFine/train',
+        pipeline=[
+            dict(type='LoadImageFromFile'),
+            dict(type='LoadAnnotationsCityscapes20'),
+            dict(
+                type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+            dict(
+                type='RandomCrop', crop_size=(1024, 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=(1024, 1024), pad_val=0, seg_pad_val=0),
+            dict(type='DefaultFormatBundle'),
+            dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+        ]),
+    val=dict(
+        type='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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='Cityscapes20Dataset',
+        data_root='data/cityscapes/',
+        img_dir='leftImg8bit/val',
+        ann_dir='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'])
+                ])
+        ]))
+log_config = dict(
+    interval=50, 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 = True
+optimizer = dict(
+    type='AdamW', lr=0.00015, betas=[0.9, 0.96], weight_decay=0.045)
+optimizer_config = dict()
+lr_config = dict(
+    policy='step',
+    warmup='linear',
+    warmup_iters=1000,
+    warmup_ratio=1e-06,
+    step=20000,
+    gamma=0.5,
+    min_lr=1e-06,
+    by_epoch=False)
+runner = dict(type='IterBasedRunner', max_iters=160000)
+checkpoint_config = dict(by_epoch=False, interval=16000, max_keep_ckpts=1)
+evaluation = dict(
+    interval=16000, metric='mIoU', pre_eval=True, save_best='mIoU')
+custom_hooks = [
+    dict(
+        type='ConstantMomentumEMAHook',
+        momentum=0.01,
+        interval=25,
+        eval_interval=16000,
+        auto_resume=True,
+        priority=49)
+]
+work_dir = './work_dirs/segformer_mit_b2_segformer_head_unet_fc_small_multi_step_ade_pretrained_freeze_embed_160k_cityscapes20_finetune_ema'
+gpu_ids = range(0, 8)
+auto_resume = True