+
+```shell
+wget https://user-images.githubusercontent.com/24582831/189833109-eddad58f-f777-4fc0-b98a-6bd429143b06.png --output-document aachen_000000_000019_leftImg8bit.png
+wget https://user-images.githubusercontent.com/24582831/189833143-15f60f8a-4d1e-4cbb-a6e7-5e2233869fac.png --output-document aachen_000000_000019_gtFine_labelTrainIds.png
+
+wget https://download.openmmlab.com/mmsegmentation/v0.5/ann/ann_r50-d8_512x1024_40k_cityscapes/ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth
+
+```
+
+```python
+# Copyright (c) OpenMMLab. All rights reserved.
+from argparse import ArgumentParser
+from typing import Type
+
+import mmcv
+import torch
+import torch.nn as nn
+
+from mmengine.model import revert_sync_batchnorm
+from mmengine.structures import PixelData
+from mmseg.apis import inference_model, init_model
+from mmseg.structures import SegDataSample
+from mmseg.utils import register_all_modules
+from mmseg.visualization import SegLocalVisualizer
+
+
+class Recorder:
+ """record the forward output feature map and save to data_buffer."""
+
+ def __init__(self) -> None:
+ self.data_buffer = list()
+
+ def __enter__(self, ):
+ self._data_buffer = list()
+
+ def record_data_hook(self, model: nn.Module, input: Type, output: Type):
+ self.data_buffer.append(output)
+
+ def __exit__(self, *args, **kwargs):
+ pass
+
+
+def visualize(args, model, recorder, result):
+ seg_visualizer = SegLocalVisualizer(
+ vis_backends=[dict(type='WandbVisBackend')],
+ save_dir='temp_dir',
+ alpha=0.5)
+ seg_visualizer.dataset_meta = dict(
+ classes=model.dataset_meta['classes'],
+ palette=model.dataset_meta['palette'])
+
+ image = mmcv.imread(args.img, 'color')
+
+ seg_visualizer.add_datasample(
+ name='predict',
+ image=image,
+ data_sample=result,
+ draw_gt=False,
+ draw_pred=True,
+ wait_time=0,
+ out_file=None,
+ show=False)
+
+ # add feature map to wandb visualizer
+ for i in range(len(recorder.data_buffer)):
+ feature = recorder.data_buffer[i][0] # remove the batch
+ drawn_img = seg_visualizer.draw_featmap(
+ feature, image, channel_reduction='select_max')
+ seg_visualizer.add_image(f'feature_map{i}', drawn_img)
+
+ if args.gt_mask:
+ sem_seg = mmcv.imread(args.gt_mask, 'unchanged')
+ sem_seg = torch.from_numpy(sem_seg)
+ gt_mask = dict(data=sem_seg)
+ gt_mask = PixelData(**gt_mask)
+ data_sample = SegDataSample()
+ data_sample.gt_sem_seg = gt_mask
+
+ seg_visualizer.add_datasample(
+ name='gt_mask',
+ image=image,
+ data_sample=data_sample,
+ draw_gt=True,
+ draw_pred=False,
+ wait_time=0,
+ out_file=None,
+ show=False)
+
+ seg_visualizer.add_image('image', image)
+
+
+def main():
+ parser = ArgumentParser(
+ description='Draw the Feature Map During Inference')
+ parser.add_argument('img', help='Image file')
+ parser.add_argument('config', help='Config file')
+ parser.add_argument('checkpoint', help='Checkpoint file')
+ parser.add_argument('--gt_mask', default=None, help='Path of gt mask file')
+ parser.add_argument('--out-file', default=None, help='Path to output file')
+ parser.add_argument(
+ '--device', default='cuda:0', help='Device used for inference')
+ parser.add_argument(
+ '--opacity',
+ type=float,
+ default=0.5,
+ help='Opacity of painted segmentation map. In (0, 1] range.')
+ parser.add_argument(
+ '--title', default='result', help='The image identifier.')
+ args = parser.parse_args()
+
+ register_all_modules()
+
+ # build the model from a config file and a checkpoint file
+ model = init_model(args.config, args.checkpoint, device=args.device)
+ if args.device == 'cpu':
+ model = revert_sync_batchnorm(model)
+
+ # show all named module in the model and use it in source list below
+ for name, module in model.named_modules():
+ print(name)
+
+ source = [
+ 'decode_head.fusion.stages.0.query_project.activate',
+ 'decode_head.context.stages.0.key_project.activate',
+ 'decode_head.context.bottleneck.activate'
+ ]
+ source = dict.fromkeys(source)
+
+ count = 0
+ recorder = Recorder()
+ # registry the forward hook
+ for name, module in model.named_modules():
+ if name in source:
+ count += 1
+ module.register_forward_hook(recorder.record_data_hook)
+ if count == len(source):
+ break
+
+ with recorder:
+ # test a single image, and record feature map to data_buffer
+ result = inference_model(model, args.img)
+
+ visualize(args, model, recorder, result)
+
+
+if __name__ == '__main__':
+ main()
+
+```
+
+将上述代码保存为 feature_map_visual.py，在终端执行如下代码
+
+```shell
+python feature_map_visual.py ${图像} ${配置文件} ${检查点文件} [可选参数]
+```
+
+样例
+
+```shell
+python feature_map_visual.py \
+aachen_000000_000019_leftImg8bit.png \
+configs/ann/ann_r50-d8_4xb2-40k_cityscapes-512x1024.py \
+ann_r50-d8_512x1024_40k_cityscapes_20200605_095211-049fc292.pth \
+--gt_mask aachen_000000_000019_gtFine_labelTrainIds.png
+```
+
+可视化后的图像结果和它的对应的 feature map图像会出现在wandb账户中
+
+
+
+
diff --git a/mmseg/__init__.py b/mmseg/__init__.py
index 765ff4a042..9f171ccb0a 100644
--- a/mmseg/__init__.py
+++ b/mmseg/__init__.py
@@ -9,7 +9,7 @@
MMCV_MIN = '2.0.0rc4'
MMCV_MAX = '2.1.0'
-MMENGINE_MIN = '0.2.0'
+MMENGINE_MIN = '0.5.0'
MMENGINE_MAX = '1.0.0'
diff --git a/mmseg/apis/__init__.py b/mmseg/apis/__init__.py
index 9933b99b3c..d22dc3f0ad 100644
--- a/mmseg/apis/__init__.py
+++ b/mmseg/apis/__init__.py
@@ -1,4 +1,7 @@
# Copyright (c) OpenMMLab. All rights reserved.
from .inference import inference_model, init_model, show_result_pyplot
+from .mmseg_inferencer import MMSegInferencer
-__all__ = ['init_model', 'inference_model', 'show_result_pyplot']
+__all__ = [
+ 'init_model', 'inference_model', 'show_result_pyplot', 'MMSegInferencer'
+]
diff --git a/mmseg/apis/inference.py b/mmseg/apis/inference.py
index d1cc545598..4aadffc798 100644
--- a/mmseg/apis/inference.py
+++ b/mmseg/apis/inference.py
@@ -9,6 +9,7 @@
import torch
from mmengine import Config
from mmengine.dataset import Compose
+from mmengine.registry import init_default_scope
from mmengine.runner import load_checkpoint
from mmengine.utils import mkdir_or_exist
@@ -48,6 +49,8 @@ def init_model(config: Union[str, Path, Config],
config.model.backbone.init_cfg = None
config.model.pretrained = None
config.model.train_cfg = None
+ init_default_scope(config.get('default_scope', 'mmseg'))
+
model = MODELS.build(config.model)
if checkpoint is not None:
checkpoint = load_checkpoint(model, checkpoint, map_location='cpu')
diff --git a/mmseg/apis/mmseg_inferencer.py b/mmseg/apis/mmseg_inferencer.py
new file mode 100644
index 0000000000..cb387b10b3
--- /dev/null
+++ b/mmseg/apis/mmseg_inferencer.py
@@ -0,0 +1,361 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import os.path as osp
+import warnings
+from typing import List, Optional, Sequence, Union
+
+import mmcv
+import mmengine
+import numpy as np
+import torch
+import torch.nn as nn
+from mmcv.transforms import Compose
+from mmengine.infer.infer import BaseInferencer, ModelType
+from mmengine.model import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
+from mmengine.runner.checkpoint import _load_checkpoint_to_model
+from PIL import Image
+
+from mmseg.structures import SegDataSample
+from mmseg.utils import ConfigType, SampleList, get_classes, get_palette
+from mmseg.visualization import SegLocalVisualizer
+
+InputType = Union[str, np.ndarray]
+InputsType = Union[InputType, Sequence[InputType]]
+PredType = Union[SegDataSample, SampleList]
+
+
+class MMSegInferencer(BaseInferencer):
+ """Semantic segmentation inferencer, provides inference and visualization
+ interfaces. Note: MMEngine >= 0.5.0 is required.
+
+ Args:
+ model (str, optional): Path to the config file or the model name
+ defined in metafile. Take the `mmseg metafile `_
+ as an example the `model` could be
+ "fcn_r50-d8_4xb2-40k_cityscapes-512x1024", and the weights of model
+ will be download automatically. If use config file, like
+ "configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py", the
+ `weights` should be defined.
+ weights (str, optional): Path to the checkpoint. If it is not specified
+ and model is a model name of metafile, the weights will be loaded
+ from metafile. Defaults to None.
+ classes (list, optional): Input classes for result rendering, as the
+ prediction of segmentation model is a segment map with label
+ indices, `classes` is a list which includes items responding to the
+ label indices. If classes is not defined, visualizer will take
+ `cityscapes` classes by default. Defaults to None.
+ palette (list, optional): Input palette for result rendering, which is
+ a list of color palette responding to the classes. If palette is
+ not defined, visualizer will take `cityscapes` palette by default.
+ Defaults to None.
+ dataset_name (str, optional): `Dataset name or alias `_
+ visulizer will use the meta information of the dataset i.e. classes
+ and palette, but the `classes` and `palette` have higher priority.
+ Defaults to None.
+ device (str, optional): Device to run inference. If None, the available
+ device will be automatically used. Defaults to None.
+ scope (str, optional): The scope of the model. Defaults to 'mmseg'.
+ """ # noqa
+
+ preprocess_kwargs: set = set()
+ forward_kwargs: set = {'mode', 'out_dir'}
+ visualize_kwargs: set = {'show', 'wait_time', 'img_out_dir', 'opacity'}
+ postprocess_kwargs: set = {'pred_out_dir', 'return_datasample'}
+
+ def __init__(self,
+ model: Union[ModelType, str],
+ weights: Optional[str] = None,
+ classes: Optional[Union[str, List]] = None,
+ palette: Optional[Union[str, List]] = None,
+ dataset_name: Optional[str] = None,
+ device: Optional[str] = None,
+ scope: Optional[str] = 'mmseg') -> None:
+ # A global counter tracking the number of images processes, for
+ # naming of the output images
+ self.num_visualized_imgs = 0
+ self.num_pred_imgs = 0
+ init_default_scope(scope if scope else 'mmseg')
+ super().__init__(
+ model=model, weights=weights, device=device, scope=scope)
+
+ if device == 'cpu' or not torch.cuda.is_available():
+ self.model = revert_sync_batchnorm(self.model)
+
+ assert isinstance(self.visualizer, SegLocalVisualizer)
+ self.visualizer.set_dataset_meta(palette, classes, dataset_name)
+
+ def _load_weights_to_model(self, model: nn.Module,
+ checkpoint: Optional[dict],
+ cfg: Optional[ConfigType]) -> None:
+ """Loading model weights and meta information from cfg and checkpoint.
+
+ Subclasses could override this method to load extra meta information
+ from ``checkpoint`` and ``cfg`` to model.
+
+ Args:
+ model (nn.Module): Model to load weights and meta information.
+ checkpoint (dict, optional): The loaded checkpoint.
+ cfg (Config or ConfigDict, optional): The loaded config.
+ """
+
+ if checkpoint is not None:
+ _load_checkpoint_to_model(model, checkpoint)
+ checkpoint_meta = checkpoint.get('meta', {})
+ # save the dataset_meta in the model for convenience
+ if 'dataset_meta' in checkpoint_meta:
+ # mmsegmentation 1.x
+ model.dataset_meta = {
+ 'classes': checkpoint_meta['dataset_meta'].get('classes'),
+ 'palette': checkpoint_meta['dataset_meta'].get('palette')
+ }
+ elif 'CLASSES' in checkpoint_meta:
+ # mmsegmentation 0.x
+ classes = checkpoint_meta['CLASSES']
+ palette = checkpoint_meta.get('PALETTE', None)
+ model.dataset_meta = {'classes': classes, 'palette': palette}
+ else:
+ warnings.warn(
+ 'dataset_meta or class names are not saved in the '
+ 'checkpoint\'s meta data, use classes of Cityscapes by '
+ 'default.')
+ model.dataset_meta = {
+ 'classes': get_classes('cityscapes'),
+ 'palette': get_palette('cityscapes')
+ }
+ else:
+ warnings.warn('Checkpoint is not loaded, and the inference '
+ 'result is calculated by the randomly initialized '
+ 'model!')
+ warnings.warn(
+ 'weights is None, use cityscapes classes by default.')
+ model.dataset_meta = {
+ 'classes': get_classes('cityscapes'),
+ 'palette': get_palette('cityscapes')
+ }
+
+ def __call__(self,
+ inputs: InputsType,
+ return_datasamples: bool = False,
+ batch_size: int = 1,
+ show: bool = False,
+ wait_time: int = 0,
+ out_dir: str = '',
+ img_out_dir: str = 'vis',
+ pred_out_dir: str = 'pred',
+ **kwargs) -> dict:
+ """Call the inferencer.
+
+ Args:
+ inputs (Union[list, str, np.ndarray]): Inputs for the inferencer.
+ return_datasamples (bool): Whether to return results as
+ :obj:`SegDataSample`. Defaults to False.
+ batch_size (int): Batch size. Defaults to 1.
+ show (bool): Whether to display the rendering color segmentation
+ mask in a popup window. Defaults to False.
+ wait_time (float): The interval of show (s). Defaults to 0.
+ out_dir (str): Output directory of inference results. Defaults
+ to ''.
+ img_out_dir (str): Subdirectory of `out_dir`, used to save
+ rendering color segmentation mask, so `out_dir` must be defined
+ if you would like to save predicted mask. Defaults to 'vis'.
+ pred_out_dir (str): Subdirectory of `out_dir`, used to save
+ predicted mask file, so `out_dir` must be defined if you would
+ like to save predicted mask. Defaults to 'pred'.
+
+ **kwargs: Other keyword arguments passed to :meth:`preprocess`,
+ :meth:`forward`, :meth:`visualize` and :meth:`postprocess`.
+ Each key in kwargs should be in the corresponding set of
+ ``preprocess_kwargs``, ``forward_kwargs``, ``visualize_kwargs``
+ and ``postprocess_kwargs``.
+
+
+ Returns:
+ dict: Inference and visualization results.
+ """
+
+ if out_dir != '':
+ pred_out_dir = osp.join(out_dir, pred_out_dir)
+ img_out_dir = osp.join(out_dir, img_out_dir)
+ else:
+ pred_out_dir = ''
+ img_out_dir = ''
+
+ return super().__call__(
+ inputs=inputs,
+ return_datasamples=return_datasamples,
+ batch_size=batch_size,
+ show=show,
+ wait_time=wait_time,
+ img_out_dir=img_out_dir,
+ pred_out_dir=pred_out_dir,
+ **kwargs)
+
+ def visualize(self,
+ inputs: list,
+ preds: List[dict],
+ show: bool = False,
+ wait_time: int = 0,
+ img_out_dir: str = '',
+ opacity: float = 0.8) -> List[np.ndarray]:
+ """Visualize predictions.
+
+ Args:
+ inputs (list): Inputs preprocessed by :meth:`_inputs_to_list`.
+ preds (Any): Predictions of the model.
+ show (bool): Whether to display the image in a popup window.
+ Defaults to False.
+ wait_time (float): The interval of show (s). Defaults to 0.
+ img_out_dir (str): Output directory of rendering prediction i.e.
+ color segmentation mask. Defaults: ''
+ opacity (int, float): The transparency of segmentation mask.
+ Defaults to 0.8.
+
+ Returns:
+ List[np.ndarray]: Visualization results.
+ """
+ if self.visualizer is None or (not show and img_out_dir == ''):
+ return None
+
+ if getattr(self, 'visualizer') is None:
+ raise ValueError('Visualization needs the "visualizer" term'
+ 'defined in the config, but got None')
+ self.visualizer.set_dataset_meta(**self.model.dataset_meta)
+ self.visualizer.alpha = opacity
+
+ results = []
+
+ for single_input, pred in zip(inputs, preds):
+ if isinstance(single_input, str):
+ img_bytes = mmengine.fileio.get(single_input)
+ img = mmcv.imfrombytes(img_bytes)
+ img = img[:, :, ::-1]
+ img_name = osp.basename(single_input)
+ elif isinstance(single_input, np.ndarray):
+ img = single_input.copy()
+ img_num = str(self.num_visualized_imgs).zfill(8) + '_vis'
+ img_name = f'{img_num}.jpg'
+ else:
+ raise ValueError('Unsupported input type:'
+ f'{type(single_input)}')
+
+ out_file = osp.join(img_out_dir, img_name) if img_out_dir != ''\
+ else None
+
+ self.visualizer.add_datasample(
+ img_name,
+ img,
+ pred,
+ show=show,
+ wait_time=wait_time,
+ draw_gt=False,
+ draw_pred=True,
+ out_file=out_file)
+ results.append(self.visualizer.get_image())
+ self.num_visualized_imgs += 1
+
+ return results
+
+ def postprocess(self,
+ preds: PredType,
+ visualization: List[np.ndarray],
+ return_datasample: bool = False,
+ pred_out_dir: str = '') -> dict:
+ """Process the predictions and visualization results from ``forward``
+ and ``visualize``.
+
+ This method should be responsible for the following tasks:
+
+ 1. Pack the predictions and visualization results and return them.
+ 2. Save the predictions, if it needed.
+
+ Args:
+ preds (List[Dict]): Predictions of the model.
+ visualization (List[np.ndarray]): The list of rendering color
+ segmentation mask.
+ return_datasample (bool): Whether to return results as datasamples.
+ Defaults to False.
+ pred_out_dir: File to save the inference results w/o
+ visualization. If left as empty, no file will be saved.
+ Defaults to ''.
+
+ Returns:
+ dict: Inference and visualization results with key ``predictions``
+ and ``visualization``
+
+ - ``visualization (Any)``: Returned by :meth:`visualize`
+ - ``predictions`` (List[np.ndarray], np.ndarray): Returned by
+ :meth:`forward` and processed in :meth:`postprocess`.
+ If ``return_datasample=False``, it will be the segmentation mask
+ with label indice.
+ """
+ if return_datasample:
+ if len(preds) == 1:
+ return preds[0]
+ else:
+ return preds
+
+ results_dict = {}
+
+ results_dict['predictions'] = []
+ results_dict['visualization'] = []
+
+ for i, pred in enumerate(preds):
+ pred_data = pred.pred_sem_seg.numpy().data[0]
+ results_dict['predictions'].append(pred_data)
+ if visualization is not None:
+ vis = visualization[i]
+ results_dict['visualization'].append(vis)
+ if pred_out_dir != '':
+ mmengine.mkdir_or_exist(pred_out_dir)
+ img_name = str(self.num_pred_imgs).zfill(8) + '_pred.png'
+ img_path = osp.join(pred_out_dir, img_name)
+ output = Image.fromarray(pred_data.astype(np.uint8))
+ output.save(img_path)
+ self.num_pred_imgs += 1
+
+ if len(results_dict['predictions']) == 1:
+ results_dict['predictions'] = results_dict['predictions'][0]
+ if visualization is not None:
+ results_dict['visualization'] = \
+ results_dict['visualization'][0]
+ return results_dict
+
+ def _init_pipeline(self, cfg: ConfigType) -> Compose:
+ """Initialize the test pipeline.
+
+ Return a pipeline to handle various input data, such as ``str``,
+ ``np.ndarray``. It is an abstract method in BaseInferencer, and should
+ be implemented in subclasses.
+
+ The returned pipeline will be used to process a single data.
+ It will be used in :meth:`preprocess` like this:
+
+ .. code-block:: python
+ def preprocess(self, inputs, batch_size, **kwargs):
+ ...
+ dataset = map(self.pipeline, dataset)
+ ...
+ """
+ pipeline_cfg = cfg.test_dataloader.dataset.pipeline
+ # Loading annotations is also not applicable
+ idx = self._get_transform_idx(pipeline_cfg, 'LoadAnnotations')
+ if idx != -1:
+ del pipeline_cfg[idx]
+ load_img_idx = self._get_transform_idx(pipeline_cfg,
+ 'LoadImageFromFile')
+
+ if load_img_idx == -1:
+ raise ValueError(
+ 'LoadImageFromFile is not found in the test pipeline')
+ pipeline_cfg[load_img_idx]['type'] = 'InferencerLoader'
+ return Compose(pipeline_cfg)
+
+ def _get_transform_idx(self, pipeline_cfg: ConfigType, name: str) -> int:
+ """Returns the index of the transform in a pipeline.
+
+ If the transform is not found, returns -1.
+ """
+ for i, transform in enumerate(pipeline_cfg):
+ if transform['type'] == name:
+ return i
+ return -1
diff --git a/mmseg/datasets/__init__.py b/mmseg/datasets/__init__.py
index 8aa2e8d1a8..0dd19ee312 100644
--- a/mmseg/datasets/__init__.py
+++ b/mmseg/datasets/__init__.py
@@ -17,6 +17,7 @@
from .night_driving import NightDrivingDataset
from .pascal_context import PascalContextDataset, PascalContextDataset59
from .potsdam import PotsdamDataset
+from .refuge import REFUGEDataset
from .stare import STAREDataset
from .synapse import SynapseDataset
# yapf: disable
@@ -48,5 +49,5 @@
'DecathlonDataset', 'LIPDataset', 'ResizeShortestEdge',
'BioMedicalGaussianNoise', 'BioMedicalGaussianBlur',
'BioMedicalRandomGamma', 'BioMedical3DPad', 'RandomRotFlip',
- 'SynapseDataset'
+ 'SynapseDataset', 'REFUGEDataset'
]
diff --git a/mmseg/datasets/basesegdataset.py b/mmseg/datasets/basesegdataset.py
index bf433b2094..ddf476bae9 100644
--- a/mmseg/datasets/basesegdataset.py
+++ b/mmseg/datasets/basesegdataset.py
@@ -73,38 +73,36 @@ class BaseSegDataset(BaseDataset):
ignore_index (int): The label index to be ignored. Default: 255
reduce_zero_label (bool): Whether to mark label zero as ignored.
Default to False.
- backend_args (dict): Arguments to instantiate a file backend.
+ backend_args (dict, Optional): Arguments to instantiate a file backend.
See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
- for details. Defaults to ``dict(backend='local')``
+ for details. Defaults to None.
Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
"""
METAINFO: dict = dict()
- def __init__(
- self,
- ann_file: str = '',
- img_suffix='.jpg',
- seg_map_suffix='.png',
- metainfo: Optional[dict] = None,
- data_root: Optional[str] = None,
- data_prefix: dict = dict(img_path='', seg_map_path=''),
- filter_cfg: Optional[dict] = None,
- indices: Optional[Union[int, Sequence[int]]] = None,
- serialize_data: bool = True,
- pipeline: List[Union[dict, Callable]] = [],
- test_mode: bool = False,
- lazy_init: bool = False,
- max_refetch: int = 1000,
- ignore_index: int = 255,
- reduce_zero_label: bool = False,
- backend_args: dict = dict(backend='local')
- ) -> None:
+ def __init__(self,
+ ann_file: str = '',
+ img_suffix='.jpg',
+ seg_map_suffix='.png',
+ metainfo: Optional[dict] = None,
+ data_root: Optional[str] = None,
+ data_prefix: dict = dict(img_path='', seg_map_path=''),
+ filter_cfg: Optional[dict] = None,
+ indices: Optional[Union[int, Sequence[int]]] = None,
+ serialize_data: bool = True,
+ pipeline: List[Union[dict, Callable]] = [],
+ test_mode: bool = False,
+ lazy_init: bool = False,
+ max_refetch: int = 1000,
+ ignore_index: int = 255,
+ reduce_zero_label: bool = False,
+ backend_args: Optional[dict] = None) -> None:
self.img_suffix = img_suffix
self.seg_map_suffix = seg_map_suffix
self.ignore_index = ignore_index
self.reduce_zero_label = reduce_zero_label
- self.backend_args = backend_args.copy()
+ self.backend_args = backend_args.copy() if backend_args else None
self.data_root = data_root
self.data_prefix = copy.copy(data_prefix)
diff --git a/mmseg/datasets/refuge.py b/mmseg/datasets/refuge.py
new file mode 100644
index 0000000000..4016a825a3
--- /dev/null
+++ b/mmseg/datasets/refuge.py
@@ -0,0 +1,28 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import mmengine.fileio as fileio
+
+from mmseg.registry import DATASETS
+from .basesegdataset import BaseSegDataset
+
+
+@DATASETS.register_module()
+class REFUGEDataset(BaseSegDataset):
+ """REFUGE dataset.
+
+ In segmentation map annotation for REFUGE, 0 stands for background, which
+ is not included in 2 categories. ``reduce_zero_label`` is fixed to True.
+ The ``img_suffix`` is fixed to '.png' and ``seg_map_suffix`` is fixed to
+ '.png'.
+ """
+ METAINFO = dict(
+ classes=('background', ' Optic Cup', 'Optic Disc'),
+ palette=[[120, 120, 120], [6, 230, 230], [56, 59, 120]])
+
+ def __init__(self, **kwargs) -> None:
+ super().__init__(
+ img_suffix='.png',
+ seg_map_suffix='.png',
+ reduce_zero_label=False,
+ **kwargs)
+ assert fileio.exists(
+ self.data_prefix['img_path'], backend_args=self.backend_args)
diff --git a/mmseg/datasets/transforms/formatting.py b/mmseg/datasets/transforms/formatting.py
index f4018f788f..4391161dfd 100644
--- a/mmseg/datasets/transforms/formatting.py
+++ b/mmseg/datasets/transforms/formatting.py
@@ -63,8 +63,12 @@ def transform(self, results: dict) -> dict:
img = results['img']
if len(img.shape) < 3:
img = np.expand_dims(img, -1)
- img = np.ascontiguousarray(img.transpose(2, 0, 1))
- packed_results['inputs'] = to_tensor(img)
+ if not img.flags.c_contiguous:
+ img = to_tensor(np.ascontiguousarray(img.transpose(2, 0, 1)))
+ else:
+ img = img.transpose(2, 0, 1)
+ img = to_tensor(img).contiguous()
+ packed_results['inputs'] = img
data_sample = SegDataSample()
if 'gt_seg_map' in results:
diff --git a/mmseg/datasets/transforms/loading.py b/mmseg/datasets/transforms/loading.py
index 5a413717b6..d2e93b1abb 100644
--- a/mmseg/datasets/transforms/loading.py
+++ b/mmseg/datasets/transforms/loading.py
@@ -1,6 +1,6 @@
# Copyright (c) OpenMMLab. All rights reserved.
import warnings
-from typing import Dict
+from typing import Dict, Optional, Union
import mmcv
import mmengine.fileio as fileio
@@ -56,14 +56,14 @@ class LoadAnnotations(MMCV_LoadAnnotations):
Defaults to 'pillow'.
backend_args (dict): Arguments to instantiate a file backend.
See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
- for details. Defaults to ``dict(backend='local')``
+ for details. Defaults to None.
Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
"""
def __init__(
self,
reduce_zero_label=None,
- backend_args=dict(backend='local'),
+ backend_args=None,
imdecode_backend='pillow',
) -> None:
super().__init__(
@@ -203,23 +203,21 @@ class LoadBiomedicalImageFromFile(BaseTransform):
to_float32 (bool): Whether to convert the loaded image to a float32
numpy array. If set to False, the loaded image is an float64 array.
Defaults to True.
- backend_args (dict): Arguments to instantiate a file backend.
+ backend_args (dict, Optional): Arguments to instantiate a file backend.
See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
- for details. Defaults to ``dict(backend='local')``
+ for details. Defaults to None.
Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
"""
- def __init__(
- self,
- decode_backend: str = 'nifti',
- to_xyz: bool = False,
- to_float32: bool = True,
- backend_args: dict = dict(backend='local')
- ) -> None:
+ def __init__(self,
+ decode_backend: str = 'nifti',
+ to_xyz: bool = False,
+ to_float32: bool = True,
+ backend_args: Optional[dict] = None) -> None:
self.decode_backend = decode_backend
self.to_xyz = to_xyz
self.to_float32 = to_float32
- self.backend_args = backend_args.copy()
+ self.backend_args = backend_args.copy() if backend_args else None
def transform(self, results: Dict) -> Dict:
"""Functions to load image.
@@ -295,24 +293,22 @@ class LoadBiomedicalAnnotation(BaseTransform):
to_float32 (bool): Whether to convert the loaded seg map to a float32
numpy array. If set to False, the loaded image is an float64 array.
Defaults to True.
- backend_args (dict): Arguments to instantiate a file backend.
+ backend_args (dict, Optional): Arguments to instantiate a file backend.
See :class:`mmengine.fileio` for details.
- Defaults to ``dict(backend='local')``.
+ Defaults to None.
Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
"""
- def __init__(
- self,
- decode_backend: str = 'nifti',
- to_xyz: bool = False,
- to_float32: bool = True,
- backend_args: dict = dict(backend='local')
- ) -> None:
+ def __init__(self,
+ decode_backend: str = 'nifti',
+ to_xyz: bool = False,
+ to_float32: bool = True,
+ backend_args: Optional[dict] = None) -> None:
super().__init__()
self.decode_backend = decode_backend
self.to_xyz = to_xyz
self.to_float32 = to_float32
- self.backend_args = backend_args.copy()
+ self.backend_args = backend_args.copy() if backend_args else None
def transform(self, results: Dict) -> Dict:
"""Functions to load image.
@@ -384,23 +380,21 @@ class LoadBiomedicalData(BaseTransform):
backend is 'nifti'. Defaults to 'nifti'.
to_xyz (bool): Whether transpose data from Z, Y, X to X, Y, Z.
Defaults to False.
- backend_args (dict): Arguments to instantiate a file backend.
+ backend_args (dict, Optional): Arguments to instantiate a file backend.
See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
- for details. Defaults to ``dict(backend='local')``
+ for details. Defaults to None.
Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
"""
- def __init__(
- self,
- with_seg=False,
- decode_backend: str = 'numpy',
- to_xyz: bool = False,
- backend_args: dict = dict(backend='local')
- ) -> None: # noqa
+ def __init__(self,
+ with_seg=False,
+ decode_backend: str = 'numpy',
+ to_xyz: bool = False,
+ backend_args: Optional[dict] = None) -> None: # noqa
self.with_seg = with_seg
self.decode_backend = decode_backend
self.to_xyz = to_xyz
- self.backend_args = backend_args.copy()
+ self.backend_args = backend_args.copy() if backend_args else None
def transform(self, results: Dict) -> Dict:
"""Functions to load image.
@@ -443,3 +437,59 @@ def __repr__(self) -> str:
f'to_xyz={self.to_xyz}, '
f'backend_args={self.backend_args})')
return repr_str
+
+
+@TRANSFORMS.register_module()
+class InferencerLoader(BaseTransform):
+ """Load an image from ``results['img']``.
+
+ Similar with :obj:`LoadImageFromFile`, but the image has been loaded as
+ :obj:`np.ndarray` in ``results['img']``. Can be used when loading image
+ from webcam.
+
+ Required Keys:
+
+ - img
+
+ Modified Keys:
+
+ - img
+ - img_path
+ - img_shape
+ - ori_shape
+
+ Args:
+ to_float32 (bool): Whether to convert the loaded image to a float32
+ numpy array. If set to False, the loaded image is an uint8 array.
+ Defaults to False.
+ """
+
+ def __init__(self, **kwargs) -> None:
+ super().__init__()
+ self.from_file = TRANSFORMS.build(
+ dict(type='LoadImageFromFile', **kwargs))
+ self.from_ndarray = TRANSFORMS.build(
+ dict(type='LoadImageFromNDArray', **kwargs))
+
+ def transform(self, single_input: Union[str, np.ndarray, dict]) -> dict:
+ """Transform function to add image meta information.
+
+ Args:
+ results (dict): Result dict with Webcam read image in
+ ``results['img']``.
+
+ Returns:
+ dict: The dict contains loaded image and meta information.
+ """
+ if isinstance(single_input, str):
+ inputs = dict(img_path=single_input)
+ elif isinstance(single_input, np.ndarray):
+ inputs = dict(img=single_input)
+ elif isinstance(single_input, dict):
+ inputs = single_input
+ else:
+ raise NotImplementedError
+
+ if 'img' in inputs:
+ return self.from_ndarray(inputs)
+ return self.from_file(inputs)
diff --git a/mmseg/engine/hooks/visualization_hook.py b/mmseg/engine/hooks/visualization_hook.py
index 25aa1cf8b5..1e7c97afe8 100644
--- a/mmseg/engine/hooks/visualization_hook.py
+++ b/mmseg/engine/hooks/visualization_hook.py
@@ -1,7 +1,7 @@
# Copyright (c) OpenMMLab. All rights reserved.
import os.path as osp
import warnings
-from typing import Sequence
+from typing import Optional, Sequence
import mmcv
import mmengine.fileio as fileio
@@ -30,9 +30,9 @@ class SegVisualizationHook(Hook):
interval (int): The interval of visualization. Defaults to 50.
show (bool): Whether to display the drawn image. Default to False.
wait_time (float): The interval of show (s). Defaults to 0.
- backend_args (dict): Arguments to instantiate a file backend.
+ backend_args (dict, Optional): Arguments to instantiate a file backend.
See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
- for details. Defaults to ``dict(backend='local')``
+ for details. Defaults to None.
Notes: mmcv>=2.0.0rc4, mmengine>=0.2.0 required.
"""
@@ -41,7 +41,7 @@ def __init__(self,
interval: int = 50,
show: bool = False,
wait_time: float = 0.,
- backend_args: dict = dict(backend='local')):
+ backend_args: Optional[dict] = None):
self._visualizer: SegLocalVisualizer = \
SegLocalVisualizer.get_current_instance()
self.interval = interval
@@ -55,7 +55,7 @@ def __init__(self,
'needs to be excluded.')
self.wait_time = wait_time
- self.backend_args = backend_args.copy()
+ self.backend_args = backend_args.copy() if backend_args else None
self.draw = draw
if not self.draw:
warnings.warn('The draw is False, it means that the '
diff --git a/mmseg/models/segmentors/cascade_encoder_decoder.py b/mmseg/models/segmentors/cascade_encoder_decoder.py
index c932b43069..0184a3533a 100644
--- a/mmseg/models/segmentors/cascade_encoder_decoder.py
+++ b/mmseg/models/segmentors/cascade_encoder_decoder.py
@@ -68,6 +68,7 @@ def _init_decode_head(self, decode_head: ConfigType) -> None:
self.decode_head.append(MODELS.build(decode_head[i]))
self.align_corners = self.decode_head[-1].align_corners
self.num_classes = self.decode_head[-1].num_classes
+ self.out_channels = self.decode_head[-1].out_channels
def encode_decode(self, inputs: Tensor,
batch_img_metas: List[dict]) -> Tensor:
diff --git a/mmseg/registry/__init__.py b/mmseg/registry/__init__.py
index c646b7e5ac..ee514d1a2a 100644
--- a/mmseg/registry/__init__.py
+++ b/mmseg/registry/__init__.py
@@ -1,13 +1,15 @@
# Copyright (c) OpenMMLab. All rights reserved.
-from .registry import (DATA_SAMPLERS, DATASETS, HOOKS, LOOPS, METRICS,
- MODEL_WRAPPERS, MODELS, OPTIM_WRAPPER_CONSTRUCTORS,
- OPTIMIZERS, PARAM_SCHEDULERS, RUNNER_CONSTRUCTORS,
- RUNNERS, TASK_UTILS, TRANSFORMS, VISBACKENDS,
- VISUALIZERS, WEIGHT_INITIALIZERS)
+from .registry import (DATA_SAMPLERS, DATASETS, EVALUATOR, HOOKS, INFERENCERS,
+ LOG_PROCESSORS, LOOPS, METRICS, MODEL_WRAPPERS, MODELS,
+ OPTIM_WRAPPER_CONSTRUCTORS, OPTIM_WRAPPERS, OPTIMIZERS,
+ PARAM_SCHEDULERS, RUNNER_CONSTRUCTORS, RUNNERS,
+ TASK_UTILS, TRANSFORMS, VISBACKENDS, VISUALIZERS,
+ WEIGHT_INITIALIZERS)
__all__ = [
- 'RUNNERS', 'RUNNER_CONSTRUCTORS', 'HOOKS', 'DATASETS', 'DATA_SAMPLERS',
- 'TRANSFORMS', 'MODELS', 'WEIGHT_INITIALIZERS', 'OPTIMIZERS',
- 'OPTIM_WRAPPER_CONSTRUCTORS', 'TASK_UTILS', 'PARAM_SCHEDULERS', 'METRICS',
- 'MODEL_WRAPPERS', 'LOOPS', 'VISBACKENDS', 'VISUALIZERS'
+ 'HOOKS', 'DATASETS', 'DATA_SAMPLERS', 'TRANSFORMS', 'MODELS',
+ 'WEIGHT_INITIALIZERS', 'OPTIMIZERS', 'OPTIM_WRAPPER_CONSTRUCTORS',
+ 'TASK_UTILS', 'PARAM_SCHEDULERS', 'METRICS', 'MODEL_WRAPPERS',
+ 'VISBACKENDS', 'VISUALIZERS', 'RUNNERS', 'RUNNER_CONSTRUCTORS', 'LOOPS',
+ 'EVALUATOR', 'LOG_PROCESSORS', 'OPTIM_WRAPPERS', 'INFERENCERS'
]
diff --git a/mmseg/registry/registry.py b/mmseg/registry/registry.py
index 5c9977ab8d..32684e758f 100644
--- a/mmseg/registry/registry.py
+++ b/mmseg/registry/registry.py
@@ -10,6 +10,7 @@
from mmengine.registry import DATASETS as MMENGINE_DATASETS
from mmengine.registry import EVALUATOR as MMENGINE_EVALUATOR
from mmengine.registry import HOOKS as MMENGINE_HOOKS
+from mmengine.registry import INFERENCERS as MMENGINE_INFERENCERS
from mmengine.registry import LOG_PROCESSORS as MMENGINE_LOG_PROCESSORS
from mmengine.registry import LOOPS as MMENGINE_LOOPS
from mmengine.registry import METRICS as MMENGINE_METRICS
@@ -39,45 +40,82 @@
# manage all kinds of loops like `EpochBasedTrainLoop`
LOOPS = Registry('loop', parent=MMENGINE_LOOPS)
# manage all kinds of hooks like `CheckpointHook`
-HOOKS = Registry('hook', parent=MMENGINE_HOOKS)
+HOOKS = Registry(
+ 'hook', parent=MMENGINE_HOOKS, locations=['mmseg.engine.hooks'])
# manage data-related modules
-DATASETS = Registry('dataset', parent=MMENGINE_DATASETS)
-DATA_SAMPLERS = Registry('data sampler', parent=MMENGINE_DATA_SAMPLERS)
-TRANSFORMS = Registry('transform', parent=MMENGINE_TRANSFORMS)
+DATASETS = Registry(
+ 'dataset', parent=MMENGINE_DATASETS, locations=['mmseg.datasets'])
+DATA_SAMPLERS = Registry(
+ 'data sampler',
+ parent=MMENGINE_DATA_SAMPLERS,
+ locations=['mmseg.datasets.samplers'])
+TRANSFORMS = Registry(
+ 'transform',
+ parent=MMENGINE_TRANSFORMS,
+ locations=['mmseg.datasets.transforms'])
# mangage all kinds of modules inheriting `nn.Module`
-MODELS = Registry('model', parent=MMENGINE_MODELS)
+MODELS = Registry('model', parent=MMENGINE_MODELS, locations=['mmseg.models'])
# mangage all kinds of model wrappers like 'MMDistributedDataParallel'
-MODEL_WRAPPERS = Registry('model_wrapper', parent=MMENGINE_MODEL_WRAPPERS)
+MODEL_WRAPPERS = Registry(
+ 'model_wrapper',
+ parent=MMENGINE_MODEL_WRAPPERS,
+ locations=['mmseg.models'])
# mangage all kinds of weight initialization modules like `Uniform`
WEIGHT_INITIALIZERS = Registry(
- 'weight initializer', parent=MMENGINE_WEIGHT_INITIALIZERS)
+ 'weight initializer',
+ parent=MMENGINE_WEIGHT_INITIALIZERS,
+ locations=['mmseg.models'])
# mangage all kinds of optimizers like `SGD` and `Adam`
-OPTIMIZERS = Registry('optimizer', parent=MMENGINE_OPTIMIZERS)
+OPTIMIZERS = Registry(
+ 'optimizer',
+ parent=MMENGINE_OPTIMIZERS,
+ locations=['mmseg.engine.optimizers'])
# manage optimizer wrapper
-OPTIM_WRAPPERS = Registry('optim_wrapper', parent=MMENGINE_OPTIM_WRAPPERS)
+OPTIM_WRAPPERS = Registry(
+ 'optim_wrapper',
+ parent=MMENGINE_OPTIM_WRAPPERS,
+ locations=['mmseg.engine.optimizers'])
# manage constructors that customize the optimization hyperparameters.
OPTIM_WRAPPER_CONSTRUCTORS = Registry(
'optimizer wrapper constructor',
- parent=MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS)
+ parent=MMENGINE_OPTIM_WRAPPER_CONSTRUCTORS,
+ locations=['mmseg.engine.optimizers'])
# mangage all kinds of parameter schedulers like `MultiStepLR`
PARAM_SCHEDULERS = Registry(
- 'parameter scheduler', parent=MMENGINE_PARAM_SCHEDULERS)
+ 'parameter scheduler',
+ parent=MMENGINE_PARAM_SCHEDULERS,
+ locations=['mmseg.engine.schedulers'])
# manage all kinds of metrics
-METRICS = Registry('metric', parent=MMENGINE_METRICS)
+METRICS = Registry(
+ 'metric', parent=MMENGINE_METRICS, locations=['mmseg.evaluation'])
# manage evaluator
-EVALUATOR = Registry('evaluator', parent=MMENGINE_EVALUATOR)
+EVALUATOR = Registry(
+ 'evaluator', parent=MMENGINE_EVALUATOR, locations=['mmseg.evaluation'])
# manage task-specific modules like ohem pixel sampler
-TASK_UTILS = Registry('task util', parent=MMENGINE_TASK_UTILS)
+TASK_UTILS = Registry(
+ 'task util', parent=MMENGINE_TASK_UTILS, locations=['mmseg.models'])
# manage visualizer
-VISUALIZERS = Registry('visualizer', parent=MMENGINE_VISUALIZERS)
+VISUALIZERS = Registry(
+ 'visualizer',
+ parent=MMENGINE_VISUALIZERS,
+ locations=['mmseg.visualization'])
# manage visualizer backend
-VISBACKENDS = Registry('vis_backend', parent=MMENGINE_VISBACKENDS)
+VISBACKENDS = Registry(
+ 'vis_backend',
+ parent=MMENGINE_VISBACKENDS,
+ locations=['mmseg.visualization'])
# manage logprocessor
-LOG_PROCESSORS = Registry('log_processor', parent=MMENGINE_LOG_PROCESSORS)
+LOG_PROCESSORS = Registry(
+ 'log_processor',
+ parent=MMENGINE_LOG_PROCESSORS,
+ locations=['mmseg.visualization'])
+
+# manage inferencer
+INFERENCERS = Registry('inferencer', parent=MMENGINE_INFERENCERS)
diff --git a/mmseg/version.py b/mmseg/version.py
index 10ceca8120..ef8e391a29 100644
--- a/mmseg/version.py
+++ b/mmseg/version.py
@@ -1,6 +1,6 @@
# Copyright (c) Open-MMLab. All rights reserved.
-__version__ = '1.0.0rc5'
+__version__ = '1.0.0rc6'
def parse_version_info(version_str):
diff --git a/mmseg/visualization/local_visualizer.py b/mmseg/visualization/local_visualizer.py
index 27443f2c57..d11ad79c81 100644
--- a/mmseg/visualization/local_visualizer.py
+++ b/mmseg/visualization/local_visualizer.py
@@ -1,5 +1,5 @@
# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Dict, List, Optional, Tuple, Union
+from typing import Dict, List, Optional
import mmcv
import numpy as np
@@ -24,6 +24,17 @@ class SegLocalVisualizer(Visualizer):
Defaults to None.
save_dir (str, optional): Save file dir for all storage backends.
If it is None, the backend storage will not save any data.
+ classes (list, optional): Input classes for result rendering, as the
+ prediction of segmentation model is a segment map with label
+ indices, `classes` is a list which includes items responding to the
+ label indices. If classes is not defined, visualizer will take
+ `cityscapes` classes by default. Defaults to None.
+ palette (list, optional): Input palette for result rendering, which is
+ a list of color palette responding to the classes. Defaults to None.
+ dataset_name (str, optional): `Dataset name or alias `_
+ visulizer will use the meta information of the dataset i.e. classes
+ and palette, but the `classes` and `palette` have higher priority.
+ Defaults to None.
alpha (int, float): The transparency of segmentation mask.
Defaults to 0.8.
@@ -49,43 +60,40 @@ class SegLocalVisualizer(Visualizer):
>>> seg_local_visualizer.add_datasample(
... 'visualizer_example', image,
... gt_seg_data_sample, show=True)
- """
+ """ # noqa
def __init__(self,
name: str = 'visualizer',
image: Optional[np.ndarray] = None,
vis_backends: Optional[Dict] = None,
save_dir: Optional[str] = None,
- palette: Optional[Union[str, List]] = None,
- classes: Optional[Union[str, List]] = None,
+ classes: Optional[List] = None,
+ palette: Optional[List] = None,
dataset_name: Optional[str] = None,
alpha: float = 0.8,
**kwargs):
super().__init__(name, image, vis_backends, save_dir, **kwargs)
self.alpha: float = alpha
- # Set default value. When calling
- # `SegLocalVisualizer().dataset_meta=xxx`,
- # it will override the default value.
- if dataset_name is None:
- dataset_name = 'cityscapes'
- classes = classes if classes else get_classes(dataset_name)
- palette = palette if palette else get_palette(dataset_name)
- assert len(classes) == len(
- palette), 'The length of classes should be equal to palette'
- self.dataset_meta: dict = {'classes': classes, 'palette': palette}
+ self.set_dataset_meta(palette, classes, dataset_name)
def _draw_sem_seg(self, image: np.ndarray, sem_seg: PixelData,
- classes: Optional[Tuple[str]],
- palette: Optional[List[List[int]]]) -> np.ndarray:
+ classes: Optional[List],
+ palette: Optional[List]) -> np.ndarray:
"""Draw semantic seg of GT or prediction.
Args:
image (np.ndarray): The image to draw.
- sem_seg (:obj:`PixelData`): Data structure for
- pixel-level annotations or predictions.
- classes (Tuple[str], optional): Category information.
- palette (List[List[int]], optional): The palette of
- segmentation map.
+ sem_seg (:obj:`PixelData`): Data structure for pixel-level
+ annotations or predictions.
+ classes (list, optional): Input classes for result rendering, as
+ the prediction of segmentation model is a segment map with
+ label indices, `classes` is a list which includes items
+ responding to the label indices. If classes is not defined,
+ visualizer will take `cityscapes` classes by default.
+ Defaults to None.
+ palette (list, optional): Input palette for result rendering, which
+ is a list of color palette responding to the classes.
+ Defaults to None.
Returns:
np.ndarray: the drawn image which channel is RGB.
@@ -109,6 +117,38 @@ def _draw_sem_seg(self, image: np.ndarray, sem_seg: PixelData,
return self.get_image()
+ def set_dataset_meta(self,
+ classes: Optional[List] = None,
+ palette: Optional[List] = None,
+ dataset_name: Optional[str] = None) -> None:
+ """Set meta information to visualizer.
+
+ Args:
+ classes (list, optional): Input classes for result rendering, as
+ the prediction of segmentation model is a segment map with
+ label indices, `classes` is a list which includes items
+ responding to the label indices. If classes is not defined,
+ visualizer will take `cityscapes` classes by default.
+ Defaults to None.
+ palette (list, optional): Input palette for result rendering, which
+ is a list of color palette responding to the classes.
+ Defaults to None.
+ dataset_name (str, optional): `Dataset name or alias `_
+ visulizer will use the meta information of the dataset i.e.
+ classes and palette, but the `classes` and `palette` have
+ higher priority. Defaults to None.
+ """ # noqa
+ # Set default value. When calling
+ # `SegLocalVisualizer().dataset_meta=xxx`,
+ # it will override the default value.
+ if dataset_name is None:
+ dataset_name = 'cityscapes'
+ classes = classes if classes else get_classes(dataset_name)
+ palette = palette if palette else get_palette(dataset_name)
+ assert len(classes) == len(
+ palette), 'The length of classes should be equal to palette'
+ self.dataset_meta: dict = {'classes': classes, 'palette': palette}
+
@master_only
def add_datasample(
self,
@@ -186,6 +226,6 @@ def add_datasample(
self.show(drawn_img, win_name=name, wait_time=wait_time)
if out_file is not None:
- mmcv.imwrite(drawn_img, out_file)
+ mmcv.imwrite(mmcv.bgr2rgb(drawn_img), out_file)
else:
self.add_image(name, drawn_img, step)
diff --git a/projects/README.md b/projects/README.md
index 40d515eda3..5482c479aa 100644
--- a/projects/README.md
+++ b/projects/README.md
@@ -1,9 +1,19 @@
# Projects
-Implementing new models and features into OpenMMLab's algorithm libraries could be troublesome due to the rigorous requirements on code quality, which could hinder the fast iteration of SOTA models and might discourage our members from sharing their latest outcomes here.
+The OpenMMLab ecosystem can only grow through the contributions of the community.
+Everyone is welcome to post their implementation of any great ideas in this folder! If you wish to start your own project, please go through the [example project](example_project/) for the best practice. For common questions about projects, please read our [faq](faq.md).
-And that's why we have this `Projects/` folder now, where some experimental features, frameworks and models are placed, only needed to satisfy the minimum requirement on the code quality, and can be used as standalone libraries. Users are welcome to use them if they [use MMSegmentation from source](https://mmsegmentation.readthedocs.io/en/dev-1.x/get_started.html#best-practices).
+## External Projects
-Everyone is welcome to post their implementation of any great ideas in this folder! If you wish to start your own project, please go through the [example project](example_project/) for the best practice.
+There are also selected external projects released in the community that use MMSegmentation:
-Note: The core maintainers of MMSegmentation only ensure the results are reproducible and the code quality meets its claim at the time each project was submitted, but they may not be responsible for future maintenance. The original authors take responsibility for maintaining their own projects.
+- [SegNeXt: Rethinking Convolutional Attention Design for Semantic Segmentation](https://github.com/visual-attention-network/segnext)
+- [Vision Transformer Adapter for Dense Predictions](https://github.com/czczup/ViT-Adapter)
+- [UniFormer: Unifying Convolution and Self-attention for Visual Recognition](https://github.com/Sense-X/UniFormer)
+- [Multi-Scale High-Resolution Vision Transformer for Semantic Segmentation](https://github.com/facebookresearch/HRViT)
+- [ViTAE: Vision Transformer Advanced by Exploring Intrinsic Inductive Bias](https://github.com/ViTAE-Transformer/ViTAE-Transformer)
+- [DAFormer: Improving Network Architectures and Training Strategies for Domain-Adaptive Semantic Segmentation](https://github.com/lhoyer/DAFormer)
+- [MPViT : Multi-Path Vision Transformer for Dense Prediction](https://github.com/youngwanLEE/MPViT)
+- [TopFormer: Token Pyramid Transformer for Mobile Semantic Segmentation](https://github.com/hustvl/TopFormer)
+
+Note: These projects are supported and maintained by their own contributors. The core maintainers of MMSegmentation only ensure the results are reproducible and the code quality meets its claim at the time each project was submitted, but they may not be responsible for future maintenance.
diff --git a/projects/example_project/README.md b/projects/example_project/README.md
index 27ca5d4e2a..4338b8acac 100644
--- a/projects/example_project/README.md
+++ b/projects/example_project/README.md
@@ -1,20 +1,26 @@
# Dummy ResNet Wrapper
-This is an example README for community `projects/`. We have provided detailed explanations for each field in the form of html comments, which are visible when you read the source of this README file. If you wish to submit your project to our main repository, then all the fields in this README are mandatory for others to understand what you have achieved in this implementation. For more details, read our [contribution guide](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/.github/CONTRIBUTING.md) or approach us in [Discussions](https://github.com/open-mmlab/mmsegmentation/discussions).
+> A README.md template for releasing a project.
+>
+> All the fields in this README are **mandatory** for others to understand what you have achieved in this implementation.
+> Please read our [Projects FAQ](../faq.md) if you still feel unclear about the requirements, or raise an [issue](https://github.com/open-mmlab/mmsegmentation/issues) to us!
## Description
-
+Author： @xxx.
This project implements a dummy ResNet wrapper, which literally does nothing new but prints "hello world" during initialization.
## Usage
-
+> For a typical model, this section should contain the commands for training and testing.
+> You are also suggested to dump your environment specification to env.yml by `conda env export > env.yml`.
### Prerequisites
@@ -47,9 +53,8 @@ mim train mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.p
mim test mmsegmentation configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py --work-dir work_dirs/dummy_resnet --checkpoint ${CHECKPOINT_PATH}
```
-
+> List the results as usually done in other model's README. \[Example\](https://github.com/open-mmlab/mmsegmentation/tree/dev-1.x/configs/fcn#results-and-models
+> You should claim whether this is based on the pre-trained weights, which are converted from the official release; or it's a reproduced result obtained from retraining the model in this project
| Method | Backbone | Crop Size | Lr schd | Mem (GB) | Inf time (fps) | mIoU | mIoU(ms+flip) | config | download |
| ------ | -------- | --------- | ------: | -------- | -------------- | ----: | ------------: | ------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -57,7 +62,7 @@ You should claim whether this is based on the pre-trained weights, which are con
## Citation
-
+> You may remove this section if not applicable.
```bibtex
@misc{mmseg2020,
@@ -72,58 +77,58 @@ You should claim whether this is based on the pre-trained weights, which are con
Here is a checklist illustrating a usual development workflow of a successful project, and also serves as an overview of this project's progress.
-
+> A project does not necessarily have to be finished in a single PR, but it's essential for the project to at least reach the first milestone in its very first PR.
- [ ] Milestone 1: PR-ready, and acceptable to be one of the `projects/`.
- [ ] Finish the code
-
+> The code's design shall follow existing interfaces and convention. For example, each model component should be registered into `mmseg.registry.MODELS` and configurable via a config file.
- - [ ] Basic docstrings & proper citation
+- [ ] Basic docstrings & proper citation
-
+> Each major object should contain a docstring, describing its functionality and arguments. If you have adapted the code from other open-source projects, don't forget to cite the source project in docstring and make sure your behavior is not against its license. Typically, we do not accept any code snippet under GPL license. [A Short Guide to Open Source Licenses](https://medium.com/nationwide-technology/a-short-guide-to-open-source-licenses-cf5b1c329edd)
- - [ ] Test-time correctness
+- [ ] Test-time correctness
-
+> If you are reproducing the result from a paper, make sure your model's inference-time performance matches that in the original paper. The weights usually could be obtained by simply renaming the keys in the official pre-trained weights. This test could be skipped though, if you are able to prove the training-time correctness and check the second milestone.
- - [ ] A full README
+- [ ] A full README
-
+> As this template does.
- [ ] Milestone 2: Indicates a successful model implementation.
- [ ] Training-time correctness
-
+> If you are reproducing the result from a paper, checking this item means that you should have trained your model from scratch based on the original paper's specification and verified that the final result matches the report within a minor error range.
- [ ] Milestone 3: Good to be a part of our core package!
- [ ] Type hints and docstrings
-
+> Ideally *all* the methods should have [type hints](https://www.pythontutorial.net/python-basics/python-type-hints/) and [docstrings](https://google.github.io/styleguide/pyguide.html#381-docstrings). [Example](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/mmseg/utils/io.py#L9)
- - [ ] Unit tests
+- [ ] Unit tests
-
+> Unit tests for each module are required. [Example](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/tests/test_utils/test_io.py#L14)
- - [ ] Code polishing
+- [ ] Code polishing
-
+> Refactor your code according to reviewer's comment.
- - [ ] Metafile.yml
+- [ ] Metafile.yml
-
+> It will be parsed by MIM and Inferencer. [Example](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/configs/fcn/fcn.yml)
- [ ] Move your modules into the core package following the codebase's file hierarchy structure.
-
+> In particular, you may have to refactor this README into a standard one. [Example](https://github.com/open-mmlab/mmsegmentation/blob/dev-1.x/configs/fcn/README.md)
- [ ] Refactor your modules into the core package following the codebase's file hierarchy structure.
diff --git a/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py b/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
index b0ec67b691..43015364eb 100644
--- a/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
+++ b/projects/example_project/configs/fcn_dummy-r50-d8_4xb2-40k_cityscapes-512x1024.py
@@ -1,6 +1,6 @@
-_base_ = ['../../../configs/fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py']
+_base_ = ['mmseg::fcn/fcn_r50-d8_4xb2-40k_cityscapes-512x1024.py']
-custom_imports = dict(imports=['projects.example_project.dummy'])
+custom_imports = dict(imports=['dummy'])
crop_size = (512, 1024)
data_preprocessor = dict(size=crop_size)
diff --git a/projects/faq.md b/projects/faq.md
new file mode 100644
index 0000000000..724c1cf6a5
--- /dev/null
+++ b/projects/faq.md
@@ -0,0 +1,19 @@
+Q1: Why set up `projects/` folder?
+
+Implementing new models and features into OpenMMLab's algorithm libraries could be troublesome due to the rigorous requirements on code quality, which could hinder the fast iteration of SOTA models and might discourage our members from sharing their latest outcomes here. And that's why we have this `projects/` folder now, where some experimental features, frameworks and models are placed, only needed to satisfy the minimum requirement on the code quality, and can be used as standalone libraries. Users are welcome to use them if they [use MMSegmentation from source](https://mmsegmentation.readthedocs.io/en/dev-1.x/get_started.html#best-practices).
+
+Q2: Why should there be a checklist for a project?
+
+This checkelist is crucial not only for this project's developers but the entire community, since there might be some other contributors joining this project and deciding their starting point from this list. It also helps maintainers accurately estimate time and effort on further code polishing, if needed.
+
+Q3: What kind of PR will be merged?
+
+Reaching the first milestone means that this project suffices the minimum requirement of being merged into 'projects/'. That is, the very first PR of a project must have all the terms in the first milestone checked. We do not have any extra requirements on the project's following PRs, so they can be a minor bug fix or update, and do not have to achieve one milestone at once. But keep in mind that this project is only eligible to become a part of the core package upon attaining the last milestone.
+
+Q4: Compared to other models in the core packages, why do the model implementations in projects have different training/testing commands?
+
+Projects are organized independently from the core package, and therefore their modules cannot be directly imported by train.py and test.py. Each model implementation in projects should either use `mim` for training/testing as suggested in the example project or provide a custom train.py/test.py.
+
+Q5: How to debug a project with a debugger?
+
+Debugger makes our lives easier, but using it becomes a bit tricky if we have to train/test a model via `mim`. The way to circumvent that is that we can take advantage of relative path to import these modules. Assuming that we are developing a project X and the core modules are placed under `projects/X/modules`, then simply adding `custom_imports = dict(imports='projects.X.modules')` to the config allows us to debug from usual entrypoints (e.g. `tools/train.py`) from the root directory of the algorithm library. Just don't forget to remove 'projects.X' before project publishment.
diff --git a/projects/HieraSeg/README.md b/projects/hssn/README.md
similarity index 82%
rename from projects/HieraSeg/README.md
rename to projects/hssn/README.md
index 5519ec6916..c2a74c69f9 100644
--- a/projects/HieraSeg/README.md
+++ b/projects/hssn/README.md
@@ -1,12 +1,10 @@
-# HieraSeg
-
-Support `Deep Hierarchical Semantic Segmentation` interface on `cityscapes`
+# HSSN
## Description
Author: AI-Tianlong
-This project implements `HieraSeg` inference in the `cityscapes` dataset
+This project implements `Deep Hierarchical Semantic Segmentation` inference on `cityscapes` dataset
## Usage
@@ -14,17 +12,17 @@ This project implements `HieraSeg` inference in the `cityscapes` dataset
- Python 3.8
- PyTorch 1.6 or higher
-- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc3
-- mmcv v2.0.0rc3
-- mmengine
+- [MMSegmentation](https://github.com/open-mmlab/mmsegmentation) v1.0.0rc5
+- mmcv v2.0.0rc4
+- mmengine >=0.4.0
### Dataset preparing
-preparing `cityscapes` dataset like this [structure](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/dataset_prepare.md#prepare-datasets)
+Preparing `cityscapes` dataset following this [Dataset Preparing Guide](https://github.com/open-mmlab/mmsegmentation/blob/master/docs/en/dataset_prepare.md#prepare-datasets)
### Testing commands
-please put [`hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth`](https://download.openmmlab.com/mmsegmentation/v0.5/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth) to `mmsegmentation/checkpoints`
+Please put [`hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth`](https://download.openmmlab.com/mmsegmentation/v0.5/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth) to `mmsegmentation/checkpoints`
#### Multi-GPUs Test
@@ -36,7 +34,7 @@ bash tools/dist_test.sh [configs] [model weights] [number of gpu] --tta
#### Example
```shell
-bash tools/dist_test.sh projects/HieraSeg_project/configs/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py checkpoints/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth 2 --tta
+bash tools/dist_test.sh projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py checkpoints/hieraseg_deeplabv3plus_r101-d8_4xb2-80k_cityscapes-512x1024_20230112_125023-bc59a3d1.pth 2 --tta
```
## Results
diff --git a/projects/HieraSeg/configs/_base_/datasets/cityscapes.py b/projects/hssn/configs/_base_/datasets/cityscapes.py
similarity index 100%
rename from projects/HieraSeg/configs/_base_/datasets/cityscapes.py
rename to projects/hssn/configs/_base_/datasets/cityscapes.py
diff --git a/projects/HieraSeg/configs/_base_/default_runtime.py b/projects/hssn/configs/_base_/default_runtime.py
similarity index 100%
rename from projects/HieraSeg/configs/_base_/default_runtime.py
rename to projects/hssn/configs/_base_/default_runtime.py
diff --git a/projects/HieraSeg/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py b/projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
similarity index 100%
rename from projects/HieraSeg/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
rename to projects/hssn/configs/_base_/models/deeplabv3plus_r50-d8_vd_contrast.py
diff --git a/projects/HieraSeg/configs/_base_/schedules/schedule_80k.py b/projects/hssn/configs/_base_/schedules/schedule_80k.py
similarity index 100%
rename from projects/HieraSeg/configs/_base_/schedules/schedule_80k.py
rename to projects/hssn/configs/_base_/schedules/schedule_80k.py
diff --git a/projects/HieraSeg/configs/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py b/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
similarity index 82%
rename from projects/HieraSeg/configs/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
rename to projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
index 0d02bef5dc..8f04a2d656 100644
--- a/projects/HieraSeg/configs/hieraseg/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
+++ b/projects/hssn/configs/hssn/hieraseg_deeplabv3plus_r101-d8_4xb2-80l_cityscapes-512x1024.py
@@ -5,8 +5,8 @@
]
custom_imports = dict(imports=[
- 'projects.HieraSeg.decode_head.sep_aspp_contrast_head',
- 'projects.HieraSeg.losses.hiera_triplet_loss_cityscape'
+ 'projects.hssn.decode_head.sep_aspp_contrast_head',
+ 'projects.hssn.losses.hiera_triplet_loss_cityscape'
])
model = dict(
diff --git a/projects/HieraSeg/decode_head/__init__.py b/projects/hssn/decode_head/__init__.py
similarity index 100%
rename from projects/HieraSeg/decode_head/__init__.py
rename to projects/hssn/decode_head/__init__.py
diff --git a/projects/HieraSeg/decode_head/sep_aspp_contrast_head.py b/projects/hssn/decode_head/sep_aspp_contrast_head.py
similarity index 76%
rename from projects/HieraSeg/decode_head/sep_aspp_contrast_head.py
rename to projects/hssn/decode_head/sep_aspp_contrast_head.py
index 75f67e7457..d1d087362c 100644
--- a/projects/HieraSeg/decode_head/sep_aspp_contrast_head.py
+++ b/projects/hssn/decode_head/sep_aspp_contrast_head.py
@@ -1,5 +1,5 @@
# Copyright (c) OpenMMLab. All rights reserved.
-from typing import List
+from typing import List, Tuple
import torch
import torch.nn as nn
@@ -10,6 +10,7 @@
from mmseg.models.losses import accuracy
from mmseg.models.utils import resize
from mmseg.registry import MODELS
+from mmseg.utils import SampleList
class ProjectionHead(nn.Module):
@@ -61,34 +62,16 @@ def __init__(self, proj: str = 'convmlp', **kwargs):
dim_in=2048, norm_cfg=self.norm_cfg, proj=proj)
self.register_buffer('step', torch.zeros(1))
- def forward(self, inputs):
+ def forward(self, inputs) -> Tuple[Tensor]:
"""Forward function."""
+ output = super().forward(inputs)
+
self.step += 1
embedding = self.proj_head(inputs[-1])
- x = self._transform_inputs(inputs)
- aspp_outs = [
- resize(
- self.image_pool(x),
- size=x.size()[2:],
- mode='bilinear',
- align_corners=self.align_corners)
- ]
- aspp_outs.extend(self.aspp_modules(x))
- aspp_outs = torch.cat(aspp_outs, dim=1)
- output = self.bottleneck(aspp_outs)
- if self.c1_bottleneck is not None:
- c1_output = self.c1_bottleneck(inputs[0])
- output = resize(
- input=output,
- size=c1_output.shape[2:],
- mode='bilinear',
- align_corners=self.align_corners)
- output = torch.cat([output, c1_output], dim=1)
- output = self.sep_bottleneck(output)
- output = self.cls_seg(output)
+
return output, embedding
- def predict_by_feat(self, seg_logits: Tensor,
+ def predict_by_feat(self, seg_logits: Tuple[Tensor],
batch_img_metas: List[dict]) -> Tensor:
"""Transform a batch of output seg_logits to the input shape.
@@ -100,12 +83,13 @@ def predict_by_feat(self, seg_logits: Tensor,
Returns:
Tensor: Outputs segmentation logits map.
"""
- # HieraSeg decode_head output is: (out, embedding) :tuple,
+ # HSSN decode_head output is: (out, embedding): tuple
# only need 'out' here.
if isinstance(seg_logits, tuple):
seg_logit = seg_logits[0]
- if seg_logit.size(1) == 26:
+ if seg_logit.size(1) == 26: # For cityscapes dataset，19 + 7
+ hiera_num_classes = 7
seg_logit[:, 0:2] += seg_logit[:, -7]
seg_logit[:, 2:5] += seg_logit[:, -6]
seg_logit[:, 5:8] += seg_logit[:, -5]
@@ -113,14 +97,18 @@ def predict_by_feat(self, seg_logits: Tensor,
seg_logit[:, 10:11] += seg_logit[:, -3]
seg_logit[:, 11:13] += seg_logit[:, -2]
seg_logit[:, 13:19] += seg_logit[:, -1]
- elif seg_logit.size(1) == 12:
+
+ elif seg_logit.size(1) == 12: # For Pascal_person dataset, 7 + 5
+ hiera_num_classes = 5
seg_logit[:, 0:1] = seg_logit[:, 0:1] + \
seg_logit[:, 7] + seg_logit[:, 10]
seg_logit[:, 1:5] = seg_logit[:, 1:5] + \
seg_logit[:, 8] + seg_logit[:, 11]
seg_logit[:, 5:7] = seg_logit[:, 5:7] + \
seg_logit[:, 9] + seg_logit[:, 11]
- elif seg_logit.size(1) == 25:
+
+ elif seg_logit.size(1) == 25: # For LIP dataset, 20 + 5
+ hiera_num_classes = 5
seg_logit[:, 0:1] = seg_logit[:, 0:1] + \
seg_logit[:, 20] + seg_logit[:, 23]
seg_logit[:, 1:8] = seg_logit[:, 1:8] + \
@@ -136,8 +124,10 @@ def predict_by_feat(self, seg_logits: Tensor,
seg_logit[:, 16:20] = seg_logit[:, 16:20] + \
seg_logit[:, 22] + seg_logit[:, 24]
- # seg_logit = seg_logit[:,:-self.test_cfg['hiera_num_classes']]
- seg_logit = seg_logit[:, :-7]
+ # elif seg_logit.size(1) == 144 # For Mapillary dataset, 124+16+4
+ # unofficial repository not release mapillary until 2023/2/6
+
+ seg_logit = seg_logit[:, :-hiera_num_classes]
seg_logit = resize(
input=seg_logit,
size=batch_img_metas[0]['img_shape'],
@@ -146,10 +136,27 @@ def predict_by_feat(self, seg_logits: Tensor,
return seg_logit
- def losses(self, results, seg_label):
- """Compute segmentation loss."""
- seg_logit_before = results[0]
- embedding = results[1]
+ def loss_by_feat(
+ self,
+ seg_logits: Tuple[Tensor], # (out, embedding)
+ batch_data_samples: SampleList) -> dict:
+ """Compute segmentation loss. Will fix in future.
+
+ Args:
+ seg_logits (Tuple[Tensor]): The output from decode head
+ forward function.
+ For this decode_head output are (out, embedding): tuple
+ batch_data_samples (List[:obj:`SegDataSample`]): The seg
+ data samples. It usually includes information such
+ as `metainfo` and `gt_sem_seg`.
+
+ Returns:
+ dict[str, Tensor]: a dictionary of loss components
+ """
+ seg_logit_before = seg_logits[0]
+ embedding = seg_logits[1]
+ seg_label = self._stack_batch_gt(batch_data_samples)
+
loss = dict()
seg_logit = resize(
input=seg_logit_before,
@@ -166,6 +173,7 @@ def losses(self, results, seg_label):
scale_factor=0.5,
mode='bilinear',
align_corners=self.align_corners)
+
loss['loss_seg'] = self.loss_decode(
self.step,
embedding,
diff --git a/projects/HieraSeg/losses/__init__.py b/projects/hssn/losses/__init__.py
similarity index 100%
rename from projects/HieraSeg/losses/__init__.py
rename to projects/hssn/losses/__init__.py
diff --git a/projects/HieraSeg/losses/hiera_triplet_loss_cityscape.py b/projects/hssn/losses/hiera_triplet_loss_cityscape.py
similarity index 100%
rename from projects/HieraSeg/losses/hiera_triplet_loss_cityscape.py
rename to projects/hssn/losses/hiera_triplet_loss_cityscape.py
diff --git a/projects/HieraSeg/losses/tree_triplet_loss.py b/projects/hssn/losses/tree_triplet_loss.py
similarity index 100%
rename from projects/HieraSeg/losses/tree_triplet_loss.py
rename to projects/hssn/losses/tree_triplet_loss.py
diff --git a/requirements/mminstall.txt b/requirements/mminstall.txt
index 11a6d5a57f..df073e0c1b 100644
--- a/requirements/mminstall.txt
+++ b/requirements/mminstall.txt
@@ -1,4 +1,2 @@
-mmcls>=1.0.0rc0
mmcv>=2.0.0rc4
--e git+https://github.com/open-mmlab/mmdetection.git@dev-3.x#egg=mmdet
-mmengine>=0.2.0,<1.0.0
+mmengine>=0.5.0,<1.0.0
diff --git a/requirements/readthedocs.txt b/requirements/readthedocs.txt
index 1b5d8443b4..9627504884 100644
--- a/requirements/readthedocs.txt
+++ b/requirements/readthedocs.txt
@@ -1,5 +1,5 @@
mmcv>=2.0.0rc1,<2.1.0
-mmengine>=0.1.0,<1.0.0
+mmengine>=0.4.0,<1.0.0
prettytable
scipy
torch
diff --git a/tests/data/pseudo_refuge_dataset/ann_dir/pseudo_g0001.png b/tests/data/pseudo_refuge_dataset/ann_dir/pseudo_g0001.png
new file mode 100644
index 0000000000..4e69365a9c
Binary files /dev/null and b/tests/data/pseudo_refuge_dataset/ann_dir/pseudo_g0001.png differ
diff --git a/tests/data/pseudo_refuge_dataset/img_dir/pseudo_g0001.png b/tests/data/pseudo_refuge_dataset/img_dir/pseudo_g0001.png
new file mode 100644
index 0000000000..e424c3cd21
Binary files /dev/null and b/tests/data/pseudo_refuge_dataset/img_dir/pseudo_g0001.png differ
diff --git a/tests/test_apis/test_inferencer.py b/tests/test_apis/test_inferencer.py
new file mode 100644
index 0000000000..497eae4a01
--- /dev/null
+++ b/tests/test_apis/test_inferencer.py
@@ -0,0 +1,113 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import tempfile
+
+import numpy as np
+import torch
+import torch.nn as nn
+from mmengine import ConfigDict
+from torch.utils.data import DataLoader, Dataset
+
+from mmseg.apis import MMSegInferencer
+from mmseg.models import EncoderDecoder
+from mmseg.models.decode_heads.decode_head import BaseDecodeHead
+from mmseg.registry import MODELS
+from mmseg.utils import register_all_modules
+
+
+@MODELS.register_module(name='InferExampleHead')
+class ExampleDecodeHead(BaseDecodeHead):
+
+ def __init__(self, num_classes=19, out_channels=None):
+ super().__init__(
+ 3, 3, num_classes=num_classes, out_channels=out_channels)
+
+ def forward(self, inputs):
+ return self.cls_seg(inputs[0])
+
+
+@MODELS.register_module(name='InferExampleBackbone')
+class ExampleBackbone(nn.Module):
+
+ def __init__(self):
+ super().__init__()
+ self.conv = nn.Conv2d(3, 3, 3)
+
+ def init_weights(self, pretrained=None):
+ pass
+
+ def forward(self, x):
+ return [self.conv(x)]
+
+
+@MODELS.register_module(name='InferExampleModel')
+class ExampleModel(EncoderDecoder):
+
+ def __init__(self, **kwargs):
+ super().__init__(**kwargs)
+
+
+class ExampleDataset(Dataset):
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.pipeline = [
+ dict(type='LoadImageFromFile'),
+ dict(type='LoadAnnotations'),
+ dict(type='PackSegInputs')
+ ]
+
+ def __getitem__(self, idx):
+ return dict(img=torch.tensor([1]), img_metas=dict())
+
+ def __len__(self):
+ return 1
+
+
+def test_inferencer():
+ register_all_modules()
+ test_dataset = ExampleDataset()
+ data_loader = DataLoader(
+ test_dataset,
+ batch_size=1,
+ sampler=None,
+ num_workers=0,
+ shuffle=False,
+ )
+
+ visualizer = dict(
+ type='SegLocalVisualizer',
+ vis_backends=[dict(type='LocalVisBackend')],
+ name='visualizer')
+
+ cfg_dict = dict(
+ model=dict(
+ type='InferExampleModel',
+ data_preprocessor=dict(type='SegDataPreProcessor'),
+ backbone=dict(type='InferExampleBackbone'),
+ decode_head=dict(type='InferExampleHead'),
+ test_cfg=dict(mode='whole')),
+ visualizer=visualizer,
+ test_dataloader=data_loader)
+ cfg = ConfigDict(cfg_dict)
+ model = MODELS.build(cfg.model)
+
+ ckpt = model.state_dict()
+ ckpt_filename = tempfile.mktemp()
+ torch.save(ckpt, ckpt_filename)
+
+ # test initialization
+ infer = MMSegInferencer(cfg, ckpt_filename)
+
+ # test forward
+ img = np.random.randint(0, 256, (4, 4, 3))
+ infer(img)
+
+ imgs = [img, img]
+ infer(imgs)
+ results = infer(imgs, out_dir=tempfile.gettempdir())
+
+ # test results
+ assert 'predictions' in results
+ assert 'visualization' in results
+ assert len(results['predictions']) == 2
+ assert results['predictions'][0].shape == (4, 4)
diff --git a/tests/test_config.py b/tests/test_config.py
index bd664ed74f..13de460181 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -6,10 +6,10 @@
import numpy as np
from mmengine import Config
from mmengine.dataset import Compose
+from mmengine.registry import init_default_scope
from torch import nn
from mmseg.models import build_segmentor
-from mmseg.utils import register_all_modules
def _get_config_directory():
@@ -70,7 +70,7 @@ def test_config_data_pipeline():
xdoctest -m tests/test_config.py test_config_build_data_pipeline
"""
- register_all_modules()
+ init_default_scope('mmseg')
config_dpath = _get_config_directory()
print(f'Found config_dpath = {config_dpath!r}')
diff --git a/tests/test_datasets/test_dataset.py b/tests/test_datasets/test_dataset.py
index 7c37204a6c..b97cbae3a4 100644
--- a/tests/test_datasets/test_dataset.py
+++ b/tests/test_datasets/test_dataset.py
@@ -8,7 +8,8 @@
from mmseg.datasets import (ADE20KDataset, BaseSegDataset, CityscapesDataset,
COCOStuffDataset, DecathlonDataset, ISPRSDataset,
LIPDataset, LoveDADataset, PascalVOCDataset,
- PotsdamDataset, SynapseDataset, iSAIDDataset)
+ PotsdamDataset, REFUGEDataset, SynapseDataset,
+ iSAIDDataset)
from mmseg.registry import DATASETS
from mmseg.utils import get_classes, get_palette
@@ -232,6 +233,19 @@ def test_synapse():
assert len(test_dataset) == 2
+def test_refuge():
+ test_dataset = REFUGEDataset(
+ pipeline=[],
+ data_prefix=dict(
+ img_path=osp.join(
+ osp.dirname(__file__),
+ '../data/pseudo_refuge_dataset/img_dir'),
+ seg_map_path=osp.join(
+ osp.dirname(__file__),
+ '../data/pseudo_refuge_dataset/ann_dir')))
+ assert len(test_dataset) == 1
+
+
def test_isaid():
test_dataset = iSAIDDataset(
pipeline=[],
diff --git a/tests/test_datasets/test_dataset_builder.py b/tests/test_datasets/test_dataset_builder.py
index 099c5b1df0..b67b1e7aaf 100644
--- a/tests/test_datasets/test_dataset_builder.py
+++ b/tests/test_datasets/test_dataset_builder.py
@@ -2,12 +2,12 @@
import os.path as osp
from mmengine.dataset import ConcatDataset, RepeatDataset
+from mmengine.registry import init_default_scope
from mmseg.datasets import MultiImageMixDataset
from mmseg.registry import DATASETS
-from mmseg.utils import register_all_modules
-register_all_modules()
+init_default_scope('mmseg')
@DATASETS.register_module()
diff --git a/tests/test_datasets/test_loading.py b/tests/test_datasets/test_loading.py
index 100eb042e2..5ce624bff6 100644
--- a/tests/test_datasets/test_loading.py
+++ b/tests/test_datasets/test_loading.py
@@ -57,9 +57,9 @@ def test_load_seg(self):
results = transform(copy.deepcopy(results))
assert results['gt_seg_map'].shape == (288, 512)
assert results['gt_seg_map'].dtype == np.uint8
- # assert repr(transform) == transform.__class__.__name__ + \
- # "(reduce_zero_label=True, imdecode_backend='pillow', " + \
- # "backend_args={'backend': 'local'})"
+ assert repr(transform) == transform.__class__.__name__ + \
+ "(reduce_zero_label=True, imdecode_backend='pillow', " + \
+ 'backend_args=None)'
# reduce_zero_label
transform = LoadAnnotations(reduce_zero_label=True)
@@ -241,7 +241,7 @@ def test_load_biomedical_img(self):
"decode_backend='nifti', "
'to_xyz=False, '
'to_float32=True, '
- "backend_args={'backend': 'local'})")
+ 'backend_args=None)')
def test_load_biomedical_annotation(self):
results = dict(
@@ -265,7 +265,7 @@ def test_load_biomedical_data(self):
'with_seg=True, '
"decode_backend='numpy', "
'to_xyz=False, '
- "backend_args={'backend': 'local'})")
+ 'backend_args=None)')
transform = LoadBiomedicalData(with_seg=False)
results = transform(copy.deepcopy(input_results))
@@ -275,4 +275,4 @@ def test_load_biomedical_data(self):
'with_seg=False, '
"decode_backend='numpy', "
'to_xyz=False, '
- "backend_args={'backend': 'local'})")
+ 'backend_args=None)')
diff --git a/tests/test_datasets/test_transform.py b/tests/test_datasets/test_transform.py
index 906b3c27e8..a9136bebc8 100644
--- a/tests/test_datasets/test_transform.py
+++ b/tests/test_datasets/test_transform.py
@@ -5,6 +5,7 @@
import mmcv
import numpy as np
import pytest
+from mmengine.registry import init_default_scope
from PIL import Image
from mmseg.datasets.transforms import * # noqa
@@ -12,9 +13,8 @@
LoadBiomedicalImageFromFile,
PhotoMetricDistortion, RandomCrop)
from mmseg.registry import TRANSFORMS
-from mmseg.utils import register_all_modules
-register_all_modules()
+init_default_scope('mmseg')
def test_resize():
diff --git a/tests/test_engine/test_layer_decay_optimizer_constructor.py b/tests/test_engine/test_layer_decay_optimizer_constructor.py
index 72dc6c5123..e7d13db1d6 100644
--- a/tests/test_engine/test_layer_decay_optimizer_constructor.py
+++ b/tests/test_engine/test_layer_decay_optimizer_constructor.py
@@ -5,12 +5,12 @@
import torch.nn as nn
from mmcv.cnn import ConvModule
from mmengine.optim.optimizer import build_optim_wrapper
+from mmengine.registry import init_default_scope
from mmseg.engine.optimizers.layer_decay_optimizer_constructor import \
LearningRateDecayOptimizerConstructor
-from mmseg.utils import register_all_modules
-register_all_modules()
+init_default_scope('mmseg')
base_lr = 1
decay_rate = 2
diff --git a/tests/test_models/test_backbones/test_unet.py b/tests/test_models/test_backbones/test_unet.py
index d0eaccd393..4d3faf68cc 100644
--- a/tests/test_models/test_backbones/test_unet.py
+++ b/tests/test_models/test_backbones/test_unet.py
@@ -2,14 +2,14 @@
import pytest
import torch
from mmcv.cnn import ConvModule
+from mmengine.registry import init_default_scope
from mmseg.models.backbones.unet import (BasicConvBlock, DeconvModule,
InterpConv, UNet, UpConvBlock)
from mmseg.models.utils import Upsample
-from mmseg.utils import register_all_modules
from .utils import check_norm_state
-register_all_modules()
+init_default_scope('mmseg')
def test_unet_basic_conv_block():
diff --git a/tests/test_models/test_forward.py b/tests/test_models/test_forward.py
index ab88e4393a..7f72efae2a 100644
--- a/tests/test_models/test_forward.py
+++ b/tests/test_models/test_forward.py
@@ -9,14 +9,14 @@
import torch
import torch.nn as nn
from mmengine.model.utils import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
from mmengine.structures import PixelData
from mmengine.utils import is_list_of, is_tuple_of
from torch import Tensor
from mmseg.structures import SegDataSample
-from mmseg.utils import register_all_modules
-register_all_modules()
+init_default_scope('mmseg')
def _demo_mm_inputs(batch_size=2, image_shapes=(3, 32, 32), num_classes=5):
diff --git a/tests/test_models/test_heads/test_maskformer_head.py b/tests/test_models/test_heads/test_maskformer_head.py
index fe4bf96fea..6a47239b03 100644
--- a/tests/test_models/test_heads/test_maskformer_head.py
+++ b/tests/test_models/test_heads/test_maskformer_head.py
@@ -3,15 +3,15 @@
import torch
from mmengine import Config
+from mmengine.registry import init_default_scope
from mmengine.structures import PixelData
from mmseg.registry import MODELS
from mmseg.structures import SegDataSample
-from mmseg.utils import register_all_modules
def test_maskformer_head():
- register_all_modules()
+ init_default_scope('mmseg')
repo_dpath = dirname(dirname(__file__))
cfg = Config.fromfile(
join(
diff --git a/tests/test_models/test_segmentors/test_seg_tta_model.py b/tests/test_models/test_segmentors/test_seg_tta_model.py
index c0e76b22f4..3c9699e8df 100644
--- a/tests/test_models/test_segmentors/test_seg_tta_model.py
+++ b/tests/test_models/test_segmentors/test_seg_tta_model.py
@@ -2,14 +2,14 @@
import torch
from mmengine import ConfigDict
from mmengine.model import BaseTTAModel
+from mmengine.registry import init_default_scope
from mmengine.structures import PixelData
from mmseg.registry import MODELS
from mmseg.structures import SegDataSample
-from mmseg.utils import register_all_modules
from .utils import * # noqa: F401,F403
-register_all_modules()
+init_default_scope('mmseg')
def test_encoder_decoder_tta():
diff --git a/tools/analysis_tools/benchmark.py b/tools/analysis_tools/benchmark.py
index bcb3948a6e..afaeabac85 100644
--- a/tools/analysis_tools/benchmark.py
+++ b/tools/analysis_tools/benchmark.py
@@ -8,11 +8,11 @@
from mmengine import Config
from mmengine.fileio import dump
from mmengine.model.utils import revert_sync_batchnorm
+from mmengine.registry import init_default_scope
from mmengine.runner import Runner, load_checkpoint
from mmengine.utils import mkdir_or_exist
from mmseg.registry import MODELS
-from mmseg.utils import register_all_modules
def parse_args():
@@ -32,8 +32,10 @@ def parse_args():
def main():
args = parse_args()
- register_all_modules()
cfg = Config.fromfile(args.config)
+
+ init_default_scope(cfg.get('default_scope', 'mmseg'))
+
timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
if args.work_dir is not None:
mkdir_or_exist(osp.abspath(args.work_dir))
diff --git a/tools/analysis_tools/browse_dataset.py b/tools/analysis_tools/browse_dataset.py
new file mode 100644
index 0000000000..925c14a8ab
--- /dev/null
+++ b/tools/analysis_tools/browse_dataset.py
@@ -0,0 +1,77 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os.path as osp
+
+from mmengine.config import Config, DictAction
+from mmengine.utils import ProgressBar
+
+from mmseg.registry import DATASETS, VISUALIZERS
+from mmseg.utils import register_all_modules
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(description='Browse a dataset')
+ parser.add_argument('config', help='train config file path')
+ parser.add_argument(
+ '--output-dir',
+ default=None,
+ type=str,
+ help='If there is no display interface, you can save it')
+ parser.add_argument('--not-show', default=False, action='store_true')
+ parser.add_argument(
+ '--show-interval',
+ type=float,
+ default=2,
+ help='the interval of show (s)')
+ parser.add_argument(
+ '--cfg-options',
+ nargs='+',
+ action=DictAction,
+ help='override some settings in the used config, the key-value pair '
+ 'in xxx=yyy format will be merged into config file. If the value to '
+ 'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+ 'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+ 'Note that the quotation marks are necessary and that no white space '
+ 'is allowed.')
+ args = parser.parse_args()
+ return args
+
+
+def main():
+ args = parse_args()
+ cfg = Config.fromfile(args.config)
+ if args.cfg_options is not None:
+ cfg.merge_from_dict(args.cfg_options)
+
+ # register all modules in mmdet into the registries
+ register_all_modules()
+
+ dataset = DATASETS.build(cfg.train_dataloader.dataset)
+ visualizer = VISUALIZERS.build(cfg.visualizer)
+ visualizer.dataset_meta = dataset.metainfo
+
+ progress_bar = ProgressBar(len(dataset))
+ for item in dataset:
+ img = item['inputs'].permute(1, 2, 0).numpy()
+ img = img[..., [2, 1, 0]] # bgr to rgb
+ data_sample = item['data_samples'].numpy()
+ img_path = osp.basename(item['data_samples'].img_path)
+
+ out_file = osp.join(
+ args.output_dir,
+ osp.basename(img_path)) if args.output_dir is not None else None
+
+ visualizer.add_datasample(
+ name=osp.basename(img_path),
+ image=img,
+ data_sample=data_sample,
+ draw_gt=True,
+ draw_pred=False,
+ wait_time=args.show_interval,
+ out_file=out_file,
+ show=not args.not_show)
+ progress_bar.update()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/tools/dataset_converters/refuge.py b/tools/dataset_converters/refuge.py
new file mode 100644
index 0000000000..1186866ab3
--- /dev/null
+++ b/tools/dataset_converters/refuge.py
@@ -0,0 +1,110 @@
+# Copyright (c) OpenMMLab. All rights reserved.
+import argparse
+import os
+import os.path as osp
+import tempfile
+import zipfile
+
+import mmcv
+import numpy as np
+from mmengine.utils import mkdir_or_exist
+
+
+def parse_args():
+ parser = argparse.ArgumentParser(
+ description='Convert REFUGE dataset to mmsegmentation format')
+ parser.add_argument('--raw_data_root', help='the root path of raw data')
+
+ parser.add_argument('--tmp_dir', help='path of the temporary directory')
+ parser.add_argument('-o', '--out_dir', help='output path')
+ args = parser.parse_args()
+ return args
+
+
+def extract_img(root: str,
+ cur_dir: str,
+ out_dir: str,
+ mode: str = 'train',
+ file_type: str = 'img') -> None:
+ """_summary_
+
+ Args:
+ Args:
+ root (str): root where the extracted data is saved
+ cur_dir (cur_dir): dir where the zip_file exists
+ out_dir (str): root dir where the data is saved
+
+ mode (str, optional): Defaults to 'train'.
+ file_type (str, optional): Defaults to 'img',else to 'mask'.
+ """
+ zip_file = zipfile.ZipFile(cur_dir)
+ zip_file.extractall(root)
+ for cur_dir, dirs, files in os.walk(root):
+ # filter child dirs and directories with "Illustration" and "MACOSX"
+ if len(dirs) == 0 and \
+ cur_dir.split('\\')[-1].find('Illustration') == -1 and \
+ cur_dir.find('MACOSX') == -1:
+
+ file_names = [
+ file for file in files
+ if file.endswith('.jpg') or file.endswith('.bmp')
+ ]
+ for filename in sorted(file_names):
+ img = mmcv.imread(osp.join(cur_dir, filename))
+
+ if file_type == 'annotations':
+ img = img[:, :, 0]
+ img[np.where(img == 0)] = 1
+ img[np.where(img == 128)] = 2
+ img[np.where(img == 255)] = 0
+ mmcv.imwrite(
+ img,
+ osp.join(out_dir, file_type, mode,
+ osp.splitext(filename)[0] + '.png'))
+
+
+def main():
+ args = parse_args()
+
+ raw_data_root = args.raw_data_root
+ if args.out_dir is None:
+ out_dir = osp.join('./data', 'REFUGE')
+
+ else:
+ out_dir = args.out_dir
+
+ print('Making directories...')
+ mkdir_or_exist(out_dir)
+ mkdir_or_exist(osp.join(out_dir, 'images'))
+ mkdir_or_exist(osp.join(out_dir, 'images', 'training'))
+ mkdir_or_exist(osp.join(out_dir, 'images', 'validation'))
+ mkdir_or_exist(osp.join(out_dir, 'images', 'test'))
+ mkdir_or_exist(osp.join(out_dir, 'annotations'))
+ mkdir_or_exist(osp.join(out_dir, 'annotations', 'training'))
+ mkdir_or_exist(osp.join(out_dir, 'annotations', 'validation'))
+ mkdir_or_exist(osp.join(out_dir, 'annotations', 'test'))
+
+ print('Generating images and annotations...')
+ # process data from the child dir on the first rank
+ cur_dir, dirs, files = list(os.walk(raw_data_root))[0]
+ print('====================')
+
+ files = list(filter(lambda x: x.endswith('.zip'), files))
+
+ with tempfile.TemporaryDirectory(dir=args.tmp_dir) as tmp_dir:
+ for file in files:
+ # search data folders for training,validation,test
+ mode = list(
+ filter(lambda x: file.lower().find(x) != -1,
+ ['training', 'test', 'validation']))[0]
+ file_root = osp.join(tmp_dir, file[:-4])
+ file_type = 'images' if file.find('Anno') == -1 and file.find(
+ 'GT') == -1 else 'annotations'
+ extract_img(file_root, osp.join(cur_dir, file), out_dir, mode,
+ file_type)
+
+ print('Done!')
+
+
+if __name__ == '__main__':
+ main()
diff --git a/tools/misc/browse_dataset.py b/tools/misc/browse_dataset.py
index b2852c21ab..7863eb74f2 100644
--- a/tools/misc/browse_dataset.py
+++ b/tools/misc/browse_dataset.py
@@ -3,10 +3,10 @@
import os.path as osp
from mmengine import Config, DictAction
+from mmengine.registry import init_default_scope
from mmengine.utils import ProgressBar
from mmseg.registry import DATASETS, VISUALIZERS
-from mmseg.utils import register_all_modules
def parse_args():
@@ -44,7 +44,7 @@ def main():
cfg.merge_from_dict(args.cfg_options)
# register all modules in mmseg into the registries
- register_all_modules()
+ init_default_scope('mmseg')
dataset = DATASETS.build(cfg.train_dataloader.dataset)
cfg.visualizer['save_dir'] = args.output_dir
diff --git a/tools/test.py b/tools/test.py
index b21b990f26..7bfde58206 100644
--- a/tools/test.py
+++ b/tools/test.py
@@ -6,8 +6,6 @@
from mmengine.config import Config, DictAction
from mmengine.runner import Runner
-from mmseg.utils import register_all_modules
-
# TODO: support fuse_conv_bn, visualization, and format_only
def parse_args():
@@ -77,10 +75,6 @@ def trigger_visualization_hook(cfg, args):
def main():
args = parse_args()
- # register all modules in mmseg into the registries
- # do not init the default scope here because it will be init in the runner
- register_all_modules(init_default_scope=False)
-
# load config
cfg = Config.fromfile(args.config)
cfg.launcher = args.launcher
diff --git a/tools/train.py b/tools/train.py
index 172815a9fe..1721306664 100644
--- a/tools/train.py
+++ b/tools/train.py
@@ -6,10 +6,9 @@
from mmengine.config import Config, DictAction
from mmengine.logging import print_log
-from mmengine.registry import RUNNERS
from mmengine.runner import Runner
-from mmseg.utils import register_all_modules
+from mmseg.registry import RUNNERS
def parse_args():
@@ -52,10 +51,6 @@ def parse_args():
def main():
args = parse_args()
- # register all modules in mmseg into the registries
- # do not init the default scope here because it will be init in the runner
- register_all_modules(init_default_scope=False)
-
# load config
cfg = Config.fromfile(args.config)
cfg.launcher = args.launcher
+ 
+
+ 
+ 
+ 
+
+
+