TSFreshRelevantFeatureExtractor

class TSFreshRelevantFeatureExtractor(default_fc_parameters='efficient', kind_to_fc_parameters=None, chunksize=None, n_jobs=1, show_warnings=True, disable_progressbar=False, impute_function=None, profiling=None, profiling_filename=None, profiling_sorting=None, distributor=None, test_for_binary_target_binary_feature=None, test_for_binary_target_real_feature=None, test_for_real_target_binary_feature=None, test_for_real_target_real_feature=None, fdr_level=None, hypotheses_independent=None, ml_task='auto')[source]

Transformer for extracting time series features via tsfresh.extract_features.

Direct interface to tsfresh.extract_features [1] followed by the tsfresh FeatureSelector class as an sktime transformer.

Parameters:

default_fc_parametersstr, FCParameters object or None,: default=None = tsfresh default = “comprehensive” Specifies pre-defined feature sets to be extracted If str, should be in [“minimal”, “efficient”, “comprehensive”] See [3] for more details.
kind_to_fc_parameterslist or None, default=None: List containing strings specifying selected features to be extracted. The naming convention from tsfresh applies, i.e. the strings should be structured as: {time_series_name}__{feature_name}__{param name 1}_ {param value 1}__[..]__{param name k}_{param value k}. See [2] for more details and [4] for viable options. Either default_fc_parameters or kind_to_fc_parameters should be passed. If both are passed, only features specified in kind_to_fc_parameters are extracted. If neither is passed, it calculates the “comprehensive” feature set.
n_jobsint, default=1: The number of processes to use for parallelization. If zero, no parallelization is used.
chunksizeNone or int, default=None: The size of one chunk that is submitted to the worker process for the parallelisation. Where one chunk is defined as a singular time series for one id and one kind. If you set the chunksize to 10, then it means that one task is to calculate all features for 10 time series. If it is set it to None, depending on distributor, heuristics are used to find the optimal chunksize. If you get out of memory exceptions, you can try it with the dask distributor and a smaller chunksize.
show_warningsbool, default=True: Show warnings during the feature extraction (needed for debugging of calculators).
disable_progressbarbool, default=False: Do not show a progressbar while doing the calculation.
impute_functionNone or Callable, default=None: None, if no imputing should happen or the function to call for imputing the result dataframe. Imputing will never happen on the input data.
profilingbool, default=None: Turn on profiling during feature extraction.
profiling_sortingbasestring, default=None: How to sort the profiling results (see the documentation of the tsfresh profiling package for more information).
profiling_filenamebasestring, default=None: Where to save the profiling results.
distributordistributor class, default=None: Advanced parameter: class to use as a distributor. See the tsfresh package utilities/distribution.py for more information. The default=None has the tsfresh default implementation choose the distributor.
test_for_binary_target_binary_featurestr or None, default=None: Which test to be used for binary target, binary feature (currently unused).
test_for_binary_target_real_featurestr or None, default=None: Which test to be used for binary target, real feature.
test_for_real_target_binary_featurestr or None, default=None: Which test to be used for real target, binary feature (currently unused).
test_for_real_target_binary_featurestr or None, default=None: Which test to be used for real target, real feature (currently unused)
fdr_level: floar or None, default=None: The FDR level that should be respected, this is the theoretical expected percentage of irrelevant features among all created features.
hypotheses_independent: bool or None, default=None: Can the significance of the features be assumed to be independent? Normally, this should be set to False as the features are never independent (e.g. mean and median)
ml_task: sre, default=”auto”: The intended machine learning task. Either 'classification', 'regression' or 'auto'. Defaults to 'auto', meaning the intended task is inferred from y. If y has a boolean, integer or object dtype, the task is assumed to be classification, else regression.

Attributes:

is_fitted: Whether fit has been called.

References

[1]

https://github.com/blue-yonder/tsfresh

[2]

https://tsfresh.readthedocs.io/en/v0.1.2/text/feature_naming.html

[3]

https://tsfresh.readthedocs.io/en/latest/text/ feature_extraction_settings.html

[4]

https://tsfresh.readthedocs.io/en/latest/api/tsfresh.feature_extraction.html #module-tsfresh.feature_extraction.feature_calculators

[5]

Christ, M., Braun, N., Neuffer, J., and Kempa-Liehr A.W. (2018). Time Series FeatuRe Extraction on basis of Scalable Hypothesis tests (tsfresh – A Python package). Neurocomputing 307 (2018) 72-77

Examples

>>> from sklearn.model_selection import train_test_split
>>> from sktime.datasets import load_arrow_head
>>> from sktime.transformations.tsfresh import (
...     TSFreshRelevantFeatureExtractor
... )
>>> X, y = load_arrow_head(return_X_y=True)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y)
>>> ts_eff = TSFreshRelevantFeatureExtractor(
...     default_fc_parameters="efficient", disable_progressbar=True
... )
>>> X_transform1 = ts_eff.fit_transform(X_train, y_train)
>>> features_to_calc = [
...     "dim_0__quantile__q_0.6",
...     "dim_0__longest_strike_above_mean",
...     "dim_0__variance",
... ]
>>> ts_custom = TSFreshRelevantFeatureExtractor(
...     kind_to_fc_parameters=features_to_calc, disable_progressbar=True
... )
>>> X_transform2 = ts_custom.fit_transform(X_train, y_train)

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.