TransformerPipeline

TransformerPipeline

class TransformerPipeline(steps)[source]

Pipeline of transformers compositor.

The TransformerPipeline compositor allows to chain transformers. The pipeline is constructed with a list of sktime transformers, i.e. estimators following the BaseTransformer interface. The 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, the pipeline behaves as follows:

• fit

  Changes state by running trafo1.fit_transform, trafo2.fit_transform` etc sequentially, with trafo[i] receiving the output of trafo[i-1]

• transform

  Result is of executing trafo1.transform, trafo2.transform, etc with trafo[i].transform input = output of trafo[i-1].transform, and returning the output of trafoN.transform

• inverse_transform

  Result is of executing trafo[i].inverse_transform, with trafo[i].inverse_transform input = output trafo[i-1].inverse_transform, and returning the output of trafoN.inverse_transform

• update

  Changes state by chaining trafo1.update, trafo1.transform, trafo2.update, trafo2.transform, …, trafoN.update, where trafo[i].update and trafo[i].transform receive as input the output of trafo[i-1].transform

For transformers in the pipeline that use the y argument, the y argument passed to TransformerPipeline.fit or transform is passed to all such transformers in the pipeline. No transformations or inverse transformations are applied to y in the pipeline.

The 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)

A TransformerPipeline can also be created by using the magic multiplication on any transformer, i.e., any estimator inheriting from BaseTransformer for instance, my_trafo1 * my_trafo2 * my_trafo3 will result in the same object as obtained from the constructor TransformerPipeline([my_trafo1, my_trafo2, my_trafo3]) A magic multiplication can also be used with (str, transformer) pairs, as long as one element in the chain is a transformer

Parameters:

stepslist 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:

steps_list of tuples (str, transformer) of sktime transformers

clones of transformers in steps which are fitted in the pipeline is always in (str, transformer) format, even if steps is just a list strings not passed in steps are replaced by unique generated strings i-th transformer in steps_ is clone of i-th in steps

Examples

>>> from sktime.transformations.compose import TransformerPipeline
>>> from sktime.transformations.exponent import ExponentTransformer
>>> t1 = ExponentTransformer(power=2)
>>> t2 = ExponentTransformer(power=0.5)

Example 1, option A: construct without strings (unique names are generated for the two components t1 and t2)

>>> pipe = TransformerPipeline(steps = [t1, t2])

Example 1, option B: construct with strings to give custom names to steps

>>> pipe = TransformerPipeline(
...         steps = [
...             ("trafo1", t1),
...             ("trafo2", t2),
...         ]
...     )

Example 1, option C: for quick construction, the * dunder method can be used

>>> pipe = t1 * t2

Example 2: sklearn transformers can be used in the pipeline. If applied to Series, sklearn transformers are applied by series instance. If applied to Table, sklearn transformers are applied to the table as a whole.

>>> from sklearn.preprocessing import StandardScaler
>>> from sktime.transformations.summarize import SummaryTransformer

This applies the scaler per series, then summarizes:

>>> pipe = StandardScaler() * SummaryTransformer()

This applies the sumamrization, then scales the full summary table:

>>> pipe = SummaryTransformer() * StandardScaler()

This scales the series, then summarizes, then scales the full summary table:

>>> pipe = StandardScaler() * SummaryTransformer() * StandardScaler()

Methods

check_is_fitted([method_name])	Check if the estimator has been fitted.
clone()	Obtain a clone of the object with same hyper-parameters and config.
clone_tags(estimator[, tag_names])	Clone tags from another object as dynamic override.
create_test_instance([parameter_set])	Construct an instance of the class, using first test parameter set.
create_test_instances_and_names([parameter_set])	Create list of all test instances and a list of names for them.
fit(X[, y])	Fit transformer to X, optionally to y.
fit_transform(X[, y])	Fit to data, then transform it.
get_class_tag(tag_name[, tag_value_default])	Get class tag value from class, with tag level inheritance from parents.
get_class_tags()	Get class tags from class, with tag level inheritance from parent classes.
get_config()	Get config flags for self.
get_fitted_params([deep])	Get fitted parameters.
get_param_defaults()	Get object's parameter defaults.
get_param_names([sort])	Get object's parameter names.
get_params([deep])	Get parameters of estimator.
get_tag(tag_name[, tag_value_default, ...])	Get tag value from instance, with tag level inheritance and overrides.
get_tags()	Get tags from instance, with tag level inheritance and overrides.
get_test_params([parameter_set])	Return testing parameter settings for the estimator.
inverse_transform(X[, y])	Inverse transform X and return an inverse transformed version.
is_composite()	Check if the object is composite.
load_from_path(serial)	Load object from file location.
load_from_serial(serial)	Load object from serialized memory container.
reset()	Reset the object to a clean post-init state.
save([path, serialization_format])	Save serialized self to bytes-like object or to (.zip) file.
set_config(**config_dict)	Set config flags to given values.
set_params(**kwargs)	Set the parameters of estimator.
set_random_state([random_state, deep, ...])	Set random_state pseudo-random seed parameters for self.
set_tags(**tag_dict)	Set instance level tag overrides to given values.
transform(X[, y])	Transform X and return a transformed version.
update(X[, y, update_params])	Update transformer with X, optionally y.