class_docstr: k-Nearest Oracles Eliminate (KNORA-E).
  
  This method searches for a local Oracle, which is a base classifier
  that correctly classify all samples belonging to the region of competence
  of the test sample. All classifiers with a perfect performance in the
  region of competence are selected (local Oracles). In the case that no
  classifier achieves a perfect accuracy, the size of the competence region
  is reduced (by removing the farthest neighbor) and the performance of the
  classifiers are re-evaluated. The outputs of the selected ensemble of
  classifiers is combined using the majority voting scheme. If no base
  classifier is selected, the whole pool is used for classification.
  
  Parameters
  ----------
   pool_classifiers : list of classifiers (Default = None)
      The generated_pool of classifiers trained for the corresponding
      classification problem. Each base classifiers should support the method
      "predict". If None, then the pool of classifiers is a bagging
      classifier.
  
  k : int (Default = 7)
      Number of neighbors used to estimate the competence of the base
      classifiers.
  
  DFP : Boolean (Default = False)
      Determines if the dynamic frienemy pruning is applied.
  
  with_IH : Boolean (Default = False)
      Whether the hardness level of the region of competence is used to
      decide between using the DS algorithm or the KNN for classification of
      a given query sample.
  
  safe_k : int (default = None)
      The size of the indecision region.
  
  IH_rate : float (default = 0.3)
      Hardness threshold. If the hardness level of the competence region is
      lower than the IH_rate the KNN classifier is used. Otherwise, the DS
      algorithm is used for classification.
  
  random_state : int, RandomState instance or None, optional (default=None)
      If int, random_state is the seed used by the random number generator;
      If RandomState instance, random_state is the random number generator;
      If None, the random number generator is the RandomState instance used
      by `np.random`.
  
  knn_classifier : {'knn', 'faiss', None} (Default = 'knn')
       The algorithm used to estimate the region of competence:
  
       - 'knn' will use :class:`KNeighborsClassifier` from sklearn
        :class:`KNNE` available on `deslib.utils.knne`
  
       - 'faiss' will use Facebook's Faiss similarity search through the
         class :class:`FaissKNNClassifier`
  
       - None, will use sklearn :class:`KNeighborsClassifier`.
  
  knn_metric : {'minkowski', 'cosine', 'mahalanobis'} (Default = 'minkowski')
      The metric used by the k-NN classifier to estimate distances.
  
      - 'minkowski' will use minkowski distance.
  
      - 'cosine' will use the cosine distance.
  
      - 'mahalanobis' will use the mahalonibis distance.
  
  knne : bool (Default=False)
      Whether to use K-Nearest Neighbor Equality (KNNE) for the region
      of competence estimation.
  
  DSEL_perc : float (Default = 0.5)
      Percentage of the input data used to fit DSEL.
      Note: This parameter is only used if the pool of classifier is None or
      unfitted.
  
  voting : {'hard', 'soft'}, default='hard'
          If 'hard', uses predicted class labels for majority rule voting.
          Else if 'soft', predicts the class label based on the argmax of
          the sums of the predicted probabilities, which is recommended for
          an ensemble of well-calibrated classifiers.
  
  n_jobs : int, default=-1
      The number of parallel jobs to run. None means 1 unless in
      a joblib.parallel_backend context. -1 means using all processors.
      Doesn’t affect fit method.
  
  References
  ----------
  Ko, Albert HR, Robert Sabourin, and Alceu Souza Britto Jr.
  "From dynamic classifier selection to dynamic ensemble
  selection." Pattern Recognition 41.5 (2008): 1718-1731.
  
  Britto, Alceu S., Robert Sabourin, and Luiz ES Oliveira. "Dynamic selection
  of classifiers—a comprehensive review."
  Pattern Recognition 47.11 (2014): 3665-3680
  
  R. M. O. Cruz, R. Sabourin, and G. D. Cavalcanti, “Dynamic classifier
  selection: Recent advances and perspectives,”
  Information Fusion, vol. 41, pp. 195 – 216, 2018.
