class_docstr: Base class for forests of trees.
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 of shape (n_samples,) or (n_samples, n_outputs)
      The target values (class labels in classification, real numbers in
      regression).
  sample_weight : array-like of shape (n_samples,), default=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
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","of","shape","(","n_samples",",",")","or","(","n_samples",",","n_outputs",")","The","target","values","(","class","labels","in","classification",",","real","numbers","in","regression",")",".","sample_weight",":","array-like","of","shape","(","n_samples",",",")",",","default=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"]
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 of shape (n_samples,) or (n_samples, n_outputs)
          The target values (class labels in classification, real numbers in
          regression).
      sample_weight : array-like of shape (n_samples,), default=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
      """
      from scipy.sparse import issparse
  
      # Validate or convert input data
      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
      self.n_columns = X.shape[1]
      self.n_features = X.shape[1] if X.ndim == 2 else 1
  
      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,
              obj=self,
          )
  
      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
  
      # Get bootstrap sample size
      n_samples_bootstrap = _get_n_samples_bootstrap(
          n_samples=X.shape[0], max_samples=self.max_samples
      )
  
      # 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.",
              obj=self,
          )
      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 = [
              self._make_estimator(
                  append=False, random_state=random_state
              )
              for i in range(n_more_estimators)
          ]
  
          # Parallel loop: for standard random forests, the threading
          # backend is preferred as the Cython code for fitting the trees
          # is internally releasing the Python GIL making threading more
          # efficient than multiprocessing in that case.
          # However, in this case,for fitting pipelines in parallel,
          # multiprocessing is more efficient.
          trees = Parallel(n_jobs=self.n_jobs, verbose=self.verbose)(
              delayed(_parallel_build_trees)(
                  t,
                  self,
                  X,
                  y,
                  sample_weight,
                  i,
                  len(trees),
                  verbose=self.verbose,
                  class_weight=self.class_weight,
                  n_samples_bootstrap=n_samples_bootstrap,
              )
              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]
  
      self._is_fitted = True
      return self
  
imports: from abc import abstractmethod
  from warnings import catch_warnings, simplefilter
  import numpy
  import pandas
  from joblib import Parallel, delayed
  from numpy import float64
  from sklearn.base import clone
  from sklearn.ensemble._forest import MAX_INT, BaseForest, _generate_sample_indices, _get_n_samples_bootstrap
  from sklearn.exceptions import DataConversionWarning
  from sklearn.utils import check_array, check_random_state, compute_sample_weight
  from sktime.transformations.panel.summarize import RandomIntervalFeatureExtractor
  from sktime.utils.random_state import set_random_state
  from sktime.utils.warnings import warn
label_desc: Use image node_id 3 for calling the BaseTimeSeriesForest obj's underlying member method code with example usage: obj._fit(X, y, sample_weight) and returns: self