Docs /Templates/ sinapsis-sktime

SklearnClassifierPipelineSKTimeWrapper

sinapsis-sktimeSKTimedynamicinferencemodelsprediction

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 set

Installation

Install the published package using pip or uv.

Terminalbash
pip install sinapsis-sktime==1.0.0
uv pip install sinapsis-sktime==1.0.0
uv add sinapsis-sktime==1.0.0

Configuration

Effective fields from the inspector schema, including nested Pydantic model fields.

metadata
sinapsis_core.template_base.base_models.TemplateMetadata | None
Optional
Default: null
root_dir
str
Optional
Default: "/sinapsis-hub/private/platform/sinapsis-hub/playground/publish"
model_save_pathRequired

Path where the trained model will be saved. sklearnclassifierpipeline_init classifier <class 'type'>: default: <class 'inspect._empty'> transformers <class 'type'>: default: <class 'inspect._empty'>

str
Required
Default: null
sklearnclassifierpipeline_initRequired
SklearnClassifierPipelineAttributes
Required
Default: null
classifier
type
Optional
Default: null
transformers
type
Optional
Default: null

Configuration example

Generated from documented defaults. Replace any placeholders and complete required nested settings before running.

yaml
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

Immediate parent: sinapsis_sktime.templates.sktime_classifiers.SKTimeComposeClassifiers

Environment variables

Environment definitions belong to their canonical Python modules.

SINAPSIS_BUILD_DOCS · defined elsewhere