PointReductionForecaster¶

`yohou.point.reduction.PointReductionForecaster` ¶

Bases: BaseReductionForecaster, BasePointForecaster

Point forecaster using sklearn estimators on tabularized time series.

Converts the time series point forecasting task to a tabular one.

Parameters¶

Name	Type	Description	Default
`estimator`	`BaseEstimator`	Point estimator used to fit the tabularized data.	`LinearRegression()`
`reduction_strategy`	`(direct, dir - rec, multi - output)`	Strategy for multi-step forecasting.	`"direct"`
`target_transformer`	`BaseTransformer or None`	Transformer for target preprocessing.	`None`
`feature_transformer`	`BaseTransformer or None`	Transformer for feature engineering (typically LagTransformer).	`None`
`target_as_feature`	`(transformed, raw)`	Whether to include the target variable as a feature for reduction. If `"transformed"`, the transformed target is used. If `"raw"`, the raw target is used. If `None`, the target is not included as a feature.	`"transformed"`
`panel_strategy`	`('global', multivariate)`	How to handle panel data. See `BaseForecaster` for details.	`"global"`
`nan_handling`	`(drop, 'pass')`	How to handle NaN values in tabularized data. `"pass"` leaves NaN in place (suitable for estimators that handle NaN natively, such as tree-based models). `"drop"` removes any training instance where X or y contains NaN before fitting the estimator, and emits a warning with the count of dropped rows. At predict time, returns NaN predictions for any time step whose features contain NaN.	`"drop"`
`n_jobs`	`int or None`	Number of jobs to run in parallel for the `"direct"` strategy (fitting and predicting H independent models). `None` means 1 unless in a `joblib.parallel_backend` context. `-1` means using all processors. Has no effect for `"multi-output"` or `"dir-rec"` strategies.	`None`
`step_feature_alignment`	`(all, matched, cumulative)`	Controls which step-indexed feature columns each direct estimator sees. Only affects the `"direct"` strategy. `"all"`: every estimator receives all step columns. `"matched"`: estimator for step h receives only `_step_h`. `"cumulative"`: estimator for step h receives `_step_1..h`.	`"all"`

Examples¶

>>> import polars as pl
>>> from datetime import datetime
>>> from yohou.point import PointReductionForecaster
>>>
>>> # Create simple time series data
>>> df = pl.DataFrame({
...     "time": pl.datetime_range(
...         start=datetime(2021, 1, 1), end=datetime(2021, 1, 10), interval="1d", eager=True
...     ),
...     "value": [10.0, 12.0, 15.0, 14.0, 16.0, 18.0, 20.0, 19.0, 21.0, 23.0],
... })
>>>
>>> # Split into train/test
>>> train = df[:8]
>>>
>>> # Create and fit forecaster
>>> forecaster = PointReductionForecaster()
>>> _ = forecaster.fit(y=train, forecasting_horizon=1)
>>>
>>> # Generate one-step prediction
>>> y_pred = forecaster.predict(forecasting_horizon=1)
>>> len(y_pred)
1
>>> sorted(y_pred.columns)
['time', 'value', 'vintage_time']

Notes¶

Reduction strategies:

Multi-output: A single model predicts all H horizon steps simultaneously. Simple and fast, but assumes the same model structure is appropriate for every step.
Direct: H independent models, one per horizon step. Each model specialises in its own step, avoiding error accumulation from recursive prediction but ignoring inter-step dependencies.
Dir-Rec (direct-recursive hybrid): H models are fitted sequentially. Model h predicts step h using the original features augmented with in-sample predictions from models 1 to h-1. This combines the specialised per-step training of the direct strategy with inter-step information flow.

For direct and dir-rec strategies, estimator_ becomes a list[BaseEstimator] of length H (one per horizon step) instead of a single estimator.

All strategies can be applied recursively for multi-step forecasting beyond the fit horizon by specifying a larger forecasting horizon during prediction.

Source Code¶

View on GitHub

