code: def auc(x, y, session=None, run_kwargs=None):
      """Compute Area Under the Curve (AUC) using the trapezoidal rule
  
      This is a general function, given points on a curve.  For computing the
      area under the ROC-curve, see :func:`roc_auc_score`.  For an alternative
      way to summarize a precision-recall curve, see
      :func:`average_precision_score`.
  
      Parameters
      ----------
      x : tensor, shape = [n]
          x coordinates. These must be either monotonic increasing or monotonic
          decreasing.
      y : tensor, shape = [n]
          y coordinates.
  
      Returns
      -------
      auc : tensor, with float value
  
      Examples
      --------
      >>> import mars.tensor as mt
      >>> from mars.learn import metrics
      >>> y = mt.array([1, 1, 2, 2])
      >>> pred = mt.array([0.1, 0.4, 0.35, 0.8])
      >>> fpr, tpr, thresholds = metrics.roc_curve(y, pred, pos_label=2)
      >>> metrics.auc(fpr, tpr)
      0.75
  
      See also
      --------
      roc_auc_score : Compute the area under the ROC curve
      average_precision_score : Compute average precision from prediction scores
      precision_recall_curve :
          Compute precision-recall pairs for different probability thresholds
      """
      check_consistent_length(x, y)
      x = column_or_1d(x)
      y = column_or_1d(y)
  
      if x.shape[0] < 2:
          raise ValueError(
              "At least 2 points are needed to compute"
              f" area under curve, but x.shape = {x.shape}"
          )
  
      direction = 1
      dx = mt.diff(x)
      any_dx_lt_0 = mt.any(dx < 0)
      all_dx_le_0 = mt.all(dx <= 0)
      mt.ExecutableTuple([x, any_dx_lt_0, all_dx_le_0]).execute(
          session=session, **(run_kwargs or dict())
      )
      if any_dx_lt_0.fetch(session=session):
          if all_dx_le_0.fetch(session=session):
              direction = -1
          else:
              x_data = x.fetch(session=session)
              raise ValueError(
                  f"x is neither increasing nor decreasing : {x_data}."
              )
  
      area = direction * mt.trapz(y, x)
      return area.execute(session=session, **(run_kwargs or dict()))
  
file_path: mars/mars/learn/metrics/_ranking.py
imports: import warnings
  from functools import partial
  import numpy
  from ...None import execute, fetch
  from ...None import tensor
  from ...utils import cache_tileables
  from ..preprocessing import label_binarize
  from ..utils._encode import _encode, _unique
  from ..utils.checks import assert_all_finite
  from ..utils.core import sort_by
  from ..utils.multiclass import type_of_target
  from ..utils.validation import check_array, check_consistent_length, column_or_1d
  from ._base import _average_binary_score, _average_multiclass_ovo_score
label_desc: Use image node_id 1 for calling a global function with example usage: auc(x, y, session, run_kwargs) and returns: area