class_docstr: Base class for forests of trees.
  
  Warning: This class should not be used directly. Use derived classes
  instead.
class_docstr_tok: ["Base","class","for","forests","of","trees",".","Warning",":","This","class","should","not","be","used","directly",".","Use","derived","classes","instead","."]
docstr: Build a forest of trees from the training set (X, y).
  
  Parameters
  ----------
  X : array-like or sparse matrix of shape = [n_samples, n_features]
      The training input samples. Internally, its dtype will be converted to
      ``dtype=np.float32``. If a sparse matrix is provided, it will be
      converted into a sparse ``csc_matrix``.
  
  y : array-like, shape = [n_samples] or [n_samples, n_outputs]
      The target values (class labels in classification, real numbers in
      regression).
  
  sample_weight : array-like, shape = [n_samples] or None
      Sample weights. If None, then samples are equally weighted. Splits
      that would create child nodes with net zero or negative weight are
      ignored while searching for a split in each node. In the case of
      classification, splits are also ignored if they would result in any
      single class carrying a negative weight in either child node.
  
  Returns
  -------
  self : object
      Returns self.
docstr_tok: ["Build","a","forest","of","trees","from","the","training","set","(","X",",","y",")",".","Parameters","--","--","--","--","--","X",":","array-like","or","sparse","matrix","of","shape","=","[","n_samples",",","n_features","]","The","training","input","samples",".","Internally",",","its","dtype","will","be","converted","to","``","dtype=np.float32","``",".","If","a","sparse","matrix","is","provided",",","it","will","be","converted","into","a","sparse","``","csc_matrix","``",".","y",":","array-like",",","shape","=","[","n_samples","]","or","[","n_samples",",","n_outputs","]","The","target","values","(","class","labels","in","classification",",","real","numbers","in","regression",")",".","sample_weight",":","array-like",",","shape","=","[","n_samples","]","or","None","Sample","weights",".","If","None",",","then","samples","are","equally","weighted",".","Splits","that","would","create","child","nodes","with","net","zero","or","negative","weight","are","ignored","while","searching","for","a","split","in","each","node",".","In","the","case","of","classification",",","splits","are","also","ignored","if","they","would","result","in","any","single","class","carrying","a","negative","weight","in","either","child","node",".","Returns","--","--","--","-","self",":","object","Returns","self","."]
code: def fit(self, X, y, sample_weight=None):
      """Build a forest of trees from the training set (X, y).
  
      Parameters
      ----------
      X : array-like or sparse matrix of shape = [n_samples, n_features]
          The training input samples. Internally, its dtype will be converted to
          ``dtype=np.float32``. If a sparse matrix is provided, it will be
          converted into a sparse ``csc_matrix``.
  
      y : array-like, shape = [n_samples] or [n_samples, n_outputs]
          The target values (class labels in classification, real numbers in
          regression).
  
      sample_weight : array-like, shape = [n_samples] or None
          Sample weights. If None, then samples are equally weighted. Splits
          that would create child nodes with net zero or negative weight are
          ignored while searching for a split in each node. In the case of
          classification, splits are also ignored if they would result in any
          single class carrying a negative weight in either child node.
  
      Returns
      -------
      self : object
          Returns self.
      """
      # Validate or convert input data
      X = check_array(X, accept_sparse="csc", dtype=DTYPE)
      y = check_array(
          y, accept_sparse="csc", ensure_2d=False, dtype=None
      )
      if issparse(X):
          # Pre-sort indices to avoid that each individual tree of the
          # ensemble sorts the indices.
          X.sort_indices()
  
      # Remap output
      n_samples, self.n_features_ = X.shape
  
      y = np.atleast_1d(y)
      if y.ndim == 2 and y.shape[1] == 1:
          warn(
              "A column-vector y was passed when a 1d array was"
              " expected. Please change the shape of y to "
              "(n_samples,), for example using ravel().",
              DataConversionWarning,
              stacklevel=2,
          )
  
      if y.ndim == 1:
          # reshape is necessary to preserve the data contiguity against vs
          # [:, np.newaxis] that does not.
          y = np.reshape(y, (-1, 1))
  
      self.n_outputs_ = y.shape[1]
  
      y, expanded_class_weight = self._validate_y_class_weight(y)
  
      if getattr(y, "dtype", None) != DOUBLE or not y.flags.contiguous:
          y = np.ascontiguousarray(y, dtype=DOUBLE)
  
      if expanded_class_weight is not None:
          if sample_weight is not None:
              sample_weight = sample_weight * expanded_class_weight
          else:
              sample_weight = expanded_class_weight
  
      # Check parameters
      self._validate_estimator()
  
      if not self.bootstrap and self.oob_score:
          raise ValueError(
              "Out of bag estimation only available"
              " if bootstrap=True"
          )
  
      random_state = check_random_state(self.random_state)
  
      if not self.warm_start:
          # Free allocated memory, if any
          self.estimators_ = []
  
      n_more_estimators = self.n_estimators - len(self.estimators_)
  
      if n_more_estimators < 0:
          raise ValueError(
              "n_estimators=%d must be larger or equal to "
              "len(estimators_)=%d when warm_start==True"
              % (self.n_estimators, len(self.estimators_))
          )
  
      elif n_more_estimators == 0:
          warn(
              "Warm-start fitting without increasing n_estimators does not "
              "fit new trees."
          )
      else:
          if self.warm_start and len(self.estimators_) > 0:
              # We draw from the random state to get the random state we
              # would have got if we hadn't used a warm_start.
              random_state.randint(MAX_INT, size=len(self.estimators_))
  
          trees = []
          for i in range(n_more_estimators):
              tree = self._make_estimator(
                  append=False, random_state=random_state
              )
              trees.append(tree)
  
          # Parallel loop: we use the threading backend as the Cython code
          # for fitting the trees is internally releasing the Python GIL
          # making threading always more efficient than multiprocessing in
          # that case.
          trees = Parallel(
              n_jobs=self.n_jobs,
              verbose=self.verbose,
              backend="threading",
          )(
              delayed(_parallel_build_trees)(
                  t,
                  self,
                  X,
                  y,
                  sample_weight,
                  i,
                  len(trees),
                  verbose=self.verbose,
                  class_weight=self.class_weight,
              )
              for i, t in enumerate(trees)
          )
  
          # Collect newly grown trees
          self.estimators_.extend(trees)
  
      if self.oob_score:
          self._set_oob_score(X, y)
  
      # Decapsulate classes_ attributes
      if hasattr(self, "classes_") and self.n_outputs_ == 1:
          self.n_classes_ = self.n_classes_[0]
          self.classes_ = self.classes_[0]
  
      return self
  
imports: from __future__ import division
  import warnings
  from warnings import warn
  from abc import ABCMeta, abstractmethod
  import numpy
  from scipy.sparse import issparse
  from scipy.sparse import hstack
  from ..base import ClassifierMixin, RegressorMixin
  from ..externals.joblib import Parallel, delayed
  from ..externals import six
  from ..feature_selection.from_model import _LearntSelectorMixin
  from ..metrics import r2_score
  from ..preprocessing import OneHotEncoder
  from ..tree import DecisionTreeClassifier, DecisionTreeRegressor, ExtraTreeClassifier, ExtraTreeRegressor
  from ..tree._tree import DTYPE, DOUBLE
  from ..utils import check_random_state, check_array, compute_sample_weight
  from ..exceptions import DataConversionWarning, NotFittedError
  from .base import BaseEnsemble, _partition_estimators
  from ..utils.fixes import bincount, parallel_helper
  from ..utils.multiclass import check_classification_targets
label_desc: Use image node_id 4 for calling the BaseForest obj's underlying member method code with example usage: obj.fit(X, y, sample_weight) and returns: self