code: def specificity_score(
      y_true,
      y_pred,
      *,
      labels=None,
      pos_label=1,
      average="binary",
      sample_weight=None,
  ):
      """Compute the specificity.
  
      The specificity is the ratio ``tn / (tn + fp)`` where ``tn`` is the number
      of true negatives and ``fp`` the number of false positives. The specificity
      quantifies the ability to avoid false positives.
  
      The best value is 1 and the worst value is 0.
  
      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.
  
      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 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`).
  
      sample_weight : array-like of shape (n_samples,), default=None
          Sample weights.
  
      Returns
      -------
      specificity : float (if `average is None`) or ndarray of \
              shape (n_unique_labels,)
          The specificity metric.
  
      Examples
      --------
      >>> import numpy as np
      >>> from imblearn.metrics import specificity_score
      >>> y_true = [0, 1, 2, 0, 1, 2]
      >>> y_pred = [0, 2, 1, 0, 0, 1]
      >>> specificity_score(y_true, y_pred, average='macro')
      0.66...
      >>> specificity_score(y_true, y_pred, average='micro')
      0.66...
      >>> specificity_score(y_true, y_pred, average='weighted')
      0.66...
      >>> specificity_score(y_true, y_pred, average=None)
      array([0.75, 0.5 , 0.75])
      """
      _, s, _ = sensitivity_specificity_support(
          y_true,
          y_pred,
          labels=labels,
          pos_label=pos_label,
          average=average,
          warn_for=("specificity",),
          sample_weight=sample_weight,
      )
  
      return s
  
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 3 for calling a global function with example usage: specificity_score(y_true, y_pred) and returns: s