class_docstr: Pipeline of transformers and a regressor.
  
  The `RegressorPipeline` compositor chains transformers and a single regressor.
  The pipeline is constructed with a list of sktime transformers, plus a regressor,
      i.e., estimators following the BaseTransformer resp BaseRegressor interface.
  The transformer list can be unnamed - a simple list of transformers -
      or string named - a list of pairs of string, estimator.
  
  For a list of transformers `trafo1`, `trafo2`, ..., `trafoN` and a regressor `reg`,
      the pipeline behaves as follows:
  `fit(X, y)` - changes styte by running `trafo1.fit_transform` on `X`,
      them `trafo2.fit_transform` on the output of `trafo1.fit_transform`, etc
      sequentially, with `trafo[i]` receiving the output of `trafo[i-1]`,
      and then running `reg.fit` with `X` being the output of `trafo[N]`,
      and `y` identical with the input to `self.fit`
  `predict(X)` - result is of executing `trafo1.transform`, `trafo2.transform`, etc
      with `trafo[i].transform` input = output of `trafo[i-1].transform`,
      then running `reg.predict` on the output of `trafoN.transform`,
      and returning the output of `reg.predict`
  
  `get_params`, `set_params` uses `sklearn` compatible nesting interface
      if list is unnamed, names are generated as names of classes
      if names are non-unique, `f"_{str(i)}"` is appended to each name string
          where `i` is the total count of occurrence of a non-unique string
          inside the list of names leading up to it (inclusive)
  
  `RegressorPipeline` can also be created by using the magic multiplication
      on any regressor, i.e., if `my_reg` inherits from `BaseRegressor`,
          and `my_trafo1`, `my_trafo2` inherit from `BaseTransformer`, then,
          for instance, `my_trafo1 * my_trafo2 * my_reg`
          will result in the same object as  obtained from the constructor
          `RegressorPipeline(regressor=my_reg, transformers=[my_trafo1, my_trafo2])`
      magic multiplication can also be used with (str, transformer) pairs,
          as long as one element in the chain is a transformer
  
  Parameters
  ----------
  regressor : sktime regressor, i.e., estimator inheriting from BaseRegressor
      this is a "blueprint" regressor, state does not change when `fit` is called
  transformers : list of sktime transformers, or
      list of tuples (str, transformer) of sktime transformers
      these are "blueprint" transformers, states do not change when `fit` is called
  
  Attributes
  ----------
  regressor_ : sktime regressor, clone of regressor in `regressor`
      this clone is fitted in the pipeline when `fit` is called
  transformers_ : list of tuples (str, transformer) of sktime transformers
      clones of transformers in `transformers` which are fitted in the pipeline
      is always in (str, transformer) format, even if transformers is just a list
      strings not passed in transformers are unique generated strings
      i-th transformer in `transformers_` is clone of i-th in `transformers`
  
  Examples
  --------
  >>> from sktime.transformations.panel.pca import PCATransformer
  >>> from sktime.datasets import load_unit_test
  >>> from sktime.regression.compose import RegressorPipeline
  >>> from sktime.regression.distance_based import KNeighborsTimeSeriesRegressor
  >>> X_train, y_train = load_unit_test(split="train")
  >>> X_test, y_test = load_unit_test(split="test")
  >>> pipeline = RegressorPipeline(
  ...     KNeighborsTimeSeriesRegressor(n_neighbors=2), [PCATransformer()]
  ... )
  >>> pipeline.fit(X_train, y_train)
  RegressorPipeline(...)
  >>> y_pred = pipeline.predict(X_test)
  
  Alternative construction via dunder method:
  
  >>> pipeline = PCATransformer() * KNeighborsTimeSeriesRegressor(n_neighbors=2)
docstr: Magic * method, return concatenated RegressorPipeline, transformers on left.
  
  Implemented for `other` being a transformer, otherwise returns `NotImplemented`.
  
  Parameters
  ----------
  other: `sktime` transformer, must inherit from BaseTransformer
      otherwise, `NotImplemented` is returned
  
  Returns
  -------
  RegressorPipeline object, concatenation of `other` (first) with `self` (last).
docstr_tok: ["Magic","*","method",",","return","concatenated","RegressorPipeline",",","transformers","on","left",".","Implemented","for","`","other","`","being","a","transformer",",","otherwise","returns","`","NotImplemented","`",".","Parameters","--","--","--","--","--","other",":","`","sktime","`","transformer",",","must","inherit","from","BaseTransformer","otherwise",",","`","NotImplemented","`","is","returned","Returns","--","--","--","-","RegressorPipeline","object",",","concatenation","of","`","other","`","(","first",")","with","`","self","`","(","last",")","."]
code: def __rmul__(self, other):
      """Magic * method, return concatenated RegressorPipeline, transformers on left.
  
      Implemented for `other` being a transformer, otherwise returns `NotImplemented`.
  
      Parameters
      ----------
      other: `sktime` transformer, must inherit from BaseTransformer
          otherwise, `NotImplemented` is returned
  
      Returns
      -------
      RegressorPipeline object, concatenation of `other` (first) with `self` (last).
      """
      if isinstance(other, BaseTransformer):
          # use the transformers dunder to get a TransformerPipeline
          trafo_pipeline = other * self.transformers_
          # then stick the expanded pipeline in a RegressorPipeline
          new_pipeline = RegressorPipeline(
              regressor=self.regressor,
              transformers=trafo_pipeline.steps,
          )
          return new_pipeline
      else:
          return NotImplemented
  
imports: import numpy
  from sktime.base import _HeterogenousMetaEstimator
  from sktime.datatypes import convert_to
  from sktime.regression.base import BaseRegressor
  from sktime.transformations.base import BaseTransformer
  from sktime.transformations.compose import TransformerPipeline
  from sktime.utils.sklearn import is_sklearn_regressor
label_desc: Use image node_id 4 for calling the RegressorPipeline obj's underlying member method code with example usage: obj.__rmul__(other) and returns: new_pipeline, NotImplemented