code: def roc_curve(
      y_true,
      y_score,
      pos_label=None,
      sample_weight=None,
      drop_intermediate=True,
  ):
      """Compute Receiver operating characteristic (ROC)
  
      Note: this implementation is restricted to the binary classification task.
  
      Read more in the :ref:`User Guide <roc_metrics>`.
  
      Parameters
      ----------
  
      y_true : array, shape = [n_samples]
          True binary labels in range {0, 1} or {-1, 1}.  If labels are not
          binary, pos_label should be explicitly given.
  
      y_score : array, shape = [n_samples]
          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).
  
      pos_label : int or str, default=None
          Label considered as positive and others are considered negative.
  
      sample_weight : array-like of shape = [n_samples], optional
          Sample weights.
  
      drop_intermediate : boolean, optional (default=True)
          Whether to drop some suboptimal thresholds which would not appear
          on a plotted ROC curve. This is useful in order to create lighter
          ROC curves.
  
          .. versionadded:: 0.17
             parameter *drop_intermediate*.
  
      Returns
      -------
      fpr : array, shape = [>2]
          Increasing false positive rates such that element i is the false
          positive rate of predictions with score >= thresholds[i].
  
      tpr : array, shape = [>2]
          Increasing true positive rates such that element i is the true
          positive rate of predictions with score >= thresholds[i].
  
      thresholds : array, shape = [n_thresholds]
          Decreasing thresholds on the decision function used to compute
          fpr and tpr. `thresholds[0]` represents no instances being predicted
          and is arbitrarily set to `max(y_score) + 1`.
  
      See also
      --------
      roc_auc_score : Compute Area Under the Curve (AUC) from prediction scores
  
      Notes
      -----
      Since the thresholds are sorted from low to high values, they
      are reversed upon returning them to ensure they correspond to both ``fpr``
      and ``tpr``, which are sorted in reversed order during their calculation.
  
      References
      ----------
      .. [1] `Wikipedia entry for the Receiver operating characteristic
              <https://en.wikipedia.org/wiki/Receiver_operating_characteristic>`_
  
  
      Examples
      --------
      >>> import numpy as np
      >>> from sklearn import metrics
      >>> y = np.array([1, 1, 2, 2])
      >>> scores = np.array([0.1, 0.4, 0.35, 0.8])
      >>> fpr, tpr, thresholds = metrics.roc_curve(y, scores, pos_label=2)
      >>> fpr
      array([ 0. ,  0.5,  0.5,  1. ])
      >>> tpr
      array([ 0.5,  0.5,  1. ,  1. ])
      >>> thresholds
      array([ 0.8 ,  0.4 ,  0.35,  0.1 ])
  
      """
      fps, tps, thresholds = _binary_clf_curve(
          y_true,
          y_score,
          pos_label=pos_label,
          sample_weight=sample_weight,
      )
  
      # Attempt to drop thresholds corresponding to points in between and
      # collinear with other points. These are always suboptimal and do not
      # appear on a plotted ROC curve (and thus do not affect the AUC).
      # Here np.diff(_, 2) is used as a "second derivative" to tell if there
      # is a corner at the point. Both fps and tps must be tested to handle
      # thresholds with multiple data points (which are combined in
      # _binary_clf_curve). This keeps all cases where the point should be kept,
      # but does not drop more complicated cases like fps = [1, 3, 7],
      # tps = [1, 2, 4]; there is no harm in keeping too many thresholds.
      if drop_intermediate and len(fps) > 2:
          optimal_idxs = np.where(
              np.r_[
                  True,
                  np.logical_or(np.diff(fps, 2), np.diff(tps, 2)),
                  True,
              ]
          )[0]
          fps = fps[optimal_idxs]
          tps = tps[optimal_idxs]
          thresholds = thresholds[optimal_idxs]
  
      if tps.size == 0 or fps[0] != 0:
          # Add an extra threshold position if necessary
          tps = np.r_[0, tps]
          fps = np.r_[0, fps]
          thresholds = np.r_[thresholds[0] + 1, thresholds]
  
      if fps[-1] <= 0:
          warnings.warn(
              "No negative samples in y_true, "
              "false positive value should be meaningless",
              UndefinedMetricWarning,
          )
          fpr = np.repeat(np.nan, fps.shape)
      else:
          fpr = fps / fps[-1]
  
      if tps[-1] <= 0:
          warnings.warn(
              "No positive samples in y_true, "
              "true positive value should be meaningless",
              UndefinedMetricWarning,
          )
          tpr = np.repeat(np.nan, tps.shape)
      else:
          tpr = tps / tps[-1]
  
      return fpr, tpr, thresholds
  
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 6 for calling a global function with example usage: roc_curve(y_true, y_score, pos_label, sample_weight, drop_intermediate) and returns: fpr,  tpr,  thresholds