class_docstr: A Posteriori Dynamic classifier selection.
  
  The A Posteriori method uses the probability of correct classification of a
  given base classifier :math:`c_{i}` for each neighbor :math:`x_{k}` with
  respect to a single class. Consider a classifier :math:`c_{i}` that assigns
  a test sample to class :math:`w_{l}`. Then, only the samples belonging to
  class :math:`w_{l}` are taken into account during the competence level
  estimates. Base classifiers with a higher probability of correct
  classification have a higher competence level. Moreover, the method also
  weights the influence of each neighbor :math:`x_{k}` according to its
  Euclidean distance to the query sample. The closest neighbors have a higher
  influence on the competence level estimate. In cases where no sample in the
  region of competence belongs to the predicted class, :math:`w_{l}`, the
  competence level estimate of the base classifier is equal to zero.
  
  A single classifier is selected only if its competence level is
  significantly higher than that of the other base classifiers in the pool
  (higher than a pre-defined threshold). Otherwise, all classifiers in the
  pool are combined using the majority voting rule. The selection methodology
  can be modified by modifying the hyper-parameter selection_method.
  
  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" and "predict_proba". 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.
  
  selection_method : String (Default = "best")
      Determines which method is used to select the base classifier after
      the competences are estimated.
  
  diff_thresh : float (Default = 0.1)
      Threshold to measure the difference between the competence level of the
      base classifiers for the random and diff selection schemes. If the
      difference is lower than the threshold, their performance are
      considered equivalent.
  
  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.
  
  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
  ----------
  G. Giacinto and F. Roli, Methods for Dynamic Classifier Selection
  10th Int. Conf. on Image Anal. and Proc., Venice, Italy (1999), 659-664.
  
  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: Prepare the DS model by setting the KNN algorithm and
  pre-processing the information required to apply the DS
  method.
  
  Parameters
  ----------
  X : array of shape (n_samples, n_features)
      Data used to fit the model.
  
  y : array of shape (n_samples)
      class labels of each example in X.
  
  Returns
  -------
  self
docstr_tok: ["Prepare","the","DS","model","by","setting","the","KNN","algorithm","and","pre-processing","the","information","required","to","apply","the","DS","method",".","Parameters","--","--","--","--","--","X",":","array","of","shape","(","n_samples",",","n_features",")","Data","used","to","fit","the","model",".","y",":","array","of","shape","(","n_samples",")","class","labels","of","each","example","in","X",".","Returns","--","--","--","-","self"]
code: def fit(self, X, y):
      """Prepare the DS model by setting the KNN algorithm and
      pre-processing the information required to apply the DS
      method.
  
      Parameters
      ----------
      X : array of shape (n_samples, n_features)
          Data used to fit the model.
  
      y : array of shape (n_samples)
          class labels of each example in X.
  
      Returns
      -------
      self
      """
      super(APosteriori, self).fit(X, y)
      self._check_predict_proba()
  
      self.dsel_scores_ = self._predict_proba_base(self.DSEL_data_)
      return self
  
imports: import numpy
  from deslib.dcs.base import BaseDCS
label_desc: Use image node_id 2 for calling the APosteriori obj's underlying member method code with example usage: obj.fit(X, y) and returns: self