ClassifierPipeline

ClassifierPipeline

class ClassifierPipeline(classifier, transformers)[source]

Pipeline of transformers and a classifier.

The ClassifierPipeline compositor chains transformers and a single classifier. The pipeline is constructed with a list of sktime transformers, plus a classifier,

i.e., estimators following the BaseTransformer resp BaseClassifier 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 classifier clf,

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 clf.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 clf.predict on the output of trafoN.transform, and returning the output of clf.predict

predict_proba(X) - result is of executing trafo1.transform, trafo2.transform,

etc, with trafo[i].transform input = output of trafo[i-1].transform, then running clf.predict_proba on the output of trafoN.transform, and returning the output of clf.predict_proba

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)

ClassifierPipeline can also be created by using the magic multiplication

on any classifier, i.e., if my_clf inherits from BaseClassifier,

and my_trafo1, my_trafo2 inherit from BaseTransformer, then, for instance, my_trafo1 * my_trafo2 * my_clf will result in the same object as obtained from the constructor ClassifierPipeline(classifier=my_clf, 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:

classifiersktime classifier, i.e., estimator inheriting from BaseClassifier

this is a “blueprint” classifier, state does not change when fit is called

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

classifier_sktime classifier, clone of classifier in classifier

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.pca import PCATransformer
>>> from sktime.classification.interval_based import TimeSeriesForestClassifier
>>> from sktime.datasets import load_unit_test
>>> from sktime.classification.compose import ClassifierPipeline
>>> X_train, y_train = load_unit_test(split="train")
>>> X_test, y_test = load_unit_test(split="test")
>>> pipeline = ClassifierPipeline(
...     TimeSeriesForestClassifier(n_estimators=5), [PCATransformer()]
... )
>>> pipeline.fit(X_train, y_train)
ClassifierPipeline(...)
>>> y_pred = pipeline.predict(X_test)

Alternative construction via dunder method:

>>> pipeline = PCATransformer() * TimeSeriesForestClassifier(n_estimators=5)

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 time series classifier to training data.
fit_predict(X, y[, cv, change_state])	Fit and predict labels for sequences in X.
fit_predict_proba(X, y[, cv, change_state])	Fit and predict labels probabilities for sequences in X.
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 in transformers.
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.
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.
predict(X)	Predicts labels for sequences in X.
predict_proba(X)	Predicts labels probabilities for sequences in X.
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.
score(X, y)	Scores predicted labels against ground truth labels on X.
set_config(**config_dict)	Set config flags to given values.
set_params(**kwargs)	Set the parameters of estimator in transformers.
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.