TransformByLevel

class TransformByLevel(transformer, groupby='local', raise_warnings=True)[source]

Transform by instance or panel.

Used to apply multiple copies of transformer by instance or by panel.

If groupby="global", behaves like transformer. If groupby="local", fits a clone of transformer per time series instance. If groupby="panel", fits a clone of transformer by panel (first non-time level).

The fitted transformers can be accessed in the transformers_ attribute, if more than one clone is fitted, otherwise in the transformer_ attribute.

Parameters:

transformersktime transformer used in TransformByLevel: A “blueprint” transformer, state does not change when fit is called.
groupbystr, one of [“local”, “global”, “panel”], optional, default=”local”: level on which data are grouped to fit clones of transformer “local” = unit/instance level, one reduced model per lowest hierarchy level “global” = top level, one reduced model overall, on pooled data ignoring levels “panel” = second lowest level, one reduced model per panel level (-2) if there are 2 or less levels, “global” and “panel” result in the same if there is only 1 level (single time series), all three settings agree
raise_warningsbool, optional, default=True: whether to warn the user if transformer is instance-wise in this case wrapping the transformer om TransformByLevel does not change the estimator logic, compared to not wrapping it. Wrapping this way can make sense in some cases of tuning, in which case warn=False can be set to suppress the warning raised.

Attributes:

transformer_sktime transformer, present only if groupby is “global”: clone of transformer used for fitting and transformation
transformers_pd.DataFrame of sktime transformer, present otherwise: entries are clones of transformer used for fitting and transformation

Examples

>>> from sktime.transformations.compose import TransformByLevel
>>> from sktime.transformations.hierarchical.reconcile import Reconciler
>>> from sktime.utils._testing.hierarchical import _make_hierarchical
>>> X = _make_hierarchical()
>>> f = TransformByLevel(Reconciler(), groupby="panel")
>>> f.fit(X)
TransformByLevel(...)

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 a dict of parameters values for this object.
`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 composed of other BaseObjects.
`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`(**params)	Set the parameters of this object.
`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.