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 Integral, Real
  import numpy
  from sklearn.base import clone
  from sklearn.neighbors import NearestNeighbors
  from sklearn.utils import check_array, column_or_1d
  from sklearn.utils.multiclass import type_of_target
  from sklearn.utils.validation import _num_samples
  from .fixes import _is_pandas_df
label_desc: Use image node_id 14 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