code: def _process_predictions(
      y: np.array, y_pred1: np.array, y_pred2: np.array
  ) -> np.array:
      """Pre-process the predictions of a pair of base classifiers for the
      computation of the diversity measures
  
      Parameters
      ----------
      y : array of shape (n_samples,):
          class labels of each sample.
  
      y_pred1 : array of shape (n_samples,):
                predicted class labels by the classifier 1 for each sample.
  
  
      y_pred2 : array of shape (n_classifiers, n_samples):
                predicted class labels by the classifier 2 for each sample.
  
      Returns
      -------
      N00 : Array of shape (n_samples,)
          Percentage of samples that both classifiers predict the wrong label
  
      N10 : Array of shape (n_samples,)
          Percentage of samples that only classifier 2 predicts the wrong label
  
      N01 : Array of shape (n_samples,)
          Percentage of samples that only classifier 1 predicts the wrong label
  
      N11 : Array of shape (n_samples,)
          Percentage of samples that both classifiers predict the correct label
      """
  
      _, n_samples = y_pred2.shape
  
      if n_samples == 0:
          raise ValueError("Need at least one sample.")
      if n_samples != len(y_pred1) or n_samples != len(y):
          raise ValueError(
              "Inconsistent number of samples between "
              "class labels and predictions."
          )
  
      classifier_1_votes = y != y_pred1
      classifier_2_votes = y != y_pred2
  
      mismatch = classifier_1_votes != classifier_2_votes
  
      classifier_1_mismatch_error = np.logical_and(
          classifier_1_votes, mismatch
      )
      classifier_2_mismatch_error = np.logical_and(
          classifier_2_votes, mismatch
      )
  
      N01 = np.sum(classifier_1_mismatch_error, axis=1) / n_samples
      N10 = np.sum(classifier_2_mismatch_error, axis=1) / n_samples
  
      matching = np.invert(mismatch)
      n_matching = np.sum(matching, axis=1)
  
      both_incorrect = np.logical_and(classifier_1_votes, matching).sum(
          axis=1
      )
  
      N00 = both_incorrect / n_samples
      N11 = (n_matching - both_incorrect) / n_samples
  
      return N00, N10, N01, N11
  
file_path: DESlib/deslib/util/diversity_batch.py
imports: import sys
  import numpy
label_desc: Use image node_id 1 for calling a global function with example usage: _process_predictions(y, y_pred1, y_pred2) and returns: N00,  N10,  N01,  N11