code: def get_scorers_dict(
      dataset: VisionData,
      alternative_scorers: t.Union[
          t.Dict[str, t.Union[Metric, str]],
          t.List[t.Union[Metric, str]],
      ] = None,
  ) -> t.Dict[str, Metric]:
      """Get scorers list according to model object and label column.
  
      Parameters
      ----------
      dataset : VisionData
          Dataset object
      alternative_scorers: Union[Dict[str, Union[Callable, str]], List[Any]] , default: None
          Scorers to override the default scorers (metrics), find more about the supported formats at
          https://docs.deepchecks.com/stable/user-guide/general/metrics_guide.html
      Returns
      -------
      t.Dict[str, Metric]
          Scorers list
      """
      task_type = dataset.task_type
  
      if alternative_scorers:
          # For alternative scorers we create a copy since in suites we are running in parallel, so we can't use the same
          # instance for several checks.
          if isinstance(alternative_scorers, list):
              alternative_scorers = {
                  get_scorer_name(scorer): scorer
                  for scorer in alternative_scorers
              }
          scorers = {}
          for name, metric in alternative_scorers.items():
              # Validate that each alternative scorer is a correct type
              if isinstance(metric, (Metric, CustomMetric)):
                  metric.reset()
                  scorers[name] = copy(metric)
              elif isinstance(metric, str):
                  metric_name = (
                      metric.lower()
                      .replace(" ", "_")
                      .replace("sensitivity", "recall")
                  )
                  if (
                      task_type == TaskType.OBJECT_DETECTION
                      and metric_name in detection_dict
                  ):
                      converted_met = detection_dict[metric_name]()
                  elif task_type == TaskType.CLASSIFICATION:
                      converted_met = CustomClassificationScorer(metric)
                  elif task_type == TaskType.SEMANTIC_SEGMENTATION:
                      converted_met = semantic_segmentation_dict[
                          metric_name
                      ]()
                  else:
                      raise DeepchecksNotSupportedError(
                          f"Unsupported metric: {name} of type {type(metric).__name__} was given."
                      )
                  scorers[name] = converted_met
              elif isinstance(metric, t.Callable):
                  if task_type == TaskType.CLASSIFICATION:
                      scorers[name] = CustomClassificationScorer(metric)
                  else:
                      raise DeepchecksNotSupportedError(
                          "Custom scikit-learn scorers are only supported for"
                          " classification."
                      )
              else:
                  raise DeepchecksValueError(
                      f"Excepted metric type one of [ignite.Metric, callable, str], was {type(metric).__name__}."
                  )
          return scorers
      elif task_type == TaskType.CLASSIFICATION:
          scorers = get_default_classification_scorers()
      elif task_type == TaskType.OBJECT_DETECTION:
          scorers = get_default_object_detection_scorers()
      elif task_type == TaskType.SEMANTIC_SEGMENTATION:
          scorers = get_default_semantic_segmentation_scorers()
      else:
          raise DeepchecksNotSupportedError(
              f"No scorers match task_type {task_type}"
          )
  
      return scorers
  
file_path: deepchecks/deepchecks/vision/metrics_utils/scorers.py
imports: import typing
  from copy import copy
  from numbers import Number
  import numpy
  import pandas
  import torch
  from ignite.metrics import Metric
  from deepchecks.core import DatasetKind
  from deepchecks.core.errors import DeepchecksNotSupportedError, DeepchecksValueError
  from deepchecks.utils.metrics import get_scorer_name
  from deepchecks.vision.metrics_utils import CustomClassificationScorer, CustomMetric, ObjectDetectionAveragePrecision, ObjectDetectionTpFpFn
  from deepchecks.vision.metrics_utils.semantic_segmentation_metrics import MeanDice, MeanIoU
  from deepchecks.vision.vision_data import TaskType, VisionData
label_desc: Use image node_id 4 for calling a global function with example usage: get_scorers_dict(dataset, alternative_scorers) and returns: scorers, scorers