SklearnClassifierPipelineSKTimeWrapper
Python template · sinapsis_sktime.templates.sktime_classifiers
Overview
Template for SkTime classification model training and inference for the compose module.
SklearnClassifierPipeline — inherited documentation
Pipeline of transformers and a classifier.
The ``SklearnClassifierPipeline`` chains transformers and an single classifier. Similar to ``ClassifierPipeline``, but uses a tabular ``sklearn`` classifier. The pipeline is constructed with a list of sktime transformers, plus a classifier, i.e., transformers following the BaseTransformer interface, classifier follows the ``scikit-learn`` classifier 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`` the output of ``trafo[N]`` converted to numpy, and ``y`` identical with the input to ``self.fit``. ``X`` is converted to ``numpyflat`` mtype if ``X`` is of ``Panel`` scitype; ``X`` is converted to ``numpy2D`` mtype if ``X`` is of ``Table`` scitype. ``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 numpy converted output of ``trafoN.transform``, and returning the output of ``clf.predict``. Output of ``trasfoN.transform`` is converted to numpy, as in ``fit``. ``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``. Output of ``trasfoN.transform`` is converted to numpy, as in ``fit``.
``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)
``SklearnClassifierPipeline`` can also be created by using the magic multiplication between ``sktime`` transformers and ``sklearn`` classifiers, 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 ``SklearnClassifierPipeline(classifier=my_clf, transformers=[t1, t2])`` magic multiplication can also be used with (str, transformer) pairs, as long as one element in the chain is a transformer
Parameters ---------- classifier : sklearn classifier, i.e., inheriting from sklearn ClassifierMixin this is a "blueprint" classifier, state does not change when ``fit`` is called transformers : list 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_ : sklearn 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 sklearn.neighbors import KNeighborsClassifier >>> from sktime.transformations.exponent import ExponentTransformer >>> from sktime.transformations.summarize import SummaryTransformer >>> from sktime.datasets import load_unit_test >>> from sktime.classification.compose import SklearnClassifierPipeline >>> X_train, y_train = load_unit_test(split="train") >>> X_test, y_test = load_unit_test(split="test") >>> t1 = ExponentTransformer() >>> t2 = SummaryTransformer() >>> pipeline = SklearnClassifierPipeline(KNeighborsClassifier(), [t1, t2]) >>> pipeline = pipeline.fit(X_train, y_train) >>> y_pred = pipeline.predict(X_test)
Alternative construction via dunder method:
>>> pipeline = t1 * t2 * KNeighborsClassifier()
Capabilities
Capabilities: not setInstallation
Install the published package using pip or uv.
pip install sinapsis-sktime==1.0.0uv pip install sinapsis-sktime==1.0.0uv add sinapsis-sktime==1.0.0Configuration
Effective fields from the inspector schema, including nested Pydantic model fields.
Optional
Default: null
Optional
Default: "/sinapsis-hub/private/platform/sinapsis-hub/playground/publish"
Path where the trained model will be saved. sklearnclassifierpipeline_init classifier <class 'type'>: default: <class 'inspect._empty'> transformers <class 'type'>: default: <class 'inspect._empty'>
Required
Default: null
Required
Default: null
Optional
Default: null
Optional
Default: null
Configuration example
Generated from documented defaults. Replace any placeholders and complete required nested settings before running.
templates:
- template_name: "SklearnClassifierPipelineSKTimeWrapper"
class_name: "SklearnClassifierPipelineSKTimeWrapper"
attributes:
root_dir: "/sinapsis-hub/private/platform/sinapsis-hub/playground/publish"
model_save_path: "<required>"
sklearnclassifierpipeline_init:
classifier: {}
transformers: {}
Inheritance
sinapsis_sktime.templates.sktime_classifiers.SKTimeComposeClassifiersEnvironment variables
Environment definitions belong to their canonical Python modules.