class_docstr: Supervised Time Series Forest (STSF).
  
  An ensemble of decision trees built on intervals selected through a supervised
  process as described in _[1].
  Overview: Input n series length m
  For each tree
      - sample X using class-balanced bagging
      - sample intervals for all 3 representations and 7 features using supervised
      - method
      - find mean, median, std, slope, iqr, min and max using their corresponding
      - interval for each rperesentation, concatenate to form new data set
      - build decision tree on new data set
  Ensemble the trees with averaged probability estimates.
  
  Parameters
  ----------
  n_estimators : int, default=200
      Number of estimators to build for the ensemble.
  n_jobs : int, default=1
      The number of jobs to run in parallel for both `fit` and `predict`.
      ``-1`` means using all processors.
  random_state : int or None, default=None
      Seed for random number generation.
  
  Attributes
  ----------
  n_classes_ : int
      The number of classes.
  n_instances_ : int
      The number of train cases.
  series_length_ : int
      The length of each series.
  classes_ : list
      The classes labels.
  intervals : array-like of shape [n_estimators][3][7][n_intervals][2]
      Stores indexes of all start and end points for all estimators. Each estimator
      contains indexes for each representation and feature combination.
  estimators_ : list of shape (n_estimators) of DecisionTreeClassifier
      The collections of estimators trained in fit.
  
  Notes
  -----
  For the Java version, see
  `TSML <https://github.com/uea-machine-learning/tsml/blob/master/src/main/
   java/tsml/classifiers/interval_based/STSF.java>`_.
  
  References
  ----------
  .. [1] Cabello, Nestor, et al. "Fast and Accurate Time Series Classification
     Through Supervised Interval Search." IEEE ICDM 2020
  
  Examples
  --------
  >>> from sktime.classification.interval_based import SupervisedTimeSeriesForest
  >>> from sktime.datasets import load_unit_test
  >>> X_train, y_train = load_unit_test(split="train", return_X_y=True)
  >>> X_test, y_test = load_unit_test(split="test", return_X_y=True)
  >>> clf = SupervisedTimeSeriesForest(n_estimators=5)
  >>> clf.fit(X_train, y_train)
  SupervisedTimeSeriesForest(n_estimators=5)
  >>> y_pred = clf.predict(X_test)
docstr: Recursive function for finding intervals for a feature using fisher score.
  
  Given a start and end point the series is split in half and both intervals are
  evaluated. The half with the higher score is retained and used as the new start
  and end for a recursive call.
docstr_tok: ["Recursive","function","for","finding","intervals","for","a","feature","using","fisher","score",".","Given","a","start","and","end","point","the","series","is","split","in","half","and","both","intervals","are","evaluated",".","The","half","with","the","higher","score","is","retained","and","used","as","the","new","start","and","end","for","a","recursive","call","."]
code: def _supervised_interval_search(
      self,
      X,
      y,
      function,
      function_intervals,
      classes,
      class_counts,
      start,
      end,
  ):
      """Recursive function for finding intervals for a feature using fisher score.
  
      Given a start and end point the series is split in half and both intervals are
      evaluated. The half with the higher score is retained and used as the new start
      and end for a recursive call.
      """
      series_length = end - start
      if series_length < 4:
          return
  
      e = start + int(series_length / 2)
  
      X_l = function(X[:, start:e], axis=1)
      X_r = function(X[:, e:end], axis=1)
  
      s1 = _fisher_score(X_l, y, classes, class_counts)
      s2 = _fisher_score(X_r, y, classes, class_counts)
  
      if s2 < s1:
          function_intervals.append([start, e])
          self._supervised_interval_search(
              X,
              y,
              function,
              function_intervals,
              classes,
              class_counts,
              start,
              e,
          )
      else:
          function_intervals.append([e, end])
          self._supervised_interval_search(
              X,
              y,
              function,
              function_intervals,
              classes,
              class_counts,
              e,
              end,
          )
  
imports: import math
  import numpy
  from joblib import Parallel, delayed
  from scipy import signal, stats
  from sklearn.base import clone
  from sklearn.preprocessing import StandardScaler
  from sklearn.tree import DecisionTreeClassifier
  from sklearn.utils.validation import check_random_state
  from sktime.classification.base import BaseClassifier
  from sktime.utils.slope_and_trend import _slope
label_desc: Use image node_id 7 for calling the SupervisedTimeSeriesForest obj's underlying member method code with example usage: obj._supervised_interval_search(X, y, function, function_intervals, classes, class_counts, start, end) without return types