class_docstr: Splitter based Bootstrapping method for synthetic time series generation.
  
  A generalized form of bootstrap based on an sktime splitter.
  
  Any sktime splitter can be passed as a component to this transformer,
  which will then produce for each series in the input of `transform`
  a panel of time series with the train and/or test sub-series.
  
  The output of `transform` will have additional levels:
  
  * all levels of the `transform` input
  * an additional integer indexed top level, indicating the number of the sample
    note: this is in general the number of the *sample* and corresponds to the
    number of the *fold* only in the deterministic, exhaustive case
  * if `split="train"` or `split="test"`, no further levels
  * if `split="both"`, the second top level contains strings `"train"` and `"test"`
    to indicate train or test fold from the split
  
  For instance, if `split="train"`, and there is a single original series `X`,
  the output of `transform` will have a top level (level 0) with integer index
  ranging from 0 to `splitter.get_n_splits(X)-1`.
  
  The splitter can be exhaustive and deterministic, or random.
  By default, exhaustive ordered samples are returned (deterministic).
  Randomness is controlled by the following parameters:
  
  * `shuffle` (by default off) applies random uniform shuffling to the instances
  * `subsample` (by default off) applies sub-sampling with or without replacement
  * `replace` (by default `False`) selects sub-sampling with or without replacement
  
  Caution: the instance index of the `transform` output will correspond to
  the split index only if `shuffle=False` and `subsample=None` (unless by coincidence)
  
  Parameters
  ----------
  splitter : optional, sktime splitter, BaseSplitter descendant
      default = SlidingWindowSplitter(window_length=3, step_length=1)
      The splitter used for the bootstrap splitting.
  fold : str, one of "train" (default), "test", and "both"
      Determines which fold is returned as new instances in the panel.
      "train" - the training folds; "test" - the test folds;
      "both" - both training and test folds, and an additional string level with
      possible values `"train"` and `"test"` is present
  shuffle : bool, default=False
      whether to shuffle the order of folds uniformly at random before returning
      if not, folds will be returned in the ordering defined by the splitter
  subsample : optional, int or float, default = None
      if provided, subsamples the folds returned uniformly at random
      `int` = subsample of that size will be returned (or full sample if smaller)
      `float`, must be between 0 and 1 = subsample of that fraction is returned
      Note: integer 1 selects *one* series; float 1 selects number in `splitter` many
  replace : bool, default=True; only used if `subsample=True`
      whether sampling, if `subsample` is provided is with or without replacement
      `True` = with replacement, `False` = without replacement
  random_state : int, np.random.RandomState or None (default)
      Random seed for the estimator
      if `None`, `numpy` environment random seed is used
      if `int`, passed to `numpy` `RandomState` as seed
      if `RandomState`, will be used as random generator
  
  See Also
  --------
  sktime.transformations.bootstrap.MovingBlockBootstrapTransformer :
      Similar logic to sliding window splitter, with bootstrap random windows.
  
  Examples
  --------
  >>> from sktime.transformations.bootstrap import SplitterBootstrapTransformer
  >>> from sktime.datasets import load_airline
  >>> y = load_airline()
  >>> transformer = SplitterBootstrapTransformer(fold="both")
  >>> y_hat = transformer.fit_transform(y)
docstr: Return testing parameter settings for the estimator.
  
  Parameters
  ----------
  parameter_set : str, default="default"
      Name of the set of test parameters to return, for use in tests. If no
      special parameters are defined for a value, will return `"default"` set.
  
  
  Returns
  -------
  params : dict or list of dict, default = {}
      Parameters to create testing instances of the class
      Each dict are parameters to construct an "interesting" test instance, i.e.,
      `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance.
      `create_test_instance` uses the first (or only) dictionary in `params`
docstr_tok: ["Return","testing","parameter","settings","for","the","estimator",".","Parameters","--","--","--","--","--","parameter_set",":","str",",","default=","''","default","''","Name","of","the","set","of","test","parameters","to","return",",","for","use","in","tests",".","If","no","special","parameters","are","defined","for","a","value",",","will","return","`","``","default","''","`","set",".","Returns","--","--","--","-","params",":","dict","or","list","of","dict",",","default","=","{","}","Parameters","to","create","testing","instances","of","the","class","Each","dict","are","parameters","to","construct","an","``","interesting","''","test","instance",",","i.e.",",","`","MyClass","(","*","*","params",")","`","or","`","MyClass","(","*","*","params","[","i","]",")","`","creates","a","valid","test","instance",".","`","create_test_instance","`","uses","the","first","(","or","only",")","dictionary","in","`","params","`"]
code: def get_test_params(cls, parameter_set="default"):
      """Return testing parameter settings for the estimator.
  
      Parameters
      ----------
      parameter_set : str, default="default"
          Name of the set of test parameters to return, for use in tests. If no
          special parameters are defined for a value, will return `"default"` set.
  
  
      Returns
      -------
      params : dict or list of dict, default = {}
          Parameters to create testing instances of the class
          Each dict are parameters to construct an "interesting" test instance, i.e.,
          `MyClass(**params)` or `MyClass(**params[i])` creates a valid test instance.
          `create_test_instance` uses the first (or only) dictionary in `params`
      """
      from sktime.split import ExpandingWindowSplitter
  
      params = [
          {},
          {
              "splitter": ExpandingWindowSplitter(initial_window=1),
              "fold": "test",
              "shuffle": True,
              "subsample": 0.5,
              "replace": True,
          },
          {
              "splitter": ExpandingWindowSplitter(initial_window=2),
              "fold": "train",
              "shuffle": False,
              "subsample": 3,
              "replace": False,
          },
      ]
  
      return params
  
file_path: sktime/sktime/transformations/bootstrap/_splitterboot.py
imports: import numpy
  import pandas
  from sklearn.utils import check_random_state
  from sktime.transformations.base import BaseTransformer
label_desc: Use image node_id 3 for calling the SplitterBootstrapTransformer obj's underlying member method code with example usage: obj.get_test_params(cls, parameter_set) and returns: params