Show/Hide sourceclass PointReductionForecaster(BaseReductionForecaster, BasePointForecaster):
    """Point forecaster using sklearn estimators on tabularized time series.

    Converts the time series point forecasting task to a tabular one.

    Parameters
    ----------
    estimator : BaseEstimator, default=LinearRegression()
        Point estimator used to fit the tabularized data.
    reduction_strategy : {"direct", "dir-rec", "multi-output"}, default="multi-output"
        Strategy for multi-step forecasting.
    target_transformer : BaseTransformer or None, default=None
        Transformer for target preprocessing.
    feature_transformer : BaseTransformer or None, default=None
        Transformer for feature engineering (typically LagTransformer).
    target_as_feature : {"transformed", "raw"} or None, default="transformed"
        Whether to include the target variable as a feature for reduction.
        If ``"transformed"``, the transformed target is used. If ``"raw"``,
        the raw target is used. If ``None``, the target is not included as
        a feature.
    panel_strategy : {"global", "multivariate"}, default="global"
        How to handle panel data. See `BaseForecaster` for details.
    nan_handling : {"drop", "pass"}, default="pass"
        How to handle NaN values in tabularized data.
        ``"pass"`` leaves NaN in place (suitable for estimators that
        handle NaN natively, such as tree-based models). ``"drop"``
        removes any training instance where X or y contains NaN before
        fitting the estimator, and emits a warning with the count of
        dropped rows. At predict time, returns NaN predictions for any
        time step whose features contain NaN.
    n_jobs : int or None, default=None
        Number of jobs to run in parallel for the ``"direct"`` strategy
        (fitting and predicting H independent models). ``None`` means 1
        unless in a ``joblib.parallel_backend`` context. ``-1`` means
        using all processors. Has no effect for ``"multi-output"`` or
        ``"dir-rec"`` strategies.
    step_feature_alignment : {"all", "matched", "cumulative"}, default="all"
        Controls which step-indexed feature columns each direct estimator
        sees. Only affects the ``"direct"`` strategy.

        - ``"all"``: every estimator receives all step columns.
        - ``"matched"``: estimator for step h receives only ``*_step_h``.
        - ``"cumulative"``: estimator for step h receives ``*_step_1..h``.

    Examples
    --------
    >>> import polars as pl
    >>> from datetime import datetime
    >>> from yohou.point import PointReductionForecaster
    >>>
    >>> # Create simple time series data
    >>> df = pl.DataFrame({
    ...     "time": pl.datetime_range(
    ...         start=datetime(2021, 1, 1), end=datetime(2021, 1, 10), interval="1d", eager=True
    ...     ),
    ...     "value": [10.0, 12.0, 15.0, 14.0, 16.0, 18.0, 20.0, 19.0, 21.0, 23.0],
    ... })
    >>>
    >>> # Split into train/test
    >>> train = df[:8]
    >>>
    >>> # Create and fit forecaster
    >>> forecaster = PointReductionForecaster()
    >>> _ = forecaster.fit(y=train, forecasting_horizon=1)
    >>>
    >>> # Generate one-step prediction
    >>> y_pred = forecaster.predict(forecasting_horizon=1)
    >>> len(y_pred)
    1
    >>> sorted(y_pred.columns)
    ['time', 'value', 'vintage_time']

    Notes
    -----
    Reduction strategies:

    - **Multi-output**: A single model predicts all H horizon steps
      simultaneously. Simple and fast, but assumes the same model
      structure is appropriate for every step.
    - **Direct**: H independent models, one per horizon step. Each
      model specialises in its own step, avoiding error accumulation
      from recursive prediction but ignoring inter-step dependencies.
    - **Dir-Rec** (direct-recursive hybrid): H models are fitted
      sequentially. Model h predicts step h using the original features
      augmented with in-sample predictions from models 1 to h-1. This
      combines the specialised per-step training of the direct
      strategy with inter-step information flow.

    For direct and dir-rec strategies, ``estimator_`` becomes a
    ``list[BaseEstimator]`` of length H (one per horizon step) instead
    of a single estimator.

    All strategies can be applied recursively for multi-step forecasting
    beyond the fit horizon by specifying a larger forecasting horizon
    during prediction.

    See Also
    --------
    - [`BaseReductionForecaster`][yohou.base.reduction.BaseReductionForecaster] : Base class for reduction forecasters.
    - [`LagTransformer`][yohou.preprocessing.window.LagTransformer] : Create lagged features for reduction strategies.

    """

    _parameter_constraints: dict = {
        **BaseReductionForecaster._parameter_constraints,
        **BasePointForecaster._parameter_constraints,
        "estimator": [HasMethods(["fit", "predict"])],
        "reduction_strategy": [StrOptions({"direct", "dir-rec", "multi-output"})],
    }

    _supports_panel = True

    def __init__(
        self,
        estimator: BaseEstimator = LinearRegression(),
        reduction_strategy: Literal["direct", "dir-rec", "multi-output"] = "multi-output",
        target_transformer: BaseTransformer | None = None,
        feature_transformer: BaseTransformer | None = None,
        target_as_feature: Literal["transformed", "raw"] | None = "transformed",
        step_feature_alignment: Literal["all", "matched", "cumulative"] = "all",
        nan_handling: Literal["drop", "pass"] = "pass",
        n_jobs: int | None = None,
        panel_strategy: Literal["global", "multivariate"] = "global",
    ) -> None:
        BaseReductionForecaster.__init__(
            self,
            estimator=estimator,
            reduction_strategy=reduction_strategy,
            target_as_feature=target_as_feature,
            step_feature_alignment=step_feature_alignment,
            nan_handling=nan_handling,
            n_jobs=n_jobs,
            panel_strategy=panel_strategy,
        )

        BasePointForecaster.__init__(
            self,
            target_transformer=target_transformer,
            feature_transformer=feature_transformer,
            target_as_feature=target_as_feature,
            panel_strategy=panel_strategy,
        )

    @_fit_context(prefer_skip_nested_validation=True)
    def fit(
        self,
        y: pl.DataFrame,
        X_actual: pl.DataFrame | None = None,
        forecasting_horizon: StrictInt = 1,
        time_weight: Callable | pl.DataFrame | dict | None = None,
        vintage_weight: Callable | pl.DataFrame | dict | None = None,
        sample_weight_alignment: str = "first_step",
        X_future: pl.DataFrame | None = None,
        X_forecast: pl.DataFrame | None = None,
        **params,
    ) -> "PointReductionForecaster":
        """Fit the forecaster to historical data.

        Tabularizes the time series and fits the wrapped sklearn estimator.

        Parameters
        ----------
        y : pl.DataFrame
            Target time series with a ``"time"`` column (datetime) and one
            or more numeric value columns.
        X_actual : pl.DataFrame or None, default=None
            Actual feature observations with a ``"time"`` column aligned
            with ``y``. Processed by the feature transformer to produce
            lags, rolling statistics, and other derived features. If
            ``None``, only target-derived features are used.
        forecasting_horizon : int, default=1
            Number of time steps to forecast into the future.
        time_weight : callable, pl.DataFrame, dict, or None, default=None
            Per-timestep weights for fitting.  Accepts a callable
            ``f(time_series) -> pl.Series``, a panel-aware callable
            ``f(time_series, group_name) -> pl.Series``, a DataFrame
            with ``"time"`` and ``"weight"`` columns, or a
            ``{datetime_or_str: float}`` dict (``"*"`` key sets default).
        vintage_weight : callable, pl.DataFrame, dict, or None, default=None
            Per-vintage weights for fitting.  Same formats as
            ``time_weight``.  Resolved via direct lookup at observation
            time (no alignment strategy). Combined multiplicatively
            with ``time_weight``.
        sample_weight_alignment : str, default="first_step"
            Strategy for converting ``time_weight`` to sklearn
            ``sample_weight`` across forecast horizons. Does not apply
            to ``vintage_weight`` (which uses direct lookup).
        X_future : pl.DataFrame or None, default=None
            Known future features with a ``"time"`` column. Deterministic
            values available for past and future dates. Bypasses the
            feature transformer.
        X_forecast : pl.DataFrame or None, default=None
            External forecasts with ``"vintage_time"`` and ``"time"``
            columns. Bypasses the feature transformer.
        **params : dict
            Metadata to route to nested estimators.

        Returns
        -------
        self
            The fitted forecaster instance.

        """
        forecasting_horizon = self._validate_fit_params(forecasting_horizon)

        y_t, X_t = self._pre_fit(
            y=y,
            X_actual=X_actual,
            forecasting_horizon=forecasting_horizon,
            X_future=X_future,
            X_forecast=X_forecast,
        )

        self.estimator_ = self._estimator_fit_one(
            y_t,
            X_t,
            forecasting_horizon,
            time_weight=time_weight,
            sample_weight_alignment=sample_weight_alignment,
            vintage_weight=vintage_weight,
            estimator_fit_params=params,
        )

        return self

    def _predict_one(
        self,
        groups: list[str],
        **params,
    ) -> pl.DataFrame:
        """Predicts `_fit_forecasting_horizon` steps from the observation horizon.

        Parameters
        ----------
        groups : list of str
            Panel group names to predict for.
        **params : dict
            Metadata to route to nested estimators.

        Returns
        -------
        pl.DataFrame
            Predicted time series.

        """
        y_pred = self._estimator_predict_one(self.estimator_, groups=groups)
        y_pred = self._add_time_columns(y_pred)

        return y_pred

