class_docstr: Custom dataset for semantic segmentation. An example of file structure
  is as followed.
  
  .. code-block:: none
  
      ├── data
      │   ├── my_dataset
      │   │   ├── img_dir
      │   │   │   ├── train
      │   │   │   │   ├── xxx{img_suffix}
      │   │   │   │   ├── yyy{img_suffix}
      │   │   │   │   ├── zzz{img_suffix}
      │   │   │   ├── val
      │   │   ├── ann_dir
      │   │   │   ├── train
      │   │   │   │   ├── xxx{seg_map_suffix}
      │   │   │   │   ├── yyy{seg_map_suffix}
      │   │   │   │   ├── zzz{seg_map_suffix}
      │   │   │   ├── val
  
  The img/gt_semantic_seg pair of BaseSegDataset should be of the same
  except suffix. A valid img/gt_semantic_seg filename pair should be like
  ``xxx{img_suffix}`` and ``xxx{seg_map_suffix}`` (extension is also included
  in the suffix). If split is given, then ``xxx`` is specified in txt file.
  Otherwise, all files in ``img_dir/``and ``ann_dir`` will be loaded.
  Please refer to ``docs/en/tutorials/new_dataset.md`` for more details.
  
  
  Args:
      ann_file (str): Annotation file path. Defaults to ''.
      metainfo (dict, optional): Meta information for dataset, such as
          specify classes to load. Defaults to None.
      data_root (str, optional): The root directory for ``data_prefix`` and
          ``ann_file``. Defaults to None.
      data_prefix (dict, optional): Prefix for training data. Defaults to
          dict(img_path=None, seg_map_path=None).
      img_suffix (str): Suffix of images. Default: '.jpg'
      seg_map_suffix (str): Suffix of segmentation maps. Default: '.png'
      filter_cfg (dict, optional): Config for filter data. Defaults to None.
      indices (int or Sequence[int], optional): Support using first few
          data in annotation file to facilitate training/testing on a smaller
          dataset. Defaults to None which means using all ``data_infos``.
      serialize_data (bool, optional): Whether to hold memory using
          serialized objects, when enabled, data loader workers can use
          shared RAM from master process instead of making a copy. Defaults
          to True.
      pipeline (list, optional): Processing pipeline. Defaults to [].
      test_mode (bool, optional): ``test_mode=True`` means in test phase.
          Defaults to False.
      lazy_init (bool, optional): Whether to load annotation during
          instantiation. In some cases, such as visualization, only the meta
          information of the dataset is needed, which is not necessary to
          load annotation file. ``Basedataset`` can skip load annotations to
          save time by set ``lazy_init=True``. Defaults to False.
      use_label_map (bool, optional): Whether to use label map.
          Defaults to False.
      max_refetch (int, optional): If ``Basedataset.prepare_data`` get a
          None img. The maximum extra number of cycles to get a valid
          image. Defaults to 1000.
      backend_args (dict, Optional): Arguments to instantiate a file backend.
          See https://mmengine.readthedocs.io/en/latest/api/fileio.htm
          for details. Defaults to None.
          Notes: mmcv>=2.0.0rc4 required.
code: 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,
      use_label_map: bool = False,
      max_refetch: int = 1000,
      backend_args: Optional[dict] = None,
  ) -> None:
      self.img_suffix = img_suffix
      self.seg_map_suffix = seg_map_suffix
      self.backend_args = backend_args.copy() if backend_args else None
  
      self.data_root = data_root
      self.data_prefix = copy.copy(data_prefix)
      self.ann_file = ann_file
      self.filter_cfg = copy.deepcopy(filter_cfg)
      self._indices = indices
      self.serialize_data = serialize_data
      self.test_mode = test_mode
      self.max_refetch = max_refetch
      self.data_list: List[dict] = []
      self.data_bytes: np.ndarray
  
      # Set meta information.
      self._metainfo = self._load_metainfo(copy.deepcopy(metainfo))
  
      # Get label map for custom classes
      new_classes = self._metainfo.get("classes", None)
      self.label_map = (
          self.get_label_map(new_classes) if use_label_map else None
      )
      self._metainfo.update(dict(label_map=self.label_map))
  
      # Update palette based on label map or generate palette
      # if it is not defined
      updated_palette = self._update_palette()
      self._metainfo.update(dict(palette=updated_palette))
  
      # Join paths.
      if self.data_root is not None:
          self._join_prefix()
  
      # Build pipeline.
      self.pipeline = Compose(pipeline)
      # Full initialize the dataset.
      if not lazy_init:
          self.full_init()
  
      if test_mode:
          assert (
              self._metainfo.get("classes") is not None
          ), "dataset metainfo `classes` should be specified when testing"
  
file_path: mmdetection/mmdet/datasets/base_semseg_dataset.py
imports: import copy
  import os.path
  from typing import Callable, Dict, List, Optional, Sequence, Union
  import mmengine
  import mmengine.fileio
  import numpy
  from mmengine.dataset import BaseDataset, Compose
  from mmdet.registry import DATASETS
label_desc: Use image node_id 1 to create a new BaseSegDataset object from inherited base classes: BaseDataset with example: obj = BaseSegDataset(ann_file, img_suffix, seg_map_suffix, metainfo, data_root, data_prefix, filter_cfg, indices, serialize_data, pipeline, test_mode, lazy_init, use_label_map, max_refetch, backend_args)