BoxCoxTransformer

class BoxCoxTransformer(bounds=None, method='mle', sp=None, lambda_fixed=0.0, enforce_positive=True)[source]

Box-Cox power transform with fittable lambda parameter.

The Box-Cox transformation is a power transformation that is used to make data more normally distributed and stabilize its variance based on the hyperparameter lambda. [1]

This transformer applies the Box-Cox-transform elementwise, where the lambda parameter is fitted by the specified method via method.

The Box-Cox-transform is defined as \(y\mapsto \frac{y^{\lambda}-1}{\lambda}, \lambda \ne 0 \text{ and } ln(y), \lambda = 0\), for positive \(y\).

The \(\lambda\) parameter is fitted per time series and instance and variable, by a method depending on the method parameter:

"pearsonr" - maximization of Pearson correlation between transformed and normalized untransformed. Direct interface to scipy.stats.boxcox_normmax with method="pearsonr", with bracket=bounds, and otherwise defaults.
"mle" - maximization of the Box-Cox log-likelihood. Direct interface to scipy.stats.boxcox_normmax with method="mle" with bracket=bounds, and otherwise defaults.
"guerrero" - Guerrero’s method with seasonal periodicity, see [2]. this requires the seasonality parameter to be passed as sp.
"fixed" - fixed, pre-specified \(\lambda\), which is passed as lambda_fixed.

If non-positive :math:y are present, they are by default replaced with their absolute values in fit. In transform, the signed Box-Cox-transform is applied, i.e., the sign is kept while the transform is applied to the value.

Direct interface to scipy boxcox, and inv_boxcox for transformation, scipy boxcox_normmax and a custom implementation of Guerrero’s method for fitting the Box-Cox lambda parameter.

Parameters:

bounds2-tuple of finite float: Initial bracket (lower, upper) for the optimization range when fitting the value of lambda. Default = unbounded. Ignored if method == "fixed". For half-open bounds pass a large bound value, e.g., (0, 1e12) for positive lambda. Infinity and nan as bound values are not supported.
method{“pearsonr”, “mle”, “guerrero”, “fixed”}, default=”mle”: The optimization approach used to determine the lambda value used in the Box-Cox transformation.
spint, optional, must be provided (only) if method=”guerrero”: Seasonal periodicity of the data in integer form. Only used if method=”guerrero” is chosen. Must be an integer >= 2.
lambda_fixedfloat, optional, default = 0.0: must be provided (only) if method=”fixed” default means that BoxCoxTransformer behaves like logarithm
enforce_positivebool, optional, default = True: If True`, in ``fit negative entries of X are replaced by their absolute values. In transform, the transform is applied to the absolute value while the sign is kept. If False, any negative values will be passed unchanged to the underlying functions (possibly causing error).

Attributes:

lambda_float: The Box-Cox lambda parameter that was fitted, based on the supplied method and data provided in fit.

References

[1]

Box, G. E. P. & Cox, D. R. (1964) An analysis of transformations, Journal of the Royal Statistical Society, Series B, 26, 211-252.

[2]

V.M. Guerrero, “Time-series analysis supported by Power Transformations “, Journal of Forecasting, vol. 12, pp. 37-48, 1993.

Examples

>>> from sktime.transformations.boxcox import BoxCoxTransformer
>>> from sktime.datasets import load_airline
>>> y = load_airline()
>>> transformer = BoxCoxTransformer()
>>> y_hat = transformer.fit_transform(y)

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.