Docs /Templates/ sinapsis-darts-forecasting

InvertibleDataTransformerWrapper

sinapsis-darts-forecastingDartsdatadartsdynamicforecasting

Python template · sinapsis_darts_forecasting.templates.time_series_preprocessing

Overview

A dynamic preprocessing template for applying Darts transformations to time series data.

This template allows users to apply various transformations from `darts.dataprocessing.transformers` to different parts of the time series packet (`content`, `past_covariates`, `future_covariates`).

If a transformer requires fitting (e.g., `Scaler`), it stores and retrieves transformation parameters.

InvertibleDataTransformer — inherited documentation

Helper class that provides a standard way to create an ABC using inheritance.Abstract class for invertible transformers.

All the deriving classes have to implement the static methods :func:`ts_transform()` and :func:`ts_inverse_transform()`. For information on how to implement the :func:`ts_transform` method, please refer to the :class:`.BaseDataTransformer` documentation.

The :func:`ts_inverse_transform()` method should be implemented in a virtually identical way to the :func:`ts_transform()` method: it should accept a ``TimeSeries`` as a first argument, and a dictionary of fixed parameters (as well as fitted parameters if the transformation also inherits from `FittableDataTransformer`) as a second argument. Additionally, :func:`ts_inverse_transform()` should also accept `*args` and `**kwargs` if additional positional/keyword arguments are expected to be passed. The only difference between :func:`ts_inverse_transform()` and :func:`ts_transform()` is that the former should 'undo' the transformation made to a `TimeSeries` by the latter. Please refer to the :func:`ts_inverse_transform()` documentation for further information.

This class takes care of parallelizing the transformation on multiple ``TimeSeries`` when possible.

Parameters ---------- name The data transformer's name n_jobs The number of jobs to run in parallel. Parallel jobs are created only when a Sequence[TimeSeries] is passed as input to a method, parallelising operations regarding different TimeSeries. Defaults to `1` (sequential). Setting the parameter to `-1` means using all the available processors. Note: for a small amount of data, the parallelisation overhead could end up increasing the total required amount of time. verbose Optionally, whether to print operations progress parallel_params Optionally, specifies which fixed parameters (i.e. the attributes initialized in the child-most class's `__init__`) take on different values for different parallel jobs. Fixed parameters specified by `parallel_params` are assumed to be a `Sequence` of values that should be used for that parameter in each parallel job; the length of this `Sequence` should equal the number of parallel jobs. If `parallel_params=True`, every fixed parameter will take on a different value for each parallel job. If `parallel_params=False`, every fixed parameter will take on the same value for each parallel job. If `parallel_params` is a `Sequence` of fixed attribute names, only those attribute names specified will take on different values between different parallel jobs. mask_components Optionally, whether to automatically apply any provided `component_mask`s to the `TimeSeries` inputs passed to `transform`, `fit`, `inverse_transform`, or `fit_transform`. If `True`, any specified `component_mask` will be applied to each input timeseries before passing them to the called method; the masked components will also be automatically 'unmasked' in the returned `TimeSeries`. If `False`, then `component_mask` (if provided) will be passed as a keyword argument, but won't automatically be applied to the input timeseries. See `apply_component_mask` method of `BaseDataTransformer` for further details.

Notes ----- Note: the :func:`ts_transform()` and :func:`ts_inverse_transform()` methods are designed to be static methods instead of instance methods to allow an efficient parallelisation also when the scaler instance is storing a non-negligible amount of data. Using instance methods would imply copying the instance's data through multiple processes, which can easily introduce a bottleneck and nullify parallelisation benefits.

Example -------- >>> from darts.dataprocessing.transformers import InvertibleDataTransformer >>> from darts.utils.timeseries_generation import linear_timeseries >>> >>> class SimpleTransform(InvertibleDataTransformer): >>> >>> def __init__(self, a): >>> self._a = a >>> super().__init__() >>> >>> @staticmethod >>> def ts_transform(series, params, **kwargs): >>> a = params['fixed']['_a'] >>> b = kwargs.pop('b') >>> return a*series + b >>> >>> @staticmethod >>> def ts_inverse_transform(series, params, **kwargs): >>> a = params['fixed']['_a'] >>> b = kwargs.pop('b') >>> return (series - b) / a >>> >>> series = linear_timeseries(length=5) >>> print(series.values()) [[0. ] [0.25] [0.5 ] [0.75] [1. ]] >>> transform = SimpleTransform(a=2) >>> series = transform.transform(series, b=3) >>> print(series.values()) [[3. ] [3.5] [4. ] [4.5] [5. ]] >>> series = transform.inverse_transform(series, b=3) >>> print(series.values()) [[0. ] [0.25] [0.5 ] [0.75] [1. ]]

Capabilities

Capabilities: not set

Installation

Install the published package using pip or uv.

Terminalbash
pip install sinapsis-darts-forecasting==1.0.0
uv pip install sinapsis-darts-forecasting==1.0.0
uv add sinapsis-darts-forecasting==1.0.0

Configuration

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

methodRequired
typing.Literal['fit', 'transform', 'fit_transform', 'inverse_transform']
Required
Default: null
apply_toRequired
list[typing.Literal['content', 'past_covariates', 'future_covariates', 'predictions']]
Required
Default: null
metadata
sinapsis_core.template_base.base_models.TemplateMetadata | None
Optional
Default: null
params_key
str | None
Optional
Default: null
transform_kwargs
dict[str, typing.Any]
Optional
Default: null
invertibledatatransformer_initRequired
__init__Attributes
Required
Default: null
name
str
Optional
Default: "InvertibleDataTransformer"
n_jobs
int
Optional
Default: 1
verbose
bool
Optional
Default: false
mask_components
bool
Optional
Default: true
parallel_params
typing.Union[bool, collections.abc.Sequence[str]]
Optional
Default: false

Configuration example

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

yaml
templates:
  - template_name: "InvertibleDataTransformerWrapper"
    class_name: "InvertibleDataTransformerWrapper"
    attributes:
      method: "<required>"
      apply_to: "<required>"
      params_key: null
      transform_kwargs: null
      invertibledatatransformer_init:
        name: "InvertibleDataTransformer"
        n_jobs: 1
        verbose: false
        mask_components: true
        parallel_params: false
View original docstring example

The source example references MissingValuesFillerWrapper, not InvertibleDataTransformerWrapper.

yaml
agent:
  name: my_test_agent
templates:
- template_name: InputTemplate
  class_name: InputTemplate
  attributes: {}
- template_name: MissingValuesFillerWrapper
  class_name: MissingValuesFillerWrapper
  template_input: InputTemplate
  attributes:
    method: "transform"
    apply_to: ["content"]
    transform_kwargs:
        method: "linear"
    missingvaluesfiller_init:
        fill: "auto"
        name: "MissingValuesFiller"
        n_jobs: 1
        verbose: False
For a full list of options use the sinapsis cli: sinapsis info --all-template-names
If you want to see all available transformers, please visit: https://unit8co.github.io/darts/generated_api/darts.dataprocessing.transformers.html

Inheritance

Immediate parent: sinapsis_darts_forecasting.templates.time_series_preprocessing.TimeSeriesPreprocessor

Environment variables

Environment definitions belong to their canonical Python modules.

SINAPSIS_BUILD_DOCS · defined elsewhere