code: def sensitivity_specificity_support(
      y_true,
      y_pred,
      *,
      labels=None,
      pos_label=1,
      average=None,
      warn_for=("sensitivity", "specificity"),
      sample_weight=None,
  ):
      """Compute sensitivity, specificity, and support for each class.
  
      The sensitivity is the ratio ``tp / (tp + fn)`` where ``tp`` is the number
      of true positives and ``fn`` the number of false negatives. The sensitivity
      quantifies the ability to avoid false negatives_[1].
  
      The specificity is the ratio ``tn / (tn + fp)`` where ``tn`` is the number
      of true negatives and ``fn`` the number of false negatives. The specificity
      quantifies the ability to avoid false positives_[1].
  
      The support is the number of occurrences of each class in ``y_true``.
  
      If ``pos_label is None`` and in binary classification, this function
      returns the average sensitivity and specificity if ``average``
      is one of ``'weighted'``.
  
      Read more in the :ref:`User Guide <sensitivity_specificity>`.
  
      Parameters
      ----------
      y_true : array-like of shape (n_samples,)
          Ground truth (correct) target values.
  
      y_pred : array-like of shape (n_samples,)
          Estimated targets as returned by a classifier.
  
      labels : array-like, default=None
          The set of labels to include when ``average != 'binary'``, and their
          order if ``average is None``. Labels present in the data can be
          excluded, for example to calculate a multiclass average ignoring a
          majority negative class, while labels not present in the data will
          result in 0 components in a macro average. For multilabel targets,
          labels are column indices. By default, all labels in ``y_true`` and
          ``y_pred`` are used in sorted order.
  
      pos_label : str, int or None, default=1
          The class to report if ``average='binary'`` and the data is binary.
          If ``pos_label is None`` and in binary classification, this function
          returns the average sensitivity and specificity if ``average``
          is one of ``'weighted'``.
          If the data are multiclass, this will be ignored;
          setting ``labels=[pos_label]`` and ``average != 'binary'`` will report
          scores for that label only.
  
      average : str, default=None
          If ``None``, the scores for each class are returned. Otherwise, this
          determines the type of averaging performed on the data:
  
          ``'binary'``:
              Only report results for the class specified by ``pos_label``.
              This is applicable only if targets (``y_{true,pred}``) are binary.
          ``'micro'``:
              Calculate metrics globally by counting the total true positives,
              false negatives and false positives.
          ``'macro'``:
              Calculate metrics for each label, and find their unweighted
              mean.  This does not take label imbalance into account.
          ``'weighted'``:
              Calculate metrics for each label, and find their average, weighted
              by support (the number of true instances for each label). This
              alters 'macro' to account for label imbalance; it can result in an
              F-score that is not between precision and recall.
          ``'samples'``:
              Calculate metrics for each instance, and find their average (only
              meaningful for multilabel classification where this differs from
              :func:`accuracy_score`).
  
      warn_for : tuple or set of {{"sensitivity", "specificity"}}, for internal use
          This determines which warnings will be made in the case that this
          function is being used to return only one of its metrics.
  
      sample_weight : array-like of shape (n_samples,), default=None
          Sample weights.
  
      Returns
      -------
      sensitivity : float (if `average is None`) or ndarray of \
              shape (n_unique_labels,)
          The sensitivity metric.
  
      specificity : float (if `average is None`) or ndarray of \
              shape (n_unique_labels,)
          The specificity metric.
  
      support : int (if `average is None`) or ndarray of \
              shape (n_unique_labels,)
          The number of occurrences of each label in ``y_true``.
  
      References
      ----------
      .. [1] `Wikipedia entry for the Sensitivity and specificity
             <https://en.wikipedia.org/wiki/Sensitivity_and_specificity>`_
  
      Examples
      --------
      >>> import numpy as np
      >>> from imblearn.metrics import sensitivity_specificity_support
      >>> y_true = np.array(['cat', 'dog', 'pig', 'cat', 'dog', 'pig'])
      >>> y_pred = np.array(['cat', 'pig', 'dog', 'cat', 'cat', 'dog'])
      >>> sensitivity_specificity_support(y_true, y_pred, average='macro')
      (0.33..., 0.66..., None)
      >>> sensitivity_specificity_support(y_true, y_pred, average='micro')
      (0.33..., 0.66..., None)
      >>> sensitivity_specificity_support(y_true, y_pred, average='weighted')
      (0.33..., 0.66..., None)
      """
      average_options = (None, "micro", "macro", "weighted", "samples")
      if average not in average_options and average != "binary":
          raise ValueError(
              "average has to be one of " + str(average_options)
          )
  
      y_type, y_true, y_pred = _check_targets(y_true, y_pred)
      present_labels = unique_labels(y_true, y_pred)
  
      if average == "binary":
          if y_type == "binary":
              if pos_label not in present_labels:
                  if len(present_labels) < 2:
                      # Only negative labels
                      return (0.0, 0.0, 0)
                  else:
                      raise ValueError(
                          "pos_label=%r is not a valid label: %r"
                          % (pos_label, present_labels)
                      )
              labels = [pos_label]
          else:
              raise ValueError(
                  "Target is %s but average='binary'. Please "
                  "choose another average setting." % y_type
              )
      elif pos_label not in (None, 1):
          warnings.warn(
              "Note that pos_label (set to %r) is ignored when "
              "average != 'binary' (got %r). You may use "
              "labels=[pos_label] to specify a single positive class."
              % (pos_label, average),
              UserWarning,
          )
  
      if labels is None:
          labels = present_labels
          n_labels = None
      else:
          n_labels = len(labels)
          labels = np.hstack(
              [
                  labels,
                  np.setdiff1d(
                      present_labels, labels, assume_unique=True
                  ),
              ]
          )
  
      # Calculate tp_sum, pred_sum, true_sum ###
  
      if y_type.startswith("multilabel"):
          raise ValueError("imblearn does not support multilabel")
      elif average == "samples":
          raise ValueError(
              "Sample-based precision, recall, fscore is "
              "not meaningful outside multilabel "
              "classification. See the accuracy_score instead."
          )
      else:
          le = LabelEncoder()
          le.fit(labels)
          y_true = le.transform(y_true)
          y_pred = le.transform(y_pred)
          sorted_labels = le.classes_
  
          # labels are now from 0 to len(labels) - 1 -> use bincount
          tp = y_true == y_pred
          tp_bins = y_true[tp]
          if sample_weight is not None:
              tp_bins_weights = np.asarray(sample_weight)[tp]
          else:
              tp_bins_weights = None
  
          if len(tp_bins):
              tp_sum = np.bincount(
                  tp_bins,
                  weights=tp_bins_weights,
                  minlength=len(labels),
              )
          else:
              # Pathological case
              true_sum = pred_sum = tp_sum = np.zeros(len(labels))
          if len(y_pred):
              pred_sum = np.bincount(
                  y_pred, weights=sample_weight, minlength=len(labels)
              )
          if len(y_true):
              true_sum = np.bincount(
                  y_true, weights=sample_weight, minlength=len(labels)
              )
  
          # Compute the true negative
          tn_sum = y_true.size - (pred_sum + true_sum - tp_sum)
  
          # Retain only selected labels
          indices = np.searchsorted(sorted_labels, labels[:n_labels])
          tp_sum = tp_sum[indices]
          true_sum = true_sum[indices]
          pred_sum = pred_sum[indices]
          tn_sum = tn_sum[indices]
  
      if average == "micro":
          tp_sum = np.array([tp_sum.sum()])
          pred_sum = np.array([pred_sum.sum()])
          true_sum = np.array([true_sum.sum()])
          tn_sum = np.array([tn_sum.sum()])
  
      # Finally, we have all our sufficient statistics. Divide! #
  
      with np.errstate(divide="ignore", invalid="ignore"):
          # Divide, and on zero-division, set scores to 0 and warn:
  
          # Oddly, we may get an "invalid" rather than a "divide" error
          # here.
          specificity = _prf_divide(
              tn_sum,
              tn_sum + pred_sum - tp_sum,
              "specificity",
              "predicted",
              average,
              warn_for,
          )
          sensitivity = _prf_divide(
              tp_sum, true_sum, "sensitivity", "true", average, warn_for
          )
  
      # Average the results
  
      if average == "weighted":
          weights = true_sum
          if weights.sum() == 0:
              return 0, 0, None
      elif average == "samples":
          weights = sample_weight
      else:
          weights = None
  
      if average is not None:
          assert average != "binary" or len(specificity) == 1
          specificity = np.average(specificity, weights=weights)
          sensitivity = np.average(sensitivity, weights=weights)
          true_sum = None  # return no support
  
      return sensitivity, specificity, true_sum
  
file_path: imbalanced-learn/imblearn/metrics/_classification.py
imports: import functools
  import numbers
  import warnings
  from inspect import signature
  import numpy
  import scipy
  from sklearn.metrics import mean_absolute_error, precision_recall_fscore_support
  from sklearn.metrics._classification import _check_targets, _prf_divide
  from sklearn.preprocessing import LabelEncoder
  from sklearn.utils.multiclass import unique_labels
  from sklearn.utils.validation import check_consistent_length, column_or_1d
  from ..utils._param_validation import Interval, StrOptions, validate_params
label_desc: Use image node_id 1 for calling a global function with example usage: sensitivity_specificity_support(y_true, y_pred) and returns: sensitivity,  specificity,  true_sum, int,  int,  None, int,  int,  int