docstr: Estimate the competence of the base classifiers. In the case of
  the KNORA-E technique, the classifiers are only considered competent
  when they achieve a 100% accuracy in the region of competence.
  For each base, we estimate the maximum size of the region of competence
  that it is a local oracle. The competence level estimate is then the
  maximum size of the region of competence that the corresponding base
  classifier is considered a local Oracle.
  
  Parameters
  ----------
  competence_region : array of shape (n_samples, n_neighbors)
      Indices of the k nearest neighbors.
  
  distances : array of shape (n_samples, n_neighbors)
      Distances from the k nearest neighbors to the query.
  
  predictions : array of shape (n_samples, n_classifiers)
      Predictions of the base classifiers for all test examples.
  
  Returns
  -------
  competences : array of shape (n_samples, n_classifiers)
      Competence level estimated for each base classifier and test
      example.
docstr_tok: ["Estimate","the","competence","of","the","base","classifiers",".","In","the","case","of","the","KNORA-E","technique",",","the","classifiers","are","only","considered","competent","when","they","achieve","a","100","%","accuracy","in","the","region","of","competence",".","For","each","base",",","we","estimate","the","maximum","size","of","the","region","of","competence","that","it","is","a","local","oracle",".","The","competence","level","estimate","is","then","the","maximum","size","of","the","region","of","competence","that","the","corresponding","base","classifier","is","considered","a","local","Oracle",".","Parameters","--","--","--","--","--","competence_region",":","array","of","shape","(","n_samples",",","n_neighbors",")","Indices","of","the","k","nearest","neighbors",".","distances",":","array","of","shape","(","n_samples",",","n_neighbors",")","Distances","from","the","k","nearest","neighbors","to","the","query",".","predictions",":","array","of","shape","(","n_samples",",","n_classifiers",")","Predictions","of","the","base","classifiers","for","all","test","examples",".","Returns","--","--","--","-","competences",":","array","of","shape","(","n_samples",",","n_classifiers",")","Competence","level","estimated","for","each","base","classifier","and","test","example","."]
code: def estimate_competence(
      self, competence_region, distances=None, predictions=None
  ):
      """Estimate the competence of the base classifiers. In the case of
      the KNORA-E technique, the classifiers are only considered competent
      when they achieve a 100% accuracy in the region of competence.
      For each base, we estimate the maximum size of the region of competence
      that it is a local oracle. The competence level estimate is then the
      maximum size of the region of competence that the corresponding base
      classifier is considered a local Oracle.
  
      Parameters
      ----------
      competence_region : array of shape (n_samples, n_neighbors)
          Indices of the k nearest neighbors.
  
      distances : array of shape (n_samples, n_neighbors)
          Distances from the k nearest neighbors to the query.
  
      predictions : array of shape (n_samples, n_classifiers)
          Predictions of the base classifiers for all test examples.
  
      Returns
      -------
      competences : array of shape (n_samples, n_classifiers)
          Competence level estimated for each base classifier and test
          example.
      """
      results_neighbors = self.DSEL_processed_[competence_region, :]
  
      # Get the shape of the vector in order to know the number of samples,
      # base classifiers and neighbors considered.
      shape = results_neighbors.shape
  
      # add an row with zero for the case where the base classifier correctly
      # classifies the whole neighborhood. That way the search will always
      # find a zero after comparing to self.K + 1 and will return self.K
      # as the Competence level estimate (correctly classified the whole
      # neighborhood)
      addition = np.zeros((shape[0], shape[2]))
      results_neighbors = np.insert(
          results_neighbors, shape[1], addition, axis=1
      )
  
      # Look for the first occurrence of a zero in the processed predictions
      # (first misclassified sample). The np.argmax can be used here, since
      # in case of multiple occurrences of the maximum values, the indices_
      # corresponding to the first occurrence are returned.
      competences = np.argmax(results_neighbors == 0, axis=1)
  
      return competences.astype(float)
  
imports: import numpy
  from deslib.des.base import BaseDES
label_desc: Use image node_id 2 for calling the KNORAE obj's underlying member method code with example usage: obj.estimate_competence(competence_region, distances, predictions) and returns: competences