docs: def predict_proba(self, X):
          """Predict class probabilities for X.
  
          The predicted class probabilities of an input sample is computed as
          the mean predicted class probabilities of the base estimators in the
          ensemble. If base estimators do not implement a ``predict_proba``
          method, then it resorts to voting and the predicted class probabilities
          of a an input sample represents the proportion of estimators predicting
          each class.
  
          Parameters
          ----------
          X : {array-like, sparse matrix} of shape = [n_samples, n_features]
              The training input samples. Sparse matrices are accepted only if
              they are supported by the base estimator.
  
          Returns
          -------
          p : array of shape = [n_samples, n_classes]
              The class probabilities of the input samples. The order of the
              classes corresponds to that in the attribute `classes_`.
          """
          # Check data
          # X = check_array(X, accept_sparse=['csr', 'csc', 'coo'])  # Dont in version 0.15
  
          if self.n_features_ != X.shape[1]:
              raise ValueError("Number of features of the model must "
                               "match the input. Model n_features is {0} and "
                               "input n_features is {1}."
                               "".format(self.n_features_, X.shape[1]))
  
          # Parallel loop
          n_jobs, n_estimators, starts = _partition_estimators(self.n_estimators, self.n_jobs)
  
          all_proba = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
              delayed(_parallel_predict_proba)(
                  self.estimators_[starts[i]:starts[i + 1]],
                  self.estimators_features_[starts[i]:starts[i + 1]],
                  X,
                  self.n_classes_,
                  self.combination,
                  self.estimators_weight_[starts[i]:starts[i + 1]])
              for i in range(n_jobs))
  
          # Reduce
          if self.combination in ['majority_voting', 'majority_bmr']:
              proba = sum(all_proba) / self.n_estimators
          elif self.combination in ['weighted_voting', 'weighted_bmr']:
              proba = sum(all_proba)
          elif self.combination in ['stacking', 'stacking_proba', 'stacking_bmr', 'stacking_proba_bmr']:
              X_stacking = _create_stacking_set(self.estimators_, self.estimators_features_,
                                                self.estimators_weight_, X, self.combination)
              proba = self.f_staking.predict_proba(X_stacking)
  
          return proba