Methods¶

`fit(y, X_actual=None, forecasting_horizon=1, time_weight=None, vintage_weight=None, sample_weight_alignment='first_step', X_future=None, X_forecast=None, **params)` ¶

Fit the forecaster to historical data.

Tabularizes the time series and fits the wrapped sklearn estimator.

Parameters¶

Name	Type	Description	Default
`y`	`DataFrame`	Target time series with a `"time"` column (datetime) and one or more numeric value columns.	required
`X_actual`	`DataFrame or None`	Actual feature observations with a `"time"` column aligned with `y`. Processed by the feature transformer to produce lags, rolling statistics, and other derived features. If `None`, only target-derived features are used.	`None`
`forecasting_horizon`	`int`	Number of time steps to forecast into the future.	`1`
`time_weight`	`callable, pl.DataFrame, dict, or None`	Per-timestep weights for fitting. Accepts a callable `f(time_series) -> pl.Series`, a panel-aware callable `f(time_series, group_name) -> pl.Series`, a DataFrame with `"time"` and `"weight"` columns, or a `{datetime_or_str: float}` dict (`"*"` key sets default).	`None`
`vintage_weight`	`callable, pl.DataFrame, dict, or None`	Per-vintage weights for fitting. Same formats as `time_weight`. Resolved via direct lookup at observation time (no alignment strategy). Combined multiplicatively with `time_weight`.	`None`
`sample_weight_alignment`	`str`	Strategy for converting `time_weight` to sklearn `sample_weight` across forecast horizons. Does not apply to `vintage_weight` (which uses direct lookup).	`"first_step"`
`X_future`	`DataFrame or None`	Known future features with a `"time"` column. Deterministic values available for past and future dates. Bypasses the feature transformer.	`None`
`X_forecast`	`DataFrame or None`	External forecasts with `"vintage_time"` and `"time"` columns. Bypasses the feature transformer.	`None`
`**params`	`dict`	Metadata to route to nested estimators.	`{}`

