code: def check_sampling_strategy(
      sampling_strategy, y, sampling_type, **kwargs
  ):
      """Sampling target validation for samplers.
  
      Checks that ``sampling_strategy`` is of consistent type and return a
      dictionary containing each targeted class with its corresponding
      number of sample. It is used in :class:`~imblearn.base.BaseSampler`.
  
      Parameters
      ----------
      sampling_strategy : float, str, dict, list or callable,
          Sampling information to sample the data set.
  
          - When ``float``:
  
              For **under-sampling methods**, it corresponds to the ratio
              :math:`\\alpha_{us}` defined by :math:`N_{rM} = \\alpha_{us}
              \\times N_{m}` where :math:`N_{rM}` and :math:`N_{m}` are the
              number of samples in the majority class after resampling and the
              number of samples in the minority class, respectively;
  
              For **over-sampling methods**, it correspond to the ratio
              :math:`\\alpha_{os}` defined by :math:`N_{rm} = \\alpha_{os}
              \\times N_{m}` where :math:`N_{rm}` and :math:`N_{M}` are the
              number of samples in the minority class after resampling and the
              number of samples in the majority class, respectively.
  
              .. warning::
                 ``float`` is only available for **binary** classification. An
                 error is raised for multi-class classification and with cleaning
                 samplers.
  
          - When ``str``, specify the class targeted by the resampling. For
            **under- and over-sampling methods**, the number of samples in the
            different classes will be equalized. For **cleaning methods**, the
            number of samples will not be equal. Possible choices are:
  
              ``'minority'``: resample only the minority class;
  
              ``'majority'``: resample only the majority class;
  
              ``'not minority'``: resample all classes but the minority class;
  
              ``'not majority'``: resample all classes but the majority class;
  
              ``'all'``: resample all classes;
  
              ``'auto'``: for under-sampling methods, equivalent to ``'not
              minority'`` and for over-sampling methods, equivalent to ``'not
              majority'``.
  
          - When ``dict``, the keys correspond to the targeted classes. The
            values correspond to the desired number of samples for each targeted
            class.
  
            .. warning::
               ``dict`` is available for both **under- and over-sampling
               methods**. An error is raised with **cleaning methods**. Use a
               ``list`` instead.
  
          - When ``list``, the list contains the targeted classes. It used only
            for **cleaning methods**.
  
            .. warning::
               ``list`` is available for **cleaning methods**. An error is raised
               with **under- and over-sampling methods**.
  
          - When callable, function taking ``y`` and returns a ``dict``. The keys
            correspond to the targeted classes. The values correspond to the
            desired number of samples for each class.
  
      y : ndarray of shape (n_samples,)
          The target array.
  
      sampling_type : {{'over-sampling', 'under-sampling', 'clean-sampling'}}
          The type of sampling. Can be either ``'over-sampling'``,
          ``'under-sampling'``, or ``'clean-sampling'``.
  
      **kwargs : dict
          Dictionary of additional keyword arguments to pass to
          ``sampling_strategy`` when this is a callable.
  
      Returns
      -------
      sampling_strategy_converted : dict
          The converted and validated sampling target. Returns a dictionary with
          the key being the class target and the value being the desired
          number of samples.
      """
      if sampling_type not in SAMPLING_KIND:
          raise ValueError(
              f"'sampling_type' should be one of {SAMPLING_KIND}. "
              f"Got '{sampling_type} instead."
          )
  
      if np.unique(y).size <= 1:
          raise ValueError(
              f"The target 'y' needs to have more than 1 class. "
              f"Got {np.unique(y).size} class instead"
          )
  
      if sampling_type in ("ensemble", "bypass"):
          return sampling_strategy
  
      if isinstance(sampling_strategy, str):
          if sampling_strategy not in SAMPLING_TARGET_KIND.keys():
              raise ValueError(
                  f"When 'sampling_strategy' is a string, it needs"
                  f" to be one of {SAMPLING_TARGET_KIND}. Got '{sampling_strategy}' "
                  f"instead."
              )
          return OrderedDict(
              sorted(
                  SAMPLING_TARGET_KIND[sampling_strategy](
                      y, sampling_type
                  ).items()
              )
          )
      elif isinstance(sampling_strategy, dict):
          return OrderedDict(
              sorted(
                  _sampling_strategy_dict(
                      sampling_strategy, y, sampling_type
                  ).items()
              )
          )
      elif isinstance(sampling_strategy, list):
          return OrderedDict(
              sorted(
                  _sampling_strategy_list(
                      sampling_strategy, y, sampling_type
                  ).items()
              )
          )
      elif isinstance(sampling_strategy, Real):
          if sampling_strategy <= 0 or sampling_strategy > 1:
              raise ValueError(
                  f"When 'sampling_strategy' is a float, it should be "
                  f"in the range (0, 1]. Got {sampling_strategy} instead."
              )
          return OrderedDict(
              sorted(
                  _sampling_strategy_float(
                      sampling_strategy, y, sampling_type
                  ).items()
              )
          )
      elif callable(sampling_strategy):
          sampling_strategy_ = sampling_strategy(y, **kwargs)
          return OrderedDict(
              sorted(
                  _sampling_strategy_dict(
                      sampling_strategy_, y, sampling_type
                  ).items()
              )
          )
  
imports: import warnings
  from collections import OrderedDict
  from functools import wraps
  from inspect import Parameter, signature
  from numbers import Real
  from typing import Any, Dict
  import numpy
  from sklearn.utils import column_or_1d
  from sklearn.utils.multiclass import type_of_target
label_desc: Use image node_id 11 for calling a global function with example usage: check_sampling_strategy(sampling_strategy, y, sampling_type) and returns: sampling_strategy, OrderedDict, OrderedDict, OrderedDict, OrderedDict, OrderedDict