class_docstr: A Bagging classifier.
  
  A Bagging classifier is an ensemble meta-estimator that fits base
  classifiers each on random subsets of the original dataset and then
  aggregate their individual predictions (either by voting or by averaging)
  to form a final prediction. Such a meta-estimator can typically be used as
  a way to reduce the variance of a black-box estimator (e.g., a decision
  tree), by introducing randomization into its construction procedure and
  then making an ensemble out of it.
  
  This algorithm encompasses several works from the literature. When random
  subsets of the dataset are drawn as random subsets of the samples, then
  this algorithm is known as Pasting [1]_. If samples are drawn with
  replacement, then the method is known as Bagging [2]_. When random subsets
  of the dataset are drawn as random subsets of the features, then the method
  is known as Random Subspaces [3]_. Finally, when base estimators are built
  on subsets of both samples and features, then the method is known as
  Random Patches [4]_.
  
  Read more in the :ref:`User Guide <bagging>`.
  
  Parameters
  ----------
  base_estimator : object or None, optional (default=None)
      The base estimator to fit on random subsets of the dataset.
      If None, then the base estimator is a decision tree.
  
  n_estimators : int, optional (default=10)
      The number of base estimators in the ensemble.
  
  max_samples : int or float, optional (default=1.0)
      The number of samples to draw from X to train each base estimator.
          - If int, then draw `max_samples` samples.
          - If float, then draw `max_samples * X.shape[0]` samples.
  
  max_features : int or float, optional (default=1.0)
      The number of features to draw from X to train each base estimator.
          - If int, then draw `max_features` features.
          - If float, then draw `max_features * X.shape[1]` features.
  
  bootstrap : boolean, optional (default=True)
      Whether samples are drawn with replacement.
  
  bootstrap_features : boolean, optional (default=False)
      Whether features are drawn with replacement.
  
  oob_score : bool
      Whether to use out-of-bag samples to estimate
      the generalization error.
  
  warm_start : bool, optional (default=False)
      When set to True, reuse the solution of the previous call to fit
      and add more estimators to the ensemble, otherwise, just fit
      a whole new ensemble.
  
      .. versionadded:: 0.17
         *warm_start* constructor parameter.
  
  n_jobs : int, optional (default=1)
      The number of jobs to run in parallel for both `fit` and `predict`.
      If -1, then the number of jobs is set to the number of cores.
  
  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`.
  
  verbose : int, optional (default=0)
      Controls the verbosity of the building process.
  
  Attributes
  ----------
  base_estimator_ : estimator
      The base estimator from which the ensemble is grown.
  
  estimators_ : list of estimators
      The collection of fitted base estimators.
  
  estimators_samples_ : list of arrays
      The subset of drawn samples (i.e., the in-bag samples) for each base
      estimator. Each subset is defined by a boolean mask.
  
  estimators_features_ : list of arrays
      The subset of drawn features for each base estimator.
  
  classes_ : array of shape = [n_classes]
      The classes labels.
  
  n_classes_ : int or list
      The number of classes.
  
  oob_score_ : float
      Score of the training dataset obtained using an out-of-bag estimate.
  
  oob_decision_function_ : array of shape = [n_samples, n_classes]
      Decision function computed with out-of-bag estimate on the training
      set. If n_estimators is small it might be possible that a data point
      was never left out during the bootstrap. In this case,
      `oob_decision_function_` might contain NaN.
  
  References
  ----------
  
  .. [1] L. Breiman, "Pasting small votes for classification in large
         databases and on-line", Machine Learning, 36(1), 85-103, 1999.
  
  .. [2] L. Breiman, "Bagging predictors", Machine Learning, 24(2), 123-140,
         1996.
  
  .. [3] T. Ho, "The random subspace method for constructing decision
         forests", Pattern Analysis and Machine Intelligence, 20(8), 832-844,
         1998.
  
  .. [4] G. Louppe and P. Geurts, "Ensembles on Random Patches", Machine
         Learning and Knowledge Discovery in Databases, 346-361, 2012.
docstr: 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.
  
  Returns
  -------
  y : array of shape = [n_samples]
      The predicted classes.
docstr_tok: ["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",".","Returns","--","--","--","-","y",":","array","of","shape","=","[","n_samples","]","The","predicted","classes","."]
code: def predict(self, X):
      """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.
  
      Returns
      -------
      y : array of shape = [n_samples]
          The predicted classes.
      """
      predicted_probabilitiy = self.predict_proba(X)
      return self.classes_.take(
          (np.argmax(predicted_probabilitiy, axis=1)), axis=0
      )
  
imports: from __future__ import division
  import itertools
  import numbers
  import numpy
  from warnings import warn
  from abc import ABCMeta, abstractmethod
  from ..base import ClassifierMixin, RegressorMixin
  from ..externals.joblib import Parallel, delayed
  from ..externals.six import with_metaclass
  from ..externals.six.moves import zip
  from ..metrics import r2_score, accuracy_score
  from ..tree import DecisionTreeClassifier, DecisionTreeRegressor
  from ..utils import check_random_state, check_X_y, check_array, column_or_1d
  from ..utils.random import sample_without_replacement
  from ..utils.validation import has_fit_parameter, check_is_fitted
  from ..utils import indices_to_mask
  from ..utils.fixes import bincount
  from ..utils.metaestimators import if_delegate_has_method
  from ..utils.multiclass import check_classification_targets
  from .base import BaseEnsemble, _partition_estimators
label_desc: Use image node_id 5 for calling the BaggingClassifier obj's underlying member method code with example usage: obj.predict(X) and returns: self