Returns¶

Type	Description
`self`	The fitted forecaster instance.

Source Code¶

View on GitHub

Show/Hide source@_fit_context(prefer_skip_nested_validation=True)
def fit(
    self,
    y: pl.DataFrame,
    X_actual: pl.DataFrame | None = None,
    forecasting_horizon: StrictInt = 1,
    time_weight: Callable | pl.DataFrame | dict | None = None,
    vintage_weight: Callable | pl.DataFrame | dict | None = None,
    sample_weight_alignment: str = "first_step",
    X_future: pl.DataFrame | None = None,
    X_forecast: pl.DataFrame | None = None,
    **params,
) -> "PointReductionForecaster":
    """Fit the forecaster to historical data.

    Tabularizes the time series and fits the wrapped sklearn estimator.

    Parameters
    ----------
    y : pl.DataFrame
        Target time series with a ``"time"`` column (datetime) and one
        or more numeric value columns.
    X_actual : pl.DataFrame or None, default=None
        Actual feature observations with a ``"time"`` column aligned
        with ``y``. Processed by the feature transformer to produce
        lags, rolling statistics, and other derived features. If
        ``None``, only target-derived features are used.
    forecasting_horizon : int, default=1
        Number of time steps to forecast into the future.
    time_weight : callable, pl.DataFrame, dict, or None, default=None
        Per-timestep weights for fitting.  Accepts a callable
        ``f(time_series) -> pl.Series``, a panel-aware callable
        ``f(time_series, group_name) -> pl.Series``, a DataFrame
        with ``"time"`` and ``"weight"`` columns, or a
        ``{datetime_or_str: float}`` dict (``"*"`` key sets default).
    vintage_weight : callable, pl.DataFrame, dict, or None, default=None
        Per-vintage weights for fitting.  Same formats as
        ``time_weight``.  Resolved via direct lookup at observation
        time (no alignment strategy). Combined multiplicatively
        with ``time_weight``.
    sample_weight_alignment : str, default="first_step"
        Strategy for converting ``time_weight`` to sklearn
        ``sample_weight`` across forecast horizons. Does not apply
        to ``vintage_weight`` (which uses direct lookup).
    X_future : pl.DataFrame or None, default=None
        Known future features with a ``"time"`` column. Deterministic
        values available for past and future dates. Bypasses the
        feature transformer.
    X_forecast : pl.DataFrame or None, default=None
        External forecasts with ``"vintage_time"`` and ``"time"``
        columns. Bypasses the feature transformer.
    **params : dict
        Metadata to route to nested estimators.

    Returns
    -------
    self
        The fitted forecaster instance.

    """
    forecasting_horizon = self._validate_fit_params(forecasting_horizon)

    y_t, X_t = self._pre_fit(
        y=y,
        X_actual=X_actual,
        forecasting_horizon=forecasting_horizon,
        X_future=X_future,
        X_forecast=X_forecast,
    )

    self.estimator_ = self._estimator_fit_one(
        y_t,
        X_t,
        forecasting_horizon,
        time_weight=time_weight,
        sample_weight_alignment=sample_weight_alignment,
        vintage_weight=vintage_weight,
        estimator_fit_params=params,
    )

    return self

