code: def compute_average_precision(precision, recall):
      """Compute Average Precision according to the definition in VOCdevkit.
  
      Precision is modified to ensure that it does not decrease as recall
      decrease.
  
      Args:
        precision: A float [N, 1] numpy array of precisions
        recall: A float [N, 1] numpy array of recalls
  
      Raises:
        ValueError: if the input is not of the correct format
  
      Returns:
        average_precison: The area under the precision recall curve. NaN if
          precision and recall are None.
  
      """
      if precision is None:
          if recall is not None:
              raise ValueError(
                  "If precision is None, recall must also be None"
              )
          return np.NAN
  
      if not isinstance(precision, np.ndarray) or not isinstance(
          recall, np.ndarray
      ):
          raise ValueError("precision and recall must be numpy array")
      if precision.dtype != float or recall.dtype != float:
          raise ValueError("input must be float numpy array.")
      if len(precision) != len(recall):
          raise ValueError(
              "precision and recall must be of the same size."
          )
      if not precision.size:
          return 0.0
      if np.amin(precision) < 0 or np.amax(precision) > 1:
          raise ValueError("Precision must be in the range of [0, 1].")
      if np.amin(recall) < 0 or np.amax(recall) > 1:
          raise ValueError("recall must be in the range of [0, 1].")
      if not all(
          recall[i] <= recall[i + 1] for i in range(len(recall) - 1)
      ):
          raise ValueError("recall must be a non-decreasing array")
  
      recall = np.concatenate([[0], recall, [1]])
      precision = np.concatenate([[0], precision, [0]])
  
      # Preprocess precision to be a non-decreasing array
      for i in range(len(precision) - 2, -1, -1):
          precision[i] = np.maximum(precision[i], precision[i + 1])
  
      indices = np.where(recall[1:] != recall[:-1])[0] + 1
      average_precision = np.sum(
          (recall[indices] - recall[indices - 1]) * precision[indices]
      )
      return average_precision
  
imports: from __future__ import division
  import numpy
label_desc: Use image node_id 2 for calling a global function with example usage: compute_average_precision(precision, recall) and returns: average_precision, np, int