[Refactor] Refactor Dataset and its Transform Config files

configs/_base_/datasets/ade20k.py

@@ -7,48 +7,39 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/training',
-        ann_dir='annotations/training',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/ade20k_640x640.py

@@ -7,48 +7,39 @@ crop_size = (640, 640)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2560, 640), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2560, 640), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2560, 640),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/training',
-        ann_dir='annotations/training',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/chase_db1.py

@@ -8,52 +8,42 @@ crop_size = (128, 128)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=img_scale, ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=img_scale,
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
 
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
-        type='RepeatDataset',
-        times=40000,
-        dataset=dict(
-            type=dataset_type,
-            data_root=data_root,
-            img_dir='images/training',
-            ann_dir='annotations/training',
-            pipeline=train_pipeline)),
-    val=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    type='RepeatDataset',
+    times=40000,
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
-        pipeline=test_pipeline),
-    test=dict(
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/cityscapes.py

@@ -7,48 +7,38 @@ crop_size = (512, 1024)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 1024), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 1024),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=2,
-    workers_per_gpu=2,
-    train=dict(
+train_dataloader = dict(
+    batch_size=2,
+    num_workers=2,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='leftImg8bit/train',
-        ann_dir='gtFine/train',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='leftImg8bit/val',
-        ann_dir='gtFine/val',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='leftImg8bit/val',
-        ann_dir='gtFine/val',
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/cityscapes_1024x1024.py

@@ -5,31 +5,18 @@ crop_size = (1024, 1024)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 1024), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 1024),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/cityscapes_768x768.py

@@ -5,31 +5,18 @@ crop_size = (768, 768)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2049, 1025), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2049, 1025),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2049, 1025), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/cityscapes_769x769.py

@@ -5,31 +5,18 @@ crop_size = (769, 769)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2049, 1025), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2049, 1025), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2049, 1025),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2049, 1025), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/cityscapes_832x832.py

@@ -5,31 +5,18 @@ crop_size = (832, 832)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 1024), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 1024),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/coco-stuff10k.py

@@ -7,51 +7,40 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
         reduce_zero_label=True,
-        img_dir='images/train2014',
-        ann_dir='annotations/train2014',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='images/train2014', seg_map_path='annotations/train2014'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
         reduce_zero_label=True,
-        img_dir='images/test2014',
-        ann_dir='annotations/test2014',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        reduce_zero_label=True,
-        img_dir='images/test2014',
-        ann_dir='annotations/test2014',
+        data_prefix=dict(
+            img_path='images/test2014', seg_map_path='annotations/test2014'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/coco-stuff164k.py

@@ -7,48 +7,38 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/train2017',
-        ann_dir='annotations/train2017',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='images/train2017', seg_map_path='annotations/val2017'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/val2017',
-        ann_dir='annotations/val2017',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='images/val2017',
-        ann_dir='annotations/val2017',
+        data_prefix=dict(
+            img_path='images/val2017', seg_map_path='annotations/val2017'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/drive.py

@@ -8,52 +8,41 @@ crop_size = (64, 64)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=img_scale, ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=img_scale,
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
-        type='RepeatDataset',
-        times=40000,
-        dataset=dict(
-            type=dataset_type,
-            data_root=data_root,
-            img_dir='images/training',
-            ann_dir='annotations/training',
-            pipeline=train_pipeline)),
-    val=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    type='RepeatDataset',
+    times=40000,
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
-        pipeline=test_pipeline),
-    test=dict(
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/hrf.py

@@ -8,52 +8,41 @@ crop_size = (256, 256)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=img_scale, ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=img_scale,
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
-        type='RepeatDataset',
-        times=40000,
-        dataset=dict(
-            type=dataset_type,
-            data_root=data_root,
-            img_dir='images/training',
-            ann_dir='annotations/training',
-            pipeline=train_pipeline)),
-    val=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    type='RepeatDataset',
+    times=40000,
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
-        pipeline=test_pipeline),
-    test=dict(
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/isaid.py

@@ -15,48 +15,37 @@ crop_size = (896, 896)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(896, 896), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(896, 896), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(896, 896),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(896, 896), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/train',
-        ann_dir='ann_dir/train',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/loveda.py

@@ -7,48 +7,37 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1024, 1024),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(1024, 1024), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/train',
-        ann_dir='ann_dir/train',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/pascal_context.py

@@ -10,51 +10,40 @@ crop_size = (480, 480)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=img_scale, ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=img_scale,
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClassContext',
-        split='ImageSets/SegmentationContext/train.txt',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/train.txt',
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClassContext',
-        split='ImageSets/SegmentationContext/val.txt',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClassContext',
-        split='ImageSets/SegmentationContext/val.txt',
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/val.txt',
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/pascal_context_59.py

@@ -10,51 +10,40 @@ crop_size = (480, 480)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=img_scale, ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=img_scale,
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClassContext',
-        split='ImageSets/SegmentationContext/train.txt',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/train.txt',
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClassContext',
-        split='ImageSets/SegmentationContext/val.txt',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClassContext',
-        split='ImageSets/SegmentationContext/val.txt',
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClassContext'),
+        ann_file='ImageSets/SegmentationContext/val.txt',
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/pascal_voc12.py