Tutorials¶

The following example notebooks use this component:

How to Use ColumnTransformer

Data-Features

Route columns through distinct transformers with ColumnTransformer, including remainder handling and automatic panel-aware column detection.

View · Open in marimo
Decomposition

Data-Features

Chain PolynomialTrendForecaster, PatternSeasonalityForecaster, and FourierSeasonalityForecaster inside DecompositionPipeline with component visualisation.

View · Open in marimo
How to Compose Features with FeatureUnion

Data-Features

Combine lag features, rolling statistics, EMA, and scaling in parallel with FeatureUnion and automatic observation horizon resolution.

View · Open in marimo
How to Tune Fourier Seasonality Terms

Data-Features

Explore how Fourier harmonic count affects seasonal fit quality, compare Fourier vs Pattern seasonality, and tune harmonics jointly with GridSearchCV.

View · Open in marimo
How to Wrap Functions as Transformers

Data-Features

Wrap arbitrary polars or numpy operations as sklearn transformers with FunctionTransformer, supporting stateful warmup, inverse transforms, and pipelines.

View · Open in marimo
How to Handle Short Series

Data-Features

Use Fourier seasonality, simple train/test splits, and panel pooling when individual series are too short for standard approaches.

View · Open in marimo
How to Build a Feature Pipeline

Data-Features

Nest FeaturePipeline, FeatureUnion, and DecompositionPipeline for multi-level feature engineering with trend-season-residual decomposition.

View · Open in marimo
How to Use Scikit-learn Scalers

Data-Features

Wrap sklearn scalers (StandardScaler, MinMaxScaler, RobustScaler, PowerTransformer, PolynomialFeatures) for polars DataFrames with inverse transforms.

