code: def roc_auc_score(
      y_true, y_score, average="macro", sample_weight=None
  ):
      """Compute Area Under the Curve (AUC) from prediction scores
  
      Note: this implementation is restricted to the binary classification task
      or multilabel classification task in label indicator format.
  
      Read more in the :ref:`User Guide <roc_metrics>`.
  
      Parameters
      ----------
      y_true : array, shape = [n_samples] or [n_samples, n_classes]
          True binary labels in binary label indicators.
  
      y_score : array, shape = [n_samples] or [n_samples, n_classes]
          Target scores, can either be probability estimates of the positive
          class, confidence values, or non-thresholded measure of decisions
          (as returned by "decision_function" on some classifiers).
  
      average : string, [None, 'micro', 'macro' (default), 'samples', 'weighted']
          If ``None``, the scores for each class are returned. Otherwise,
          this determines the type of averaging performed on the data:
  
          ``'micro'``:
              Calculate metrics globally by considering each element of the label
              indicator matrix as a label.
          ``'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).
          ``'samples'``:
              Calculate metrics for each instance, and find their average.
  
      sample_weight : array-like of shape = [n_samples], optional
          Sample weights.
  
      Returns
      -------
      auc : float
  
      References
      ----------
      .. [1] `Wikipedia entry for the Receiver operating characteristic
              <https://en.wikipedia.org/wiki/Receiver_operating_characteristic>`_
  
      See also
      --------
      average_precision_score : Area under the precision-recall curve
  
      roc_curve : Compute Receiver operating characteristic (ROC)
  
      Examples
      --------
      >>> import numpy as np
      >>> from sklearn.metrics import roc_auc_score
      >>> y_true = np.array([0, 0, 1, 1])
      >>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
      >>> roc_auc_score(y_true, y_scores)
      0.75
  
      """
  
      def _binary_roc_auc_score(y_true, y_score, sample_weight=None):
          if len(np.unique(y_true)) != 2:
              raise ValueError(
                  "Only one class present in y_true. ROC AUC score "
                  "is not defined in that case."
              )
  
          fpr, tpr, tresholds = roc_curve(
              y_true, y_score, sample_weight=sample_weight
          )
          return auc(fpr, tpr, reorder=True)
  
      return _average_binary_score(
          _binary_roc_auc_score,
          y_true,
          y_score,
          average,
          sample_weight=sample_weight,
      )
  
imports: from __future__ import division
  import warnings
  import numpy
  from scipy.sparse import csr_matrix
  from ..utils import assert_all_finite
  from ..utils import check_consistent_length
  from ..utils import column_or_1d, check_array
  from ..utils.multiclass import type_of_target
  from ..utils.extmath import stable_cumsum
  from ..utils.fixes import bincount
  from ..utils.fixes import array_equal
  from ..utils.stats import rankdata
  from ..utils.sparsefuncs import count_nonzero
  from ..exceptions import UndefinedMetricWarning
  from .base import _average_binary_score
label_desc: Use image node_id 3 for calling a global function with example usage: roc_auc_score(y_true, y_score, average, sample_weight) and returns: _average_binary_score, auc