@@ -7,51 +7,40 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClass',
-        split='ImageSets/Segmentation/train.txt',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClass'),
+        ann_file='ImageSets/Segmentation/train.txt',
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClass',
-        split='ImageSets/Segmentation/val.txt',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='JPEGImages',
-        ann_dir='SegmentationClass',
-        split='ImageSets/Segmentation/val.txt',
+        data_prefix=dict(
+            img_path='JPEGImages', seg_map_path='SegmentationClass'),
+        ann_file='ImageSets/Segmentation/val.txt',
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/pascal_voc12_aug.py

@@ -1,9 +1,9 @@
 _base_ = './pascal_voc12.py'
 # dataset settings
-data = dict(
-    train=dict(
+train_dataloader = dict(
+    dataset=dict(
         ann_dir=['SegmentationClass', 'SegmentationClassAug'],
-        split=[
+        ann_file=[
             'ImageSets/Segmentation/train.txt',
             'ImageSets/Segmentation/aug.txt'
         ]))

configs/_base_/datasets/potsdam.py

@@ -7,48 +7,37 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(512, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(512, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(512, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(512, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/train',
-        ann_dir='ann_dir/train',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/stare.py

@@ -8,52 +8,41 @@ crop_size = (128, 128)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=img_scale, ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=img_scale,
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=img_scale, keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
-        type='RepeatDataset',
-        times=40000,
-        dataset=dict(
-            type=dataset_type,
-            data_root=data_root,
-            img_dir='images/training',
-            ann_dir='annotations/training',
-            pipeline=train_pipeline)),
-    val=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    type='RepeatDataset',
+    times=40000,
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
-        pipeline=test_pipeline),
-    test=dict(
+        data_prefix=dict(
+            img_path='images/training', seg_map_path='annotations/training'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='images/validation',
-        ann_dir='annotations/validation',
+        data_prefix=dict(
+            img_path='images/validation',
+            seg_map_path='annotations/validation'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/_base_/datasets/vaihingen.py

@@ -7,48 +7,37 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(512, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(512, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(512, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(512, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-    train=dict(
+train_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=True),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/train',
-        ann_dir='ann_dir/train',
-        pipeline=train_pipeline),
-    val=dict(
+        data_prefix=dict(
+            img_path='img_dir/train', seg_map_path='ann_dir/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=4,
+    num_workers=4,
+    persistent_workers=True,
+    sampler=dict(type='DefaultSampler', shuffle=False),
+    dataset=dict(
         type=dataset_type,
         data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='img_dir/val',
-        ann_dir='ann_dir/val',
+        data_prefix=dict(img_path='img_dir/val', seg_map_path='ann_dir/val'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/beit/upernet_beit-base_640x640_160k_ade20k_ms.py

@@ -5,20 +5,12 @@ img_norm_cfg = dict(
 
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2560, 640),
-        img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=True,
-        transforms=[
-            dict(type='Resize', keep_ratio=True, min_size=640),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    # TODO: Refactor 'MultiScaleFlipAug' which supports
+    # `min_size` feature in `Resize` class
+    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+    # original image scale is (2560, 640)
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    dict(type='PackSegInputs'),
 ]
-data = dict(
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline),
-    samples_per_gpu=2)
+val_dataloader = dict(batch_size=2, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/beit/upernet_beit-base_8x2_640x640_160k_ade20k.py

@@ -27,4 +27,6 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/beit/upernet_beit-large_fp16_640x640_160k_ade20k_ms.py

@@ -5,18 +5,12 @@ img_norm_cfg = dict(
 
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2560, 640),
-        img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=True,
-        transforms=[
-            dict(type='Resize', keep_ratio=True, min_size=640),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    # TODO: Refactor 'MultiScaleFlipAug' which supports
+    # `min_size` feature in `Resize` class
+    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+    # original image scale is (2560, 640)
+    dict(type='Resize', scale=(2560, 640), keep_ratio=True),
+    dict(type='PackSegInputs'),
 ]
-data = dict(
-    val=dict(pipeline=test_pipeline), test=dict(pipeline=test_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/beit/upernet_beit-large_fp16_8x1_640x640_160k_ade20k.py

@@ -40,7 +40,9 @@ lr_config = dict(
     min_lr=0.0,
     by_epoch=False)
 
-data = dict(samples_per_gpu=1)
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader
 optimizer_config = dict(
     type='GradientCumulativeFp16OptimizerHook', cumulative_iters=2)
 

configs/bisenetv1/bisenetv1_r18-d32_4x4_1024x1024_160k_cityscapes.py

@@ -5,7 +5,6 @@ _base_ = [
 ]
 lr_config = dict(warmup='linear', warmup_iters=1000)
 optimizer = dict(lr=0.025)
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes.py

@@ -10,7 +10,6 @@ model = dict(
                 type='Pretrained', checkpoint='open-mmlab://resnet18_v1c'))))
 lr_config = dict(warmup='linear', warmup_iters=1000)
 optimizer = dict(lr=0.025)
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/bisenetv1/bisenetv1_r18-d32_in1k-pre_4x8_1024x1024_160k_cityscapes.py

@@ -1,5 +1,4 @@
 _base_ = './bisenetv1_r18-d32_in1k-pre_4x4_1024x1024_160k_cityscapes.py'
-data = dict(
-    samples_per_gpu=8,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=8, num_workers=4)
+val_dataloader = dict(batch_size=8, num_workers=4)
+test_dataloader = val_dataloader

configs/bisenetv1/bisenetv1_r50-d32_4x4_1024x1024_160k_cityscapes.py

@@ -36,7 +36,6 @@ model = dict(
     ])
 lr_config = dict(warmup='linear', warmup_iters=1000)
 optimizer = dict(lr=0.05)
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/bisenetv2/bisenetv2_fcn_4x4_1024x1024_160k_cityscapes.py

@@ -5,7 +5,6 @@ _base_ = [
 ]
 lr_config = dict(warmup='linear', warmup_iters=1000)
 optimizer = dict(lr=0.05)
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/bisenetv2/bisenetv2_fcn_4x8_1024x1024_160k_cityscapes.py

@@ -5,7 +5,6 @@ _base_ = [
 ]
 lr_config = dict(warmup='linear', warmup_iters=1000)
 optimizer = dict(lr=0.05)
-data = dict(
-    samples_per_gpu=8,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=8, num_workers=4)
+val_dataloader = dict(batch_size=8, num_workers=4)
+test_dataloader = val_dataloader

configs/bisenetv2/bisenetv2_fcn_ohem_4x4_1024x1024_160k_cityscapes.py

@@ -6,7 +6,6 @@ _base_ = [
 sampler = dict(type='OHEMPixelSampler', thresh=0.7, min_kept=10000)
 lr_config = dict(warmup='linear', warmup_iters=1000)
 optimizer = dict(lr=0.05)
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/cgnet/cgnet_512x1024_60k_cityscapes.py

@@ -19,48 +19,30 @@ crop_size = (512, 1024)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 1024), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
-    dict(type='RandomFlip', flip_ratio=0.5),
+    dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 1024),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=8,
-    workers_per_gpu=4,
-    train=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='leftImg8bit/train',
-        ann_dir='gtFine/train',
-        pipeline=train_pipeline),
-    val=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='leftImg8bit/val',
-        ann_dir='gtFine/val',
-        pipeline=test_pipeline),
-    test=dict(
-        type=dataset_type,
-        data_root=data_root,
-        img_dir='leftImg8bit/val',
-        ann_dir='gtFine/val',
+train_dataloader = dict(
+    batch_size=8,
+    num_workers=4,
+    dataset=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/train', seg_map_path='gtFine/train'),
+        pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=8,
+    num_workers=4,
+    dataset=dict(
+        data_prefix=dict(
+            img_path='leftImg8bit/val', seg_map_path='gtFine/val'),
         pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/cgnet/cgnet_680x680_60k_cityscapes.py

@@ -19,32 +19,19 @@ crop_size = (680, 680)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations'),
-    dict(type='Resize', img_scale=(2048, 1024), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 1024), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size),
-    dict(type='RandomFlip', flip_ratio=0.5),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='RandomFlip', prob=0.5),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 1024),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 1024), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    samples_per_gpu=8,
-    workers_per_gpu=4,
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+train_dataloader = dict(
+    batch_size=8, num_workers=4, dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(
+    batch_size=8, num_workers=4, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/convnext/upernet_convnext_base_fp16_512x512_160k_ade20k.py

@@ -33,7 +33,9 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader
 # fp16 settings
 optimizer_config = dict(type='Fp16OptimizerHook', loss_scale='dynamic')
 # fp16 placeholder

configs/convnext/upernet_convnext_base_fp16_640x640_160k_ade20k.py

@@ -48,7 +48,9 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader
 # fp16 settings
 optimizer_config = dict(type='Fp16OptimizerHook', loss_scale='dynamic')
 # fp16 placeholder

configs/convnext/upernet_convnext_large_fp16_640x640_160k_ade20k.py

@@ -48,7 +48,9 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader
 # fp16 settings
 optimizer_config = dict(type='Fp16OptimizerHook', loss_scale='dynamic')
 # fp16 placeholder

configs/convnext/upernet_convnext_small_fp16_512x512_160k_ade20k.py

@@ -47,7 +47,9 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader
 # fp16 settings
 optimizer_config = dict(type='Fp16OptimizerHook', loss_scale='dynamic')
 # fp16 placeholder

configs/convnext/upernet_convnext_tiny_fp16_512x512_160k_ade20k.py

@@ -47,7 +47,9 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader
 # fp16 settings
 optimizer_config = dict(type='Fp16OptimizerHook', loss_scale='dynamic')
 # fp16 placeholder

configs/convnext/upernet_convnext_xlarge_fp16_640x640_160k_ade20k.py

@@ -48,7 +48,9 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader
 # fp16 settings
 optimizer_config = dict(type='Fp16OptimizerHook', loss_scale='dynamic')
 # fp16 placeholder

configs/dpt/dpt_vit-b16_512x512_160k_ade20k.py

@@ -29,4 +29,6 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/erfnet/erfnet_fcn_4x4_512x1024_160k_cityscapes.py

@@ -2,7 +2,6 @@ _base_ = [
     '../_base_/models/erfnet_fcn.py', '../_base_/datasets/cityscapes.py',
     '../_base_/default_runtime.py', '../_base_/schedules/schedule_160k.py'
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/fastfcn/fastfcn_r50-d32_jpu_aspp_4x4_512x1024_80k_cityscapes.py

@@ -1,6 +1,5 @@
 # model settings
 _base_ = './fastfcn_r50-d32_jpu_aspp_512x1024_80k_cityscapes.py'
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/fastfcn/fastfcn_r50-d32_jpu_enc_4x4_512x1024_80k_cityscapes.py

@@ -1,6 +1,5 @@
 # model settings
 _base_ = './fastfcn_r50-d32_jpu_enc_512x1024_80k_cityscapes.py'
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/fastfcn/fastfcn_r50-d32_jpu_psp_4x4_512x1024_80k_cityscapes.py

@@ -3,7 +3,6 @@ _base_ = [
     '../_base_/datasets/cityscapes.py', '../_base_/default_runtime.py',
     '../_base_/schedules/schedule_80k.py'
 ]
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/fastscnn/fast_scnn_lr0.12_8x4_160k_cityscapes.py

@@ -4,7 +4,9 @@ _base_ = [
 ]
 
 # Re-config the data sampler.
-data = dict(samples_per_gpu=4, workers_per_gpu=4)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader
 
 # Re-config the optimizer.
 optimizer = dict(type='SGD', lr=0.12, momentum=0.9, weight_decay=4e-5)

configs/knet/knet_s3_deeplabv3_r50-d8_8x2_512x512_adamw_80k_ade20k.py

@@ -90,4 +90,6 @@ lr_config = dict(
     step=[60000, 72000],
     by_epoch=False)
 # In K-Net implementation we use batch size 2 per GPU as default
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/knet/knet_s3_fcn_r50-d8_8x2_512x512_adamw_80k_ade20k.py

@@ -90,4 +90,6 @@ lr_config = dict(
     step=[60000, 72000],
     by_epoch=False)
 # In K-Net implementation we use batch size 2 per GPU as default
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/knet/knet_s3_pspnet_r50-d8_8x2_512x512_adamw_80k_ade20k.py

@@ -89,4 +89,6 @@ lr_config = dict(
     step=[60000, 72000],
     by_epoch=False)
 # In K-Net implementation we use batch size 2 per GPU as default
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/knet/knet_s3_upernet_r50-d8_8x2_512x512_adamw_80k_ade20k.py

@@ -90,4 +90,6 @@ lr_config = dict(
     step=[60000, 72000],
     by_epoch=False)
 # In K-Net implementation we use batch size 2 per GPU as default
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/knet/knet_s3_upernet_swin-l_8x2_512x512_adamw_80k_ade20k.py

@@ -16,4 +16,6 @@ model = dict(
         kernel_generate_head=dict(in_channels=[192, 384, 768, 1536])),
     auxiliary_head=dict(in_channels=768))
 # In K-Net implementation we use batch size 2 per GPU as default
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/knet/knet_s3_upernet_swin-l_8x2_640x640_adamw_80k_ade20k.py

@@ -22,33 +22,22 @@ crop_size = (640, 640)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 640), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 640), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 640),
-        #         img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 640), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
 # In K-Net implementation we use batch size 2 per GPU as default
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/knet/knet_s3_upernet_swin-t_8x2_512x512_adamw_80k_ade20k.py

@@ -54,4 +54,6 @@ lr_config = dict(
     step=[60000, 72000],
     by_epoch=False)
 # In K-Net implementation we use batch size 2 per GPU as default
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/mae/upernet_mae-base_fp16_512x512_160k_ade20k_ms.py

@@ -5,20 +5,12 @@ img_norm_cfg = dict(
 
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=True,
-        transforms=[
-            dict(type='Resize', keep_ratio=True, min_size=512),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    # TODO: Refactor 'MultiScaleFlipAug' which supports
+    # `min_size` feature in `Resize` class
+    # img_ratios is [0.5, 0.75, 1.0, 1.25, 1.5, 1.75]
+    # original image scale is (2048, 512)
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline),
-    samples_per_gpu=2)
+val_dataloader = dict(batch_size=2, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/mae/upernet_mae-base_fp16_8x2_512x512_160k_ade20k.py

@@ -45,4 +45,6 @@ lr_config = dict(
 fp16 = dict(loss_scale='dynamic')
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/mobilenet_v3/lraspp_m-v3-d8_512x1024_320k_cityscapes.py

@@ -6,6 +6,8 @@ _base_ = [
 model = dict(pretrained='open-mmlab://contrib/mobilenet_v3_large')
 
 # Re-config the data sampler.
-data = dict(samples_per_gpu=4, workers_per_gpu=4)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader
 
 runner = dict(type='IterBasedRunner', max_iters=320000)

configs/mobilenet_v3/lraspp_m-v3-d8_scratch_512x1024_320k_cityscapes.py

@@ -4,6 +4,8 @@ _base_ = [
 ]
 
 # Re-config the data sampler.
-data = dict(samples_per_gpu=4, workers_per_gpu=4)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader
 
 runner = dict(type='IterBasedRunner', max_iters=320000)

configs/pspnet/pspnet_r50-d8_512x1024_40k_dark.py

@@ -6,24 +6,14 @@ img_norm_cfg = dict(
     mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1920, 1080),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-
-data = dict(
-    test=dict(
+test_dataloader = dict(
+    dataset=dict(
         type='DarkZurichDataset',
         data_root='data/dark_zurich/',
-        img_dir='rgb_anon/val/night/GOPR0356',
-        ann_dir='gt/val/night/GOPR0356',
+        data_prefix=dict(
+            img_path='rgb_anon/val/night/GOPR0356',
+            seg_map_path='gt/val/night/GOPR0356'),
         pipeline=test_pipeline))

configs/pspnet/pspnet_r50-d8_512x1024_40k_night_driving.py

@@ -7,23 +7,14 @@ img_norm_cfg = dict(
     mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1920, 1080),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    test=dict(
+test_dataloader = dict(
+    dataset=dict(
         type='NightDrivingDataset',
         data_root='data/NighttimeDrivingTest/',
-        img_dir='leftImg8bit/test/night',
-        ann_dir='gtCoarse_daytime_trainvaltest/test/night',
+        data_prefix=dict(
+            img_path='leftImg8bit/test/night',
+            seg_map_path='gtCoarse_daytime_trainvaltest/test/night'),
         pipeline=test_pipeline))

configs/pspnet/pspnet_r50-d8_512x1024_80k_dark.py

@@ -7,24 +7,14 @@ img_norm_cfg = dict(
     mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1920, 1080),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-
-data = dict(
-    test=dict(
+test_dataloader = dict(
+    dataset=dict(
         type='DarkZurichDataset',
         data_root='data/dark_zurich/',
-        img_dir='rgb_anon/val/night/GOPR0356',
-        ann_dir='gt/val/night/GOPR0356',
+        data_prefix=dict(
+            img_path='rgb_anon/val/night/GOPR0356',
+            seg_map_path='gt/val/night/GOPR0356'),
         pipeline=test_pipeline))

configs/pspnet/pspnet_r50-d8_512x1024_80k_night_driving.py

@@ -7,23 +7,14 @@ img_norm_cfg = dict(
     mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(1920, 1080),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(1920, 1080), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    test=dict(
+test_dataloader = dict(
+    dataset=dict(
         type='NightDrivingDataset',
         data_root='data/NighttimeDrivingTest/',
-        img_dir='leftImg8bit/test/night',
-        ann_dir='gtCoarse_daytime_trainvaltest/test/night',
+        data_prefix=dict(
+            img_path='leftImg8bit/test/night',
+            seg_map_path='gtCoarse_daytime_trainvaltest/test/night'),
         pipeline=test_pipeline))

configs/segformer/segformer_mit-b0_512x512_160k_ade20k.py

@@ -29,5 +29,6 @@ lr_config = dict(
     power=1.0,
     min_lr=0.0,
     by_epoch=False)
-
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/segformer/segformer_mit-b0_8x1_1024x1024_160k_cityscapes.py

@@ -32,5 +32,6 @@ lr_config = dict(
     power=1.0,
     min_lr=0.0,
     by_epoch=False)
-
-data = dict(samples_per_gpu=1, workers_per_gpu=1)
+train_dataloader = dict(batch_size=1, num_workers=1)
+val_dataloader = dict(batch_size=1, num_workers=1)
+test_dataloader = val_dataloader

configs/segformer/segformer_mit-b5_640x640_160k_ade20k.py

@@ -7,34 +7,21 @@ crop_size = (640, 640)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 640), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 640), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg']),
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 640),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img']),
-        ])
+    dict(type='Resize', scale=(2048, 640), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+train_dataloader = dict(dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader
 
 # model settings
 model = dict(

configs/segmenter/segmenter_vit-b_mask_8x1_512x512_160k_ade20k.py

@@ -11,33 +11,21 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
+train_dataloader = dict(
     # num_gpus: 8 -> batch_size: 8
-    samples_per_gpu=1,
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+    batch_size=1,
+    dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/segmenter/segmenter_vit-l_mask_8x1_512x512_160k_ade20k.py

@@ -29,33 +29,21 @@ crop_size = (640, 640)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 640), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 640), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 640),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=(2048, 640), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
+train_dataloader = dict(
     # num_gpus: 8 -> batch_size: 8
-    samples_per_gpu=1,
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+    batch_size=1,
+    dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/segmenter/segmenter_vit-s_mask_8x1_512x512_160k_ade20k.py

@@ -34,33 +34,21 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
+train_dataloader = dict(
     # num_gpus: 8 -> batch_size: 8
-    samples_per_gpu=1,
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+    batch_size=1,
+    dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/segmenter/segmenter_vit-t_mask_8x1_512x512_160k_ade20k.py

@@ -24,33 +24,21 @@ crop_size = (512, 512)
 train_pipeline = [
     dict(type='LoadImageFromFile'),
     dict(type='LoadAnnotations', reduce_zero_label=True),
-    dict(type='Resize', img_scale=(2048, 512), ratio_range=(0.5, 2.0)),
+    dict(type='RandomResize', scale=(2048, 512), ratio_range=(0.5, 2.0)),
     dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
     dict(type='RandomFlip', prob=0.5),
     dict(type='PhotoMetricDistortion'),
-    dict(type='Normalize', **img_norm_cfg),
-    dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
-    dict(type='DefaultFormatBundle'),
-    dict(type='Collect', keys=['img', 'gt_semantic_seg'])
+    dict(type='Pad', size=crop_size),
+    dict(type='PackSegInputs')
 ]
 test_pipeline = [
     dict(type='LoadImageFromFile'),
-    dict(
-        type='MultiScaleFlipAug',
-        img_scale=(2048, 512),
-        # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75],
-        flip=False,
-        transforms=[
-            dict(type='Resize', keep_ratio=True),
-            dict(type='RandomFlip'),
-            dict(type='Normalize', **img_norm_cfg),
-            dict(type='ImageToTensor', keys=['img']),
-            dict(type='Collect', keys=['img'])
-        ])
+    dict(type='Resize', scale=(2048, 512), keep_ratio=True),
+    dict(type='PackSegInputs')
 ]
-data = dict(
+train_dataloader = dict(
     # num_gpus: 8 -> batch_size: 8
-    samples_per_gpu=1,
-    train=dict(pipeline=train_pipeline),
-    val=dict(pipeline=test_pipeline),
-    test=dict(pipeline=test_pipeline))
+    batch_size=1,
+    dataset=dict(pipeline=train_pipeline))
+val_dataloader = dict(batch_size=1, dataset=dict(pipeline=test_pipeline))
+test_dataloader = val_dataloader

configs/setr/setr_mla_512x512_160k_b16_ade20k.py

@@ -1,4 +1,6 @@
 _base_ = ['./setr_mla_512x512_160k_b8_ade20k.py']
 
 # num_gpus: 8 -> batch_size: 16
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/setr/setr_mla_512x512_160k_b8_ade20k.py

@@ -82,4 +82,6 @@ optimizer = dict(
     paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
 
 # num_gpus: 8 -> batch_size: 8
-data = dict(samples_per_gpu=1)
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader

configs/setr/setr_naive_512x512_160k_b16_ade20k.py

@@ -64,4 +64,6 @@ optimizer = dict(
     paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
 
 # num_gpus: 8 -> batch_size: 16
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/setr/setr_pup_512x512_160k_b16_ade20k.py

@@ -64,4 +64,6 @@ optimizer = dict(
     paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
 
 # num_gpus: 8 -> batch_size: 16
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/setr/setr_vit-large_mla_8x1_768x768_80k_cityscapes.py

@@ -14,4 +14,6 @@ optimizer = dict(
     lr=0.002,
     weight_decay=0.0,
     paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
-data = dict(samples_per_gpu=1)
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader

configs/setr/setr_vit-large_naive_8x1_768x768_80k_cityscapes.py

@@ -15,4 +15,6 @@ optimizer = dict(
     weight_decay=0.0,
     paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
 
-data = dict(samples_per_gpu=1)
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader

configs/setr/setr_vit-large_pup_8x1_768x768_80k_cityscapes.py

@@ -61,4 +61,6 @@ optimizer = dict(
     weight_decay=0.0,
     paramwise_cfg=dict(custom_keys={'head': dict(lr_mult=10.)}))
 
-data = dict(samples_per_gpu=1)
+train_dataloader = dict(batch_size=1)
+val_dataloader = dict(batch_size=1)
+test_dataloader = val_dataloader

configs/stdc/stdc1_512x1024_80k_cityscapes.py

@@ -3,7 +3,6 @@ _base_ = [
     '../_base_/default_runtime.py', '../_base_/schedules/schedule_80k.py'
 ]
 lr_config = dict(warmup='linear', warmup_iters=1000)
-data = dict(
-    samples_per_gpu=12,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=12, num_workers=4)
+val_dataloader = dict(batch_size=12, num_workers=4)
+test_dataloader = val_dataloader

configs/swin/upernet_swin_tiny_patch4_window7_512x512_160k_ade20k_pretrain_224x224_1K.py

@@ -42,4 +42,6 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/twins/twins_pcpvt-b_uperhead_8x2_512x512_160k_ade20k.py

@@ -8,4 +8,6 @@ model = dict(
         depths=[3, 4, 18, 3],
         drop_path_rate=0.3))
 
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/twins/twins_pcpvt-l_uperhead_8x2_512x512_160k_ade20k.py

@@ -8,4 +8,6 @@ model = dict(
         depths=[3, 8, 27, 3],
         drop_path_rate=0.3))
 
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/twins/twins_svt-s_uperhead_8x2_512x512_160k_ade20k.py

@@ -40,4 +40,6 @@ lr_config = dict(
     min_lr=0.0,
     by_epoch=False)
 
-data = dict(samples_per_gpu=2, workers_per_gpu=2)
+train_dataloader = dict(batch_size=2, num_workers=2)
+val_dataloader = dict(batch_size=2, num_workers=2)
+test_dataloader = val_dataloader

configs/unet/fcn_unet_s5-d16_4x4_512x1024_160k_cityscapes.py

@@ -9,8 +9,6 @@ model = dict(
     # model training and testing settings
     train_cfg=dict(),
     test_cfg=dict(mode='whole'))
-
-data = dict(
-    samples_per_gpu=4,
-    workers_per_gpu=4,
-)
+train_dataloader = dict(batch_size=4, num_workers=4)
+val_dataloader = dict(batch_size=4, num_workers=4)
+test_dataloader = val_dataloader

configs/vit/upernet_vit-b16_ln_mln_512x512_160k_ade20k.py

@@ -36,4 +36,6 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/vit/upernet_vit-b16_mln_512x512_160k_ade20k.py

@@ -35,4 +35,6 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

configs/vit/upernet_vit-b16_mln_512x512_80k_ade20k.py

@@ -35,4 +35,6 @@ lr_config = dict(
     by_epoch=False)
 
 # By default, models are trained on 8 GPUs with 2 images per GPU
-data = dict(samples_per_gpu=2)
+train_dataloader = dict(batch_size=2)
+val_dataloader = dict(batch_size=2)
+test_dataloader = val_dataloader

mmseg/datasets/pipelines/formatting.py

@@ -16,9 +16,7 @@ class PackSegInputs(BaseTransform):
     The ``img_meta`` item is always populated.  The contents of the
     ``img_meta`` dictionary depends on ``meta_keys``. By default this includes:
 
-        - ``filename``: filename of the image
-
-        - ``ori_filename``: original filename of the image file
+        - ``img_path``: filename of the image
 
         - ``ori_shape``: original shape of the image as a tuple (h, w, c)
 
@@ -34,20 +32,17 @@ class PackSegInputs(BaseTransform):
 
         - ``flip_direction``: the flipping direction
 
-        - ``img_norm_cfg``: config of image pixel normalization
-
     Args:
         meta_keys (Sequence[str], optional): Meta keys to be packed from
             ``SegDataSample`` and collected in ``data[img_metas]``.
-            Default: ``('filename', 'ori_filename', 'ori_shape',
+            Default: ``('img_path', 'ori_shape',
             'img_shape', 'pad_shape', 'scale_factor', 'flip',
-            'flip_direction', 'img_norm_cfg')``
+            'flip_direction')``
     """
 
     def __init__(self,
-                 meta_keys=('filename', 'ori_filename', 'ori_shape',
-                            'img_shape', 'pad_shape', 'scale_factor', 'flip',
-                            'flip_direction', 'img_norm_cfg')):
+                 meta_keys=('img_path', 'ori_shape', 'img_shape', 'pad_shape',
+                            'scale_factor', 'flip', 'flip_direction')):
         self.meta_keys = meta_keys
 
     def transform(self, results: dict) -> dict:

tests/test_config.py

@@ -0,0 +1,162 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import glob
+import os
+from os.path import dirname, exists, isdir, join, relpath
+
+from mmcv import Config
+from torch import nn
+
+from mmseg.models import build_segmentor
+
+
+def _get_config_directory():
+    """Find the predefined segmentor config directory."""
+    try:
+        # Assume we are running in the source mmsegmentation repo
+        repo_dpath = dirname(dirname(__file__))
+    except NameError:
+        # For IPython development when this __file__ is not defined
+        import mmseg
+        repo_dpath = dirname(dirname(mmseg.__file__))
+    config_dpath = join(repo_dpath, 'configs')
+    if not exists(config_dpath):
+        raise Exception('Cannot find config path')
+    return config_dpath
+
+
+def test_config_build_segmentor():
+    """Test that all segmentation models defined in the configs can be
+    initialized."""
+    config_dpath = _get_config_directory()
+    print('Found config_dpath = {!r}'.format(config_dpath))
+
+    config_fpaths = []
+    # one config each sub folder
+    for sub_folder in os.listdir(config_dpath):
+        if isdir(sub_folder):
+            config_fpaths.append(
+                list(glob.glob(join(config_dpath, sub_folder, '*.py')))[0])
+    config_fpaths = [p for p in config_fpaths if p.find('_base_') == -1]
+    config_names = [relpath(p, config_dpath) for p in config_fpaths]
+
+    print('Using {} config files'.format(len(config_names)))
+
+    for config_fname in config_names:
+        config_fpath = join(config_dpath, config_fname)
+        config_mod = Config.fromfile(config_fpath)
+
+        config_mod.model
+        print('Building segmentor, config_fpath = {!r}'.format(config_fpath))
+
+        # Remove pretrained keys to allow for testing in an offline environment
+        if 'pretrained' in config_mod.model:
+            config_mod.model['pretrained'] = None
+
+        print('building {}'.format(config_fname))
+        segmentor = build_segmentor(config_mod.model)
+        assert segmentor is not None
+
+        head_config = config_mod.model['decode_head']
+        _check_decode_head(head_config, segmentor.decode_head)
+
+
+def test_config_data_pipeline():
+    """Test whether the data pipeline is valid and can process corner cases.
+
+    CommandLine:
+        xdoctest -m tests/test_config.py test_config_build_data_pipeline
+    """
+    import numpy as np
+    from mmcv import Config
+
+    from mmseg.datasets.pipelines import Compose
+
+    config_dpath = _get_config_directory()
+    print('Found config_dpath = {!r}'.format(config_dpath))
+
+    import glob
+    config_fpaths = list(glob.glob(join(config_dpath, '**', '*.py')))
+    config_fpaths = [p for p in config_fpaths if p.find('_base_') == -1]
+    config_names = [relpath(p, config_dpath) for p in config_fpaths]
+
+    print('Using {} config files'.format(len(config_names)))
+
+    for config_fname in config_names:
+        config_fpath = join(config_dpath, config_fname)
+        print(
+            'Building data pipeline, config_fpath = {!r}'.format(config_fpath))
+        config_mod = Config.fromfile(config_fpath)
+
+        # remove loading pipeline
+        load_img_pipeline = config_mod.train_pipeline.pop(0)
+        to_float32 = load_img_pipeline.get('to_float32', False)
+        config_mod.train_pipeline.pop(0)
+        config_mod.test_pipeline.pop(0)
+
+        train_pipeline = Compose(config_mod.train_pipeline)
+        test_pipeline = Compose(config_mod.test_pipeline)
+
+        img = np.random.randint(0, 255, size=(1024, 2048, 3), dtype=np.uint8)
+        if to_float32:
+            img = img.astype(np.float32)
+        seg = np.random.randint(0, 255, size=(1024, 2048, 1), dtype=np.uint8)
+
+        results = dict(
+            filename='test_img.png',
+            ori_filename='test_img.png',
+            img=img,
+            img_shape=img.shape,
+            ori_shape=img.shape,
+            gt_seg_map=seg)
+        results['seg_fields'] = ['gt_seg_map']
+
+        print('Test training data pipeline: \n{!r}'.format(train_pipeline))
+        output_results = train_pipeline(results)
+        assert output_results is not None
+
+        results = dict(
+            filename='test_img.png',
+            ori_filename='test_img.png',
+            img=img,
+            img_shape=img.shape,
+            ori_shape=img.shape,
+        )
+        print('Test testing data pipeline: \n{!r}'.format(test_pipeline))
+        output_results = test_pipeline(results)
+        assert output_results is not None
+
+
+def _check_decode_head(decode_head_cfg, decode_head):
+    if isinstance(decode_head_cfg, list):
+        assert isinstance(decode_head, nn.ModuleList)
+        assert len(decode_head_cfg) == len(decode_head)
+        num_heads = len(decode_head)
+        for i in range(num_heads):
+            _check_decode_head(decode_head_cfg[i], decode_head[i])
+        return
+    # check consistency between head_config and roi_head
+    assert decode_head_cfg['type'] == decode_head.__class__.__name__
+
+    assert decode_head_cfg['type'] == decode_head.__class__.__name__
+
+    in_channels = decode_head_cfg.in_channels
+    input_transform = decode_head.input_transform
+    assert input_transform in ['resize_concat', 'multiple_select', None]
+    if input_transform is not None:
+        assert isinstance(in_channels, (list, tuple))
+        assert isinstance(decode_head.in_index, (list, tuple))
+        assert len(in_channels) == len(decode_head.in_index)
+    elif input_transform == 'resize_concat':
+        assert sum(in_channels) == decode_head.in_channels
+    else:
+        assert isinstance(in_channels, int)
+        assert in_channels == decode_head.in_channels
+        assert isinstance(decode_head.in_index, int)
+
+    if decode_head_cfg['type'] == 'PointHead':
+        assert decode_head_cfg.channels+decode_head_cfg.num_classes == \
+               decode_head.fc_seg.in_channels
+        assert decode_head.fc_seg.out_channels == decode_head_cfg.num_classes
+    else:
+        assert decode_head_cfg.channels == decode_head.conv_seg.in_channels
+        assert decode_head.conv_seg.out_channels == decode_head_cfg.num_classes

tests/test_data/test_formatting.py

@@ -22,8 +22,7 @@ class TestPackSegInputs(unittest.TestCase):
         img_path = osp.join(data_prefix, 'color.jpg')
         rng = np.random.RandomState(0)
         self.results = {
-            'filename': img_path,
-            'ori_filename': 'color.jpg',
+            'img_path': img_path,
             'ori_shape': (300, 400),
             'pad_shape': (600, 800),
             'img_shape': (600, 800),
@@ -34,9 +33,8 @@ class TestPackSegInputs(unittest.TestCase):
             'img': rng.rand(300, 400),
             'gt_seg_map': rng.rand(300, 400),
         }
-        self.meta_keys = ('filename', 'ori_filename', 'ori_shape', 'img_shape',
-                          'pad_shape', 'scale_factor', 'flip',
-                          'flip_direction', 'img_norm_cfg')
+        self.meta_keys = ('img_path', 'ori_shape', 'img_shape', 'pad_shape',
+                          'scale_factor', 'flip', 'flip_direction')
 
     def test_transform(self):
         transform = PackSegInputs(meta_keys=self.meta_keys)