View · Open in marimo
How to Align Exogenous Features Across Pipeline Steps

Data-Features

Control which step-indexed columns each direct-strategy estimator sees using the step_feature_alignment parameter of PointReductionForecaster.

View · Open in marimo
How to Aggregate Scorer Results

Evaluation-Search

Demonstrate all scorer aggregation strategies (stepwise, vintagewise, componentwise, groupwise, coveragewise, all) on panel data with weighted group aggregation.

View · Open in marimo
How to Create a Custom Scorer

Evaluation-Search

Implement a custom point scorer with aggregation, panel support, and systematic testing.

View · Open in marimo
How to Run Hyperparameter Search

Evaluation-Search

Tune forecaster hyperparameters with GridSearchCV and RandomizedSearchCV using temporal cross-validation splitters and result scatter visualisation.

View · Open in marimo
How to Search Interval Forecaster Hyperparameters

Evaluation-Search

Tune interval forecaster parameters directly with interval metrics in GridSearchCV, including mixed point+interval multimetric search.

View · Open in marimo
How to Score Multi-Vintage Forecasts

Evaluation-Search

Generate multi-vintage predictions with observe_predict, score per step and per vintage, and visualize with heatmap, per-step, and per-vintage plots.

View · Open in marimo
How to Use Point Forecast Metrics

Evaluation-Search

Compare MAE, MAPE, MASE, RMSE, and other point metrics across multiple forecasters with componentwise and groupwise aggregation.

View · Open in marimo
How to Forecast with CatBoost

Forecasting-Models

Plug CatBoostRegressor into PointReductionForecaster as a drop-in sklearn estimator, compare gradient-boosted versus Ridge linear baseline, and demonstrate the direct reduction strategy with tree-based models.

View · Open in marimo
How to Choose a Decomposition Strategy

Forecasting-Models

Build 2- and 3-component DecompositionPipeline forecasters chaining trend, seasonality, and residual models with target pre-transformation.

View · Open in marimo
How to Use Distance-Based Similarity for Intervals

Forecasting-Models

Adaptive prediction intervals via similarity-weighted conformal prediction using DistanceSimilarity with configurable distance metrics and bandwidths.

View · Open in marimo
How to Build a Lag-Feature Forecaster

Forecasting-Models

Chain feature and target forecasters with ForecastedFeatureForecaster when exogenous variables are unknown at prediction time and must be forecasted.

View · Open in marimo
How to Use Lagged Forecasts as Features

Forecasting-Models

Compare ForecastedFeatureForecaster strategies (actual, predicted, rewind) and split ratio tuning for chaining feature and target forecasters.

View · Open in marimo
How to Produce Multi-Vintage Predictions

Forecasting-Models

Generate multiple predictions from different weather forecast vintages without refitting, using the X_forecast predict-time override.

View · Open in marimo
How to Apply Time-Weighted Training

Forecasting-Models

Use time_weight and sample_weight_alignment to emphasise recent or seasonal training samples in PointReductionForecaster, with visualisation of weight curves and alignment strategy comparison.

View · Open in marimo
How to Combine Interval Forecasters

Forecasting-Models

Build interval ensembles with VotingIntervalForecaster using envelope, mean, and median aggregation strategies.

View · Open in marimo
How to Combine Forecasters with VotingPointForecaster

Forecasting-Models

Build point ensembles with VotingPointForecaster using mean, weighted, and median aggregation strategies.

View · Open in marimo
How to Choose a Forecasting Method

Getting-Started

Interactive decision guide progressing from SeasonalNaive baseline through linear reduction, stationarity transforms, feature enrichment, nonlinear models, decomposition, and prediction intervals.

View · Open in marimo
Conformal Prediction Intervals

Getting-Started

Build distribution-free prediction intervals with SplitConformalForecaster using calibration holdouts and configurable conformity scoring functions.

View · Open in marimo
How to Create a Custom Transformer

Getting-Started

Implement a ScaleTransformer from scratch, validate it with the check generator, and use it in a forecast pipeline.

