class_docstr: Same as sklearn `BaseForest` but with distributed
  training using spark.
  
  Args:
      base_estimator (sklearn estimator): An estimator object implementing fit and one of
          decision_function or predict_proba.
      sc (sparkContext): Spark context for spark broadcasting and rdd operations.
      partitions (int or 'auto'): default 'auto'
          Number of partitions to use for parallelization of parameter
          search space. Integer values or None will be used directly for `numSlices`,
          while 'auto' will set `numSlices` to the number required fits.
      **kwargs: Keyword arguments to be passed to `BaseForest`.
class_docstr_tok: ["Same","as","sklearn","`","BaseForest","`","but","with","distributed","training","using","spark",".","Args",":","base_estimator","(","sklearn","estimator",")",":","An","estimator","object","implementing","fit","and","one","of","decision_function","or","predict_proba",".","sc","(","sparkContext",")",":","Spark","context","for","spark","broadcasting","and","rdd","operations",".","partitions","(","int","or","'auto","'",")",":","default","'auto'","Number","of","partitions","to","use","for","parallelization","of","parameter","search","space",".","Integer","values","or","None","will","be","used","directly","for","`","numSlices","`",",","while","'auto","'","will","set","`","numSlices","`","to","the","number","required","fits",".","*","*","kwargs",":","Keyword","arguments","to","be","passed","to","`","BaseForest","`","."]
docstr: Build a forest of trees from the training set (X, y). Parallelize fit
  operation using spark.
  
  Args:
      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.
docstr_tok: ["Build","a","forest","of","trees","from","the","training","set","(","X",",","y",")",".","Parallelize","fit","operation","using","spark",".","Args",":","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","."]
code: def fit(self, X, y, sample_weight=None):
      """
      Build a forest of trees from the training set (X, y). Parallelize fit
      operation using spark.
  
      Args:
          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.
      """
      _check_estimator(self, verbose=self.verbose)
  
      # 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 sample_weight is not None:
          sample_weight = check_array(sample_weight, ensure_2d=False)
      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 or not hasattr(self, "estimators_"):
          # 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_RAND_SEED, size=len(self.estimators_)
              )
  
          estimator_params = self.estimator_params
          verbose = self.verbose
          class_weight = self.class_weight
          bootstrap = self.bootstrap
          states = list(
              random_state.randint(
                  MAX_RAND_SEED, size=n_more_estimators
              )
          )
          params = {}
          for p in self.estimator_params:
              params[p] = getattr(self, p)
  
          if self.sc is None:
              base_estimator = self.base_estimator_
              trees = Parallel(n_jobs=self.n_jobs)(
                  delayed(_build_trees)(
                      base_estimator,
                      estimator_params,
                      params,
                      X,
                      y,
                      sample_weight,
                      state,
                      n_more_estimators,
                      verbose=verbose,
                      class_weight=class_weight,
                      bootstrap=bootstrap,
                  )
                  for state in states
              )
          else:
              base_estimator = self.sc.broadcast(self.base_estimator_)
              partitions = _parse_partitions(
                  self.partitions, n_more_estimators
              )
              trees = (
                  self.sc.parallelize(states, numSlices=partitions)
                  .map(
                      lambda x: _build_trees(
                          base_estimator,
                          estimator_params,
                          params,
                          X,
                          y,
                          sample_weight,
                          x,
                          n_more_estimators,
                          verbose=verbose,
                          class_weight=class_weight,
                          bootstrap=bootstrap,
                      )
                  )
                  .collect()
              )
  
          # 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]
  
      del self.sc
      return self
  
imports: import numpy
  import pandas
  from joblib import Parallel, delayed
  from scipy.sparse import hstack, issparse
  from sklearn.base import BaseEstimator, TransformerMixin
  from sklearn.ensemble.forest import BaseForest, ExtraTreesClassifier, ExtraTreesRegressor, ForestClassifier, ForestRegressor, RandomForestClassifier, RandomForestRegressor
  from sklearn.tree import ExtraTreeRegressor
  from sklearn.preprocessing import OneHotEncoder
  from sklearn.model_selection import KFold
  from sklearn.utils import check_array, check_random_state
  from numpy import float32
  from numpy import float64
  from .validation import _check_estimator, _check_is_fitted
  from .base import _clone, _get_value, _parse_partitions
label_desc: Use image node_id 2 for calling the DistBaseForest obj's underlying member method code with example usage: obj.fit(X, y, sample_weight) and returns: self