docs: def predict(self, X, cost_mat=None):
          """Predict class for X.
  
          The predicted class of an input sample is computed as the class with
          the highest mean predicted probability. If base estimators do not
          implement a ``predict_proba`` method, then it resorts to voting.
  
          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.
  
          cost_mat : optional array-like of shape = [n_samples, 4], (default=None)
              Cost matrix of the classification problem
              Where the columns represents the costs of: false positives, false negatives,
              true positives and true negatives, for each example.
  
          Returns
          -------
          pred : array of shape = [n_samples]
              The predicted 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]))
  
          #TODO: check if combination in possible combinations
  
          if self.combination in ['stacking', 'stacking_proba']:
  
              X_stacking = _create_stacking_set(self.estimators_, self.estimators_features_,
                                                self.estimators_weight_, X, self.combination)
              return self.f_staking.predict(X_stacking)
  
          elif self.combination in ['majority_voting', 'weighted_voting']:
              # Parallel loop
              n_jobs, n_estimators, starts = _partition_estimators(self.n_estimators,
                                                                   self.n_jobs)
  
              all_pred = Parallel(n_jobs=n_jobs, verbose=self.verbose)(
                  delayed(_parallel_predict)(
                      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
              pred = sum(all_pred) / self.n_estimators
  
              return self.classes_.take(np.argmax(pred, axis=1), axis=0)
  
          elif self.combination in ['majority_bmr', 'weighted_bmr', 'stacking_bmr', 'stacking_proba_bmr']:
              #TODO: Add check if cost_mat == None
              X_bmr = self.predict_proba(X)
              return self.f_bmr.predict(X_bmr, cost_mat)