View · Open in marimo
Exogenous Features (X_actual, X_future, X_forecast)

Getting-Started

Build a forecasting model with actual observations, known-future indicators, and multi-vintage external forecasts on synthetic electricity price data.

View · Open in marimo
Forecasting Workflow

Getting-Started

Evaluate forecasters with cross-validation, search hyperparameters with GridSearchCV, and inspect residuals to diagnose model weaknesses.

View · Open in marimo
Interval Forecasting

Getting-Started

Wrap a point forecaster with SplitConformalForecaster to produce 95% prediction intervals with statistical coverage guarantees.

View · Open in marimo
Observe-Predict Workflow

Getting-Started

Walk through a test set in batches, updating forecasts as new data arrives with observe_predict.

View · Open in marimo
Reduction Forecasting Walkthrough

Getting-Started

Walk through the full fit/predict/evaluate cycle with PointReductionForecaster, cross-validation, and grid search on a real dataset.

View · Open in marimo
Direct, Recursive, and MIMO Strategies

Getting-Started

Compare direct, recursive, and MIMO reduction strategies across forecasting horizons to understand the trade-offs for your use case.

View · Open in marimo
How to Save and Load Forecasters

Getting-Started

Serialize fitted forecasters with joblib and pickle, reload them in a fresh session, and produce predictions without retraining.

View · Open in marimo
How to Configure LocalPanelForecaster

Panel-Data

Wrap any forecaster with LocalPanelForecaster for fully independent per-group clones, parallel fitting via n_jobs, and selective group operations.

View · Open in marimo
How to Forecast Multiple Columns Independently

Panel-Data

Use ColumnForecaster to apply a point forecaster independently to each column of a multivariate time series.

View · Open in marimo
How to Run Panel Cross-Validation

Panel-Data

Time series cross-validation on panel data with GridSearchCV, selective group observation, rewind operations, and groupwise performance comparison.

View · Open in marimo
How to Forecast Panel Prediction Intervals

Panel-Data

Combine conformal and quantile regression intervals on panel data with per-group coverage analysis, calibration plots, and groupwise interval scoring.

View · Open in marimo
How to Build Panel Feature Pipelines

Panel-Data

Combine ColumnForecaster, FeaturePipeline, FeatureUnion, and DecompositionPipeline on panel data with per-group scoring on KDD Cup air quality.

View · Open in marimo
How to Apply Stationarity to Panel Data

Panel-Data

Apply per-group stationarity transforms on panel data with SeasonalDifferencing, DecompositionPipeline (polynomial trend + pattern seasonality), and residuals.

View · Open in marimo
Quickstart

Quickstart

Comprehensive end-to-end tour of yohou beyond the Getting Started tutorials, covering data loading, baseline forecasting, preprocessing pipelines, decomposition, cross-validation search, and interval prediction.

View · Open in marimo
How to Visualize Forecast Evaluation Results

Visualization

Use plot_calibration, plot_score_per_step, and plot_forecast to diagnose forecast accuracy and interval calibration visually.

View · Open in marimo
Forecast Visualization

Visualization

Visualise point forecasts from single and multiple models, decomposition pipeline components, and time weight decay functions with interactive Plotly.

View · Open in marimo
How to Visualize Forecasts

Visualization

Plot point forecasts, compare multiple models, render prediction interval bands, inspect residual diagnostics, and check interval calibration.

View · Open in marimo

PointReductionForecaster¶

yohou.point.reduction.PointReductionForecaster ¶

Parameters¶

Examples¶

Notes¶

See Also¶

Source Code¶

Methods¶

fit(y, X_actual=None, forecasting_horizon=1, time_weight=None, vintage_weight=None, sample_weight_alignment='first_step', X_future=None, X_forecast=None, **params) ¶

Parameters¶

Returns¶

Source Code¶

Tutorials¶

`yohou.point.reduction.PointReductionForecaster` ¶

`fit(y, X_actual=None, forecasting_horizon=1, time_weight=None, vintage_weight=None, sample_weight_alignment='first_step', X_future=None, X_forecast=None, **params)` ¶