code: import numbers
  from warnings import catch_warnings, simplefilter, warn
  import threading
  
  from abc import ABCMeta, abstractmethod
  import numpy as np
  from scipy.sparse import issparse
  from scipy.sparse import hstack as sparse_hstack
  from joblib import Parallel, delayed
  
  from sklearn.base import ClassifierMixin, RegressorMixin, MultiOutputMixin
  from sklearn.metrics import r2_score
  from sklearn.preprocessing import OneHotEncoder
  from sklearn.tree import (DecisionTreeClassifier, DecisionTreeRegressor,
                      ExtraTreeClassifier, ExtraTreeRegressor)
  from sklearn.tree._tree import DTYPE, DOUBLE
  from sklearn.utils import check_random_state, check_array, compute_sample_weight
  from sklearn.exceptions import DataConversionWarning
  from sklearn.ensemble._base import BaseEnsemble, _partition_estimators
  from sklearn.utils.fixes import _joblib_parallel_args
  from sklearn.utils.multiclass import check_classification_targets
  from sklearn.utils.validation import check_is_fitted, _check_sample_weight
  from sklearn.utils.validation import _deprecate_positional_args
  
  from settree.set_tree import SetTree
  from settree.set_data import OPERATIONS
  
  __all__ = ["SetRandomForestClassifier",
             "SetRandomForestRegressor"]
  
  MAX_INT = np.iinfo(np.int32).max
  
  
  def _get_n_samples_bootstrap(n_samples, max_samples):
      """
      Get the number of samples in a bootstrap sample.
      Parameters
      ----------
      n_samples : int
          Number of samples in the dataset.
      max_samples : int or float
          The maximum number of samples to draw from the total available:
              - if float, this indicates a fraction of the total and should be
                the interval `(0, 1)`;
              - if int, this indicates the exact number of samples;
              - if None, this indicates the total number of samples.
      Returns
      -------
      n_samples_bootstrap : int
          The total number of samples to draw for the bootstrap sample.
      """
      if max_samples is None:
          return n_samples
  
      if isinstance(max_samples, numbers.Integral):
          if not (1 <= max_samples <= n_samples):
              msg = "`max_samples` must be in range 1 to {} but got value {}"
              raise ValueError(msg.format(n_samples, max_samples))
          return max_samples
  
      if isinstance(max_samples, numbers.Real):
          if not (0 < max_samples < 1):
              msg = "`max_samples` must be in range (0, 1) but got value {}"
              raise ValueError(msg.format(max_samples))
          return int(round(n_samples * max_samples))
  
      msg = "`max_samples` should be int or float, but got type '{}'"
      raise TypeError(msg.format(type(max_samples)))
  
  
  def _generate_sample_indices(random_state, n_samples, n_samples_bootstrap):
      """
      Private function used to _parallel_build_trees function."""
  
      random_instance = check_random_state(random_state)
      sample_indices = random_instance.randint(0, n_samples, n_samples_bootstrap)
  
      return sample_indices
  
  
  def _generate_unsampled_indices(random_state, n_samples, n_samples_bootstrap):
      """
      Private function used to forest._set_oob_score function."""
      sample_indices = _generate_sample_indices(random_state, n_samples,
                                                n_samples_bootstrap)
      sample_counts = np.bincount(sample_indices, minlength=n_samples)
      unsampled_mask = sample_counts == 0
      indices_range = np.arange(n_samples)
      unsampled_indices = indices_range[unsampled_mask]
  
      return unsampled_indices
  
  
  def _parallel_build_trees(tree, forest, X_set, y, sample_weight, tree_idx, n_trees,
                            verbose=0, class_weight=None,
                            n_samples_bootstrap=None):
      """
      Private function used to fit a single tree in parallel."""
      if verbose > 1:
          print("building tree %d of %d" % (tree_idx + 1, n_trees))
  
      if forest.bootstrap:
          n_samples = X_set.shape[0]
          if sample_weight is None:
              curr_sample_weight = np.ones((n_samples,), dtype=np.float64)
          else:
              curr_sample_weight = sample_weight.copy()
  
          indices = _generate_sample_indices(tree.random_state, n_samples,
                                             n_samples_bootstrap)
  
          X_subset = X_set.get_subset(indices)
          y_subset = y.take(indices)
          sample_weights_subset = None if sample_weight is None else curr_sample_weight.take(indices)
  
          # todo: currently not supporting those options
          # sample_counts = np.bincount(indices, minlength=n_samples)
          # curr_sample_weight *= sample_counts
          #
          # if class_weight == 'subsample':
          #     with catch_warnings():
          #         simplefilter('ignore', DeprecationWarning)
          #         curr_sample_weight *= compute_sample_weight('auto', y,
          #                                                     indices=indices)
          # elif class_weight == 'balanced_subsample':
          #     curr_sample_weight *= compute_sample_weight('balanced', y,
          #                                                 indices=indices)
  
          tree.fit(X_subset, y_subset, sample_weights_subset)
      else:
          tree.fit(X_set, y, sample_weight)
  
      return tree
  
  
  class BaseForest(MultiOutputMixin, BaseEnsemble, metaclass=ABCMeta):
      """
      Base class for forests of trees.
      Warning: This class should not be used directly. Use derived classes
      instead.
      """
  
      @abstractmethod
      def __init__(self,
                   base_estimator,
                   n_estimators=100, *,
                   estimator_params=tuple(),
                   bootstrap=False,
                   oob_score=False,
                   n_jobs=None,
                   random_state=None,
                   verbose=0,
                   warm_start=False,
                   class_weight=None,
                   max_samples=None):
          super().__init__(
              base_estimator=base_estimator,
              n_estimators=n_estimators,
              estimator_params=estimator_params)
  
          self.bootstrap = bootstrap
          self.oob_score = oob_score
          self.n_jobs = n_jobs
          self.random_state = random_state
          self.verbose = verbose
          self.warm_start = warm_start
          self.class_weight = class_weight
          self.max_samples = max_samples
  
      def apply(self, X_set):
          """
          Apply trees in the forest to X, return leaf indices.
          Parameters
          ----------
          X : {array-like, sparse matrix} of shape (n_samples, n_features)
              The 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 ``csr_matrix``.
          Returns
          -------
          X_leaves : ndarray of shape (n_samples, n_estimators)
              For each datapoint x in X and for each tree in the forest,
              return the index of the leaf x ends up in.
          """
          #X = self._validate_X_predict(X)
          results = Parallel(n_jobs=self.n_jobs, verbose=self.verbose,
                             **_joblib_parallel_args(prefer="threads"))(
              delayed(tree.apply)(X_set)
              for tree in self.estimators_)
  
          return np.array(results).T
  
      def decision_path(self, X_set):
          # todo currently not working
  
          """
          Return the decision path in the forest.
          .. versionadded:: 0.18
          Parameters
          ----------
          X : {array-like, sparse matrix} of shape (n_samples, n_features)
              The 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 ``csr_matrix``.
          Returns
          -------
          indicator : sparse matrix of shape (n_samples, n_nodes)
              Return a node indicator matrix where non zero elements indicates
              that the samples goes through the nodes. The matrix is of CSR
              format.
          n_nodes_ptr : ndarray of shape (n_estimators + 1,)
              The columns from indicator[n_nodes_ptr[i]:n_nodes_ptr[i+1]]
              gives the indicator value for the i-th estimator.
          """
          #X = self._validate_X_predict(X)
          indicators = Parallel(n_jobs=self.n_jobs, verbose=self.verbose,
                                **_joblib_parallel_args(prefer='threads'))(
              delayed(tree.decision_path)(X_set)
              for tree in self.estimators_)
  
          n_nodes = [0]
          n_nodes.extend([i.shape[1] for i in indicators])
          n_nodes_ptr = np.array(n_nodes).cumsum()
  
          return sparse_hstack(indicators).tocsr(), n_nodes_ptr
  
      def fit(self, X_set, y, sample_weight=None):
          # Validate or convert input data
  
          if issparse(y):
              raise ValueError(
                  "sparse multilabel-indicator for y is not supported."
              )
          # X, y = self._validate_data(X, y, multi_output=True,
          #                            accept_sparse="csc", dtype=DTYPE)
          if sample_weight is not None:
              sample_weight = _check_sample_weight(sample_weight, X_set)
  
          # Remap output
          self.n_features_ = X_set.shape[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)
  
          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)
  
          # todo: the default was to cast y into float - keep it with it's current dtype
          #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_set.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.")
          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: we prefer the threading backend as the Cython code
              # for fitting the trees is internally releasing the Python GIL
              # making threading more efficient than multiprocessing in
              # that case. However, for joblib 0.12+ we respect any
              # parallel_backend contexts set at a higher level,
              # since correctness does not rely on using threads.
              trees = Parallel(n_jobs=self.n_jobs, verbose=self.verbose,
                               **_joblib_parallel_args(prefer='threads'))(
                  delayed(_parallel_build_trees)(
                      t, self, X_set, 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_set, 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
  
      @abstractmethod
      def _set_oob_score(self, X_set, y):
          """
          Calculate out of bag predictions and score."""
  
      def _validate_y_class_weight(self, y):
          # Default implementation
          return y, None
  
      def _validate_X_predict(self, X):
          """
          Validate X whenever one tries to predict, apply, predict_proba."""
          check_is_fitted(self)
  
          return self.estimators_[0]._validate_X_predict(X, check_input=True)
  
      @property
      def feature_importances_(self):
          """
          The impurity-based feature importances.
          The higher, the more important the feature.
          The importance of a feature is computed as the (normalized)
          total reduction of the criterion brought by that feature.  It is also
          known as the Gini importance.
          Warning: impurity-based feature importances can be misleading for
          high cardinality features (many unique values). See
          :func:`sklearn.inspection.permutation_importance` as an alternative.
          Returns
          -------
          feature_importances_ : ndarray of shape (n_features,)
              The values of this array sum to 1, unless all trees are single node
              trees consisting of only the root node, in which case it will be an
              array of zeros.
          """
          check_is_fitted(self)
  
          all_importances = Parallel(n_jobs=self.n_jobs,
                                     **_joblib_parallel_args(prefer='threads'))(
              delayed(getattr)(tree, 'feature_importances_')
              for tree in self.estimators_ if tree.tree_.node_count > 1)
  
          if not all_importances:
              return np.zeros(self.n_features_, dtype=np.float64)
  
          all_importances = np.mean(all_importances,
                                    axis=0, dtype=np.float64)
          return all_importances / np.sum(all_importances)
  
  
  def _accumulate_prediction(predict, X_set, out, lock):
      """
      This is a utility function for joblib's Parallel.
      It can't go locally in ForestClassifier or ForestRegressor, because joblib
      complains that it cannot pickle it when placed there.
      """
      prediction = predict(X_set)
      with lock:
          if len(out) == 1:
              out[0] += prediction
          else:
              for i in range(len(out)):
                  out[i] += prediction[i]
  
  
  class SetForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
      """
      Base class for forest of trees-based classifiers.
      Warning: This class should not be used directly. Use derived classes
      instead.
      """
  
      @abstractmethod
      def __init__(self,
                   base_estimator,
                   n_estimators=100, *,
                   estimator_params=tuple(),
                   bootstrap=False,
                   oob_score=False,
                   n_jobs=None,
                   random_state=None,
                   verbose=0,
                   warm_start=False,
                   class_weight=None,
                   max_samples=None):
          super().__init__(
              base_estimator,
              n_estimators=n_estimators,
              estimator_params=estimator_params,
              bootstrap=bootstrap,
              oob_score=oob_score,
              n_jobs=n_jobs,
              random_state=random_state,
              verbose=verbose,
              warm_start=warm_start,
              class_weight=class_weight,
              max_samples=max_samples)
  
      def _set_oob_score(self, X_set, y):
          """
          Compute out-of-bag score."""
          #X = check_array(X, dtype=DTYPE, accept_sparse='csr')
  
          n_classes_ = self.n_classes_
          n_samples = y.shape[0]
  
          oob_decision_function = []
          oob_score = 0.0
          predictions = [np.zeros((n_samples, n_classes_[k]))
                         for k in range(self.n_outputs_)]
  
          n_samples_bootstrap = _get_n_samples_bootstrap(
              n_samples, self.max_samples
          )
  
          for estimator in self.estimators_:
              unsampled_indices = _generate_unsampled_indices(
                  estimator.random_state, n_samples, n_samples_bootstrap)
              X_subsample = X_set.get_subset(unsampled_indices)
              p_estimator = estimator.predict_proba(X_subsample)
  
              if self.n_outputs_ == 1:
                  p_estimator = [p_estimator]
  
              for k in range(self.n_outputs_):
                  predictions[k][unsampled_indices, :] += p_estimator[k]
  
          for k in range(self.n_outputs_):
              if (predictions[k].sum(axis=1) == 0).any():
                  warn("Some inputs do not have OOB scores. "
                       "This probably means too few trees were used "
                       "to compute any reliable oob estimates.")
  
              decision = (predictions[k] /
                          predictions[k].sum(axis=1)[:, np.newaxis])
              oob_decision_function.append(decision)
              oob_score += np.mean(y[:, k] ==
                                   np.argmax(predictions[k], axis=1), axis=0)
  
          if self.n_outputs_ == 1:
              self.oob_decision_function_ = oob_decision_function[0]
          else:
              self.oob_decision_function_ = oob_decision_function
  
          self.oob_score_ = oob_score / self.n_outputs_
  
      def _validate_y_class_weight(self, y):
          check_classification_targets(y)
  
          y = np.copy(y)
          expanded_class_weight = None
  
          if self.class_weight is not None:
              y_original = np.copy(y)
  
          self.classes_ = []
          self.n_classes_ = []
  
          y_store_unique_indices = np.zeros(y.shape, dtype=np.int)
          for k in range(self.n_outputs_):
              classes_k, y_store_unique_indices[:, k] = \
                  np.unique(y[:, k], return_inverse=True)
              self.classes_.append(classes_k)
              self.n_classes_.append(classes_k.shape[0])
          y = y_store_unique_indices
  
          if self.class_weight is not None:
              valid_presets = ('balanced', 'balanced_subsample')
              if isinstance(self.class_weight, str):
                  if self.class_weight not in valid_presets:
                      raise ValueError('Valid presets for class_weight include '
                                       '"balanced" and "balanced_subsample".'
                                       'Given "%s".'
                                       % self.class_weight)
                  if self.warm_start:
                      warn('class_weight presets "balanced" or '
                           '"balanced_subsample" are '
                           'not recommended for warm_start if the fitted data '
                           'differs from the full dataset. In order to use '
                           '"balanced" weights, use compute_class_weight '
                           '("balanced", classes, y). In place of y you can use '
                           'a large enough sample of the full training set '
                           'target to properly estimate the class frequency '
                           'distributions. Pass the resulting weights as the '
                           'class_weight parameter.')
  
              if (self.class_weight != 'balanced_subsample' or
                      not self.bootstrap):
                  if self.class_weight == "balanced_subsample":
                      class_weight = "balanced"
                  else:
                      class_weight = self.class_weight
                  expanded_class_weight = compute_sample_weight(class_weight,
                                                                y_original)
  
          return y, expanded_class_weight
  
      def predict(self, X_set):
          """
          Predict class for X.
          The predicted class of an input sample is a vote by the trees in
          the forest, weighted by their probability estimates. That is,
          the predicted class is the one with highest mean probability
          estimate across the trees.
          Parameters
          ----------
          X : {array-like, sparse matrix} of shape (n_samples, n_features)
              The 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 ``csr_matrix``.
          Returns
          -------
          y : ndarray of shape (n_samples,) or (n_samples, n_outputs)
              The predicted classes.
          """
          proba = self.predict_proba(X_set)
  
          if self.n_outputs_ == 1:
              return self.classes_.take(np.argmax(proba, axis=1), axis=0)
  
          else:
              n_samples = proba[0].shape[0]
              # all dtypes should be the same, so just take the first
              class_type = self.classes_[0].dtype
              predictions = np.empty((n_samples, self.n_outputs_),
                                     dtype=class_type)
  
              for k in range(self.n_outputs_):
                  predictions[:, k] = self.classes_[k].take(np.argmax(proba[k],
                                                                      axis=1),
                                                            axis=0)
  
              return predictions
  
      def predict_proba(self, X_set):
          """
          Predict class probabilities for X.
          The predicted class probabilities of an input sample are computed as
          the mean predicted class probabilities of the trees in the forest.
          The class probability of a single tree is the fraction of samples of
          the same class in a leaf.
          Parameters
          ----------
          X : {array-like, sparse matrix} of shape (n_samples, n_features)
              The 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 ``csr_matrix``.
          Returns
          -------
          p : ndarray of shape (n_samples, n_classes), or a list of n_outputs
              such arrays if n_outputs > 1.
              The class probabilities of the input samples. The order of the
              classes corresponds to that in the attribute :term:`classes_`.
          """
          check_is_fitted(self)
          # Check data
          # X = self._validate_X_predict(X)
  
          # Assign chunk of trees to jobs
          n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
  
          # avoid storing the output of every estimator by summing them here
          all_proba = [np.zeros((X_set.shape[0], j), dtype=np.float64)
                       for j in np.atleast_1d(self.n_classes_)]
          lock = threading.Lock()
          Parallel(n_jobs=n_jobs, verbose=self.verbose,
                   **_joblib_parallel_args(require="sharedmem"))(
              delayed(_accumulate_prediction)(e.predict_proba, X_set, all_proba,
                                              lock)
              for e in self.estimators_)
  
          for proba in all_proba:
              proba /= len(self.estimators_)
  
          if len(all_proba) == 1:
              return all_proba[0]
          else:
              return all_proba
  
      def predict_log_proba(self, X_set):
          """
          Predict class log-probabilities for X.
          The predicted class log-probabilities of an input sample is computed as
          the log of the mean predicted class probabilities of the trees in the
          forest.
          Parameters
          ----------
          X : {array-like, sparse matrix} of shape (n_samples, n_features)
              The 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 ``csr_matrix``.
          Returns
          -------
          p : ndarray of shape (n_samples, n_classes), or a list of n_outputs
              such arrays if n_outputs > 1.
              The class probabilities of the input samples. The order of the
              classes corresponds to that in the attribute :term:`classes_`.
          """
          proba = self.predict_proba(X_set)
  
          if self.n_outputs_ == 1:
              return np.log(proba)
  
          else:
              for k in range(self.n_outputs_):
                  proba[k] = np.log(proba[k])
  
              return proba
  
  
  class SetForestRegressor(RegressorMixin, BaseForest, metaclass=ABCMeta):
      """
      Base class for forest of trees-based regressors.
      Warning: This class should not be used directly. Use derived classes
      instead.
      """
  
      @abstractmethod
      def __init__(self,
                   base_estimator,
                   n_estimators=100, *,
                   estimator_params=tuple(),
                   bootstrap=False,
                   oob_score=False,
                   n_jobs=None,
                   random_state=None,
                   verbose=0,
                   warm_start=False,
                   max_samples=None):
          super().__init__(
              base_estimator,
              n_estimators=n_estimators,
              estimator_params=estimator_params,
              bootstrap=bootstrap,
              oob_score=oob_score,
              n_jobs=n_jobs,
              random_state=random_state,
              verbose=verbose,
              warm_start=warm_start,
              max_samples=max_samples)
  
      def predict(self, X_set):
          """
          Predict regression target for X.
          The predicted regression target of an input sample is computed as the
          mean predicted regression targets of the trees in the forest.
          Parameters
          ----------
          X : {array-like, sparse matrix} of shape (n_samples, n_features)
              The 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 ``csr_matrix``.
          Returns
          -------
          y : ndarray of shape (n_samples,) or (n_samples, n_outputs)
              The predicted values.
          """
          check_is_fitted(self)
          # Check data
          # X = self._validate_X_predict(X)
  
          # Assign chunk of trees to jobs
          n_jobs, _, _ = _partition_estimators(self.n_estimators, self.n_jobs)
  
          # avoid storing the output of every estimator by summing them here
          if self.n_outputs_ > 1:
              y_hat = np.zeros((X_set.shape[0], self.n_outputs_), dtype=np.float64)
          else:
              y_hat = np.zeros((X_set.shape[0]), dtype=np.float64)
  
          # Parallel loop
          lock = threading.Lock()
          Parallel(n_jobs=n_jobs, verbose=self.verbose,
                   **_joblib_parallel_args(require="sharedmem"))(
              delayed(_accumulate_prediction)(e.predict, X_set, [y_hat], lock)
              for e in self.estimators_)
  
          y_hat /= len(self.estimators_)
  
          return y_hat
  
      def _set_oob_score(self, X_set, y):
          """
          Compute out-of-bag scores."""
          # X = check_array(X, dtype=DTYPE, accept_sparse='csr')
  
          n_samples = y.shape[0]
  
          predictions = np.zeros((n_samples, self.n_outputs_))
          n_predictions = np.zeros((n_samples, self.n_outputs_))
  
          n_samples_bootstrap = _get_n_samples_bootstrap(
              n_samples, self.max_samples
          )
  
          for estimator in self.estimators_:
              unsampled_indices = _generate_unsampled_indices(
                  estimator.random_state, n_samples, n_samples_bootstrap)
              X_subset = X_set.get_subset(unsampled_indices)
              p_estimator = estimator.predict(X_subset)
  
              if self.n_outputs_ == 1:
                  p_estimator = p_estimator[:, np.newaxis]
  
              predictions[unsampled_indices, :] += p_estimator
              n_predictions[unsampled_indices, :] += 1
  
          if (n_predictions == 0).any():
              warn("Some inputs do not have OOB scores. "
                   "This probably means too few trees were used "
                   "to compute any reliable oob estimates.")
              n_predictions[n_predictions == 0] = 1
  
          predictions /= n_predictions
          self.oob_prediction_ = predictions
  
          if self.n_outputs_ == 1:
              self.oob_prediction_ = \
                  self.oob_prediction_.reshape((n_samples, ))
  
          self.oob_score_ = 0.0
  
          for k in range(self.n_outputs_):
              self.oob_score_ += r2_score(y[:, k],
                                          predictions[:, k])
  
          self.oob_score_ /= self.n_outputs_
  
      def _compute_partial_dependence_recursion(self, grid, target_features):
          """Fast partial dependence computation.
          Parameters
          ----------
          grid : ndarray of shape (n_samples, n_target_features)
              The grid points on which the partial dependence should be
              evaluated.
          target_features : ndarray of shape (n_target_features)
              The set of target features for which the partial dependence
              should be evaluated.
          Returns
          -------
          averaged_predictions : ndarray of shape (n_samples,)
              The value of the partial dependence function on each grid point.
          """
          grid = np.asarray(grid, dtype=DTYPE, order='C')
          averaged_predictions = np.zeros(shape=grid.shape[0],
                                          dtype=np.float64, order='C')
  
          for tree in self.estimators_:
              # Note: we don't sum in parallel because the GIL isn't released in
              # the fast method.
              tree.tree_.compute_partial_dependence(
                  grid, target_features, averaged_predictions)
          # Average over the forest
          averaged_predictions /= len(self.estimators_)
  
          return averaged_predictions
  
  
  class SetRandomForestClassifier(SetForestClassifier):
      @_deprecate_positional_args
      def __init__(self,
                   n_estimators=100, *,
                   criterion="gini",
                   max_depth=None,
                   min_samples_split=2,
                   min_samples_leaf=1,
                   min_weight_fraction_leaf=0.,
                   max_features="auto",
                   max_leaf_nodes=None,
                   min_impurity_decrease=0.,
                   min_impurity_split=None,
                   splitter='xgboost',
                   operations=OPERATIONS,
                   use_attention_set=True,
                   attention_set_limit=1,
                   bootstrap=True,
                   oob_score=False,
                   n_jobs=None,
                   random_state=None,
                   verbose=0,
                   warm_start=False,
                   class_weight=None,
                   ccp_alpha=0.0,
                   max_samples=None):
          super().__init__(
              base_estimator=SetTree(),
              n_estimators=n_estimators,
              estimator_params=tuple(SetTree().get_params()),
              bootstrap=bootstrap,
              oob_score=oob_score,
              n_jobs=n_jobs,
              random_state=random_state,
              verbose=verbose,
              warm_start=warm_start,
              class_weight=class_weight,
              max_samples=max_samples)
  
          self.criterion = criterion
          self.max_depth = max_depth
          self.min_samples_split = min_samples_split
          self.min_samples_leaf = min_samples_leaf
          self.min_weight_fraction_leaf = min_weight_fraction_leaf
          self.max_features = max_features
          self.max_leaf_nodes = max_leaf_nodes
          self.min_impurity_decrease = min_impurity_decrease
          self.min_impurity_split = min_impurity_split
          self.operations = operations
          self.splitter = splitter
          self.use_attention_set = use_attention_set
          self.attention_set_limit = attention_set_limit
          self.classifier = True
          self.ccp_alpha = ccp_alpha
  
  
  class SetRandomForestRegressor(SetForestRegressor):
      @_deprecate_positional_args
      def __init__(self,
                   n_estimators=100, *,
                   criterion="mse",
                   max_depth=None,
                   min_samples_split=2,
                   min_samples_leaf=1,
                   min_weight_fraction_leaf=0.,
                   max_features="auto",
                   max_leaf_nodes=None,
                   min_impurity_decrease=0.,
                   min_impurity_split=None,
                   splitter='xgboost',
                   operations=OPERATIONS,
                   use_attention_set=True,
                   attention_set_limit=1,
                   bootstrap=True,
                   oob_score=False,
                   n_jobs=None,
                   random_state=None,
                   verbose=0,
                   warm_start=False,
                   ccp_alpha=0.0,
                   max_samples=None):
          super().__init__(
              base_estimator=SetTree(),
              n_estimators=n_estimators,
              estimator_params=tuple(SetTree().get_params()),
              bootstrap=bootstrap,
              oob_score=oob_score,
              n_jobs=n_jobs,
              random_state=random_state,
              verbose=verbose,
              warm_start=warm_start,
              max_samples=max_samples)
  
          self.criterion = criterion
          self.max_depth = max_depth
          self.min_samples_split = min_samples_split
          self.min_samples_leaf = min_samples_leaf
          self.min_weight_fraction_leaf = min_weight_fraction_leaf
          self.max_features = max_features
          self.max_leaf_nodes = max_leaf_nodes
          self.min_impurity_decrease = min_impurity_decrease
          self.min_impurity_split = min_impurity_split
          self.operations = operations
          self.splitter = splitter
          self.use_attention_set = use_attention_set
          self.attention_set_limit = attention_set_limit
          self.classifier = False
          self.ccp_alpha = ccp_alpha
  
apis: sklearn.utils.validation.check_is_fitted numpy.ones numpy.sum numpy.asarray numpy.copy numpy.log sklearn.ensemble._base._partition_estimators sklearn.utils.multiclass.check_classification_targets sklearn.utils.fixes._joblib_parallel_args sklearn.utils.validation._check_sample_weight numpy.reshape numpy.unique numpy.mean sklearn.utils.check_random_state numpy.bincount numpy.zeros numpy.argmax numpy.arange sklearn.metrics.r2_score numpy.empty scipy.sparse.issparse numpy.atleast_1d sklearn.utils.compute_sample_weight numpy.iinfo numpy.array scipy.sparse.hstack