code: def average_precision_score(
      y_true, y_score, average="macro", sample_weight=None
  ):
      """Compute average precision (AP) from prediction scores
  
      This score corresponds to the area under the precision-recall curve.
  
      Note: this implementation is restricted to the binary classification task
      or multilabel classification task.
  
      Read more in the :ref:`User Guide <precision_recall_f_measure_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
      -------
      average_precision : float
  
      References
      ----------
      .. [1] `Wikipedia entry for the Average precision
             <https://en.wikipedia.org/wiki/Average_precision>`_
  
      See also
      --------
      roc_auc_score : Area under the ROC curve
  
      precision_recall_curve :
          Compute precision-recall pairs for different probability thresholds
  
      Examples
      --------
      >>> import numpy as np
      >>> from sklearn.metrics import average_precision_score
      >>> y_true = np.array([0, 0, 1, 1])
      >>> y_scores = np.array([0.1, 0.4, 0.35, 0.8])
      >>> average_precision_score(y_true, y_scores)  # doctest: +ELLIPSIS
      0.79...
  
      """
  
      def _binary_average_precision(
          y_true, y_score, sample_weight=None
      ):
          precision, recall, thresholds = precision_recall_curve(
              y_true, y_score, sample_weight=sample_weight
          )
          return auc(recall, precision)
  
      return _average_binary_score(
          _binary_average_precision,
          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 2 for calling a global function with example usage: average_precision_score(y_true, y_score, average, sample_weight) and returns: _average_binary_score, auc