How to Transform Features on the Forecast Channel¶

This guide shows you how to apply transformers to an X_forecast frame, using PerVintageActualTransformer. Use this when your exogenous features arrive as forecasts (carrying vintage_time and time) and you need to derive features from them, for example computing net load from load, wind, and solar forecasts before feeding them to a forecaster's X_forecast channel.

Prerequisites¶

• Familiarity with transformers (How to Use Preprocessing Transformers)
• Understanding of forecast vintages (How to Work with Forecast Vintages)

Try it interactively¶

An X_forecast frame carries two time axes, vintage_time and time, so an ordinary single-axis transformer cannot consume it. PerVintageActualTransformer wraps an actual transformer and fits and applies it to each vintage independently. For why the two kinds exist, see Transformer Kinds.

Derive a Feature per Vintage¶

Wrap any actual transformer. Here a FunctionTransformer computes net load from load and wind forecasts:

import polars as pl
from yohou.preprocessing import FunctionTransformer
from yohou.compose import PerVintageActualTransformer

net_load = PerVintageActualTransformer(
    FunctionTransformer(
        func=lambda df: df.select((pl.col("load") - pl.col("wind")).alias("net_load")),
        feature_names_out=lambda self, names: ["net_load"],
    )
)

X_forecast_t = net_load.fit_transform(X_forecast)
# columns: ["vintage_time", "time", "net_load"]

The vintage_time and time index columns are preserved, and each vintage's net_load is computed from only that vintage's rows.

Fit a Transformer per Vintage¶

net_load learns nothing, so per-vintage handling only keeps its rows aligned. The wrapper earns its keep when the inner fits from data: each vintage is fitted on its own rows, so a scaler standardizes each forecast trajectory to its own scale, and an imputer fills each vintage's gaps from that vintage's own values.

from yohou.preprocessing import SimpleImputer

# each vintage's missing values are filled with that vintage's own mean
impute = PerVintageActualTransformer(SimpleImputer(strategy="mean"))
X_forecast_t = impute.fit_transform(X_forecast)

This is leakage-free: a vintage's output depends only on its own rows, all of which are known at that vintage's vintage_time. It is a different operation from normalizing X_forecast against the training distribution; for that, put the scaler in the estimator pipeline (estimator=make_pipeline(StandardScaler(), model)) so it fits on the tabularized training matrix instead.

Compose Several Forecast Transformers¶

The composition estimators accept forecast transformers too. A FeatureUnion of forecast transformers is itself forecast-kind and aligns its branches on (vintage_time, time):

from yohou.compose import FeatureUnion

features = FeatureUnion([
    ("net_load", net_load),
    ("wind_share", PerVintageActualTransformer(
        FunctionTransformer(
            func=lambda df: df.select(
                (pl.col("wind") / pl.col("load")).alias("wind_share")
            ),
            feature_names_out=lambda self, names: ["wind_share"],
        )
    )),
])

Each branch is lifted independently, so a branch may be stateful. A branch computing a ramp (pl.col("load").diff()) works, but FunctionTransformer measures the .diff() as an observation_horizon of 1, so that branch drops each vintage's first step, and the union drops it from every other branch too.

A composition must be homogeneous in kind: mixing actual and forecast transformers in one FeatureUnion, FeaturePipeline, or ColumnTransformer raises a ValueError.

Equivalently, you can compose-then-lift, building a union of actual transformers and lifting the whole thing once:

PerVintageActualTransformer(FeatureUnion([
    ("net_load", FunctionTransformer(func=..., feature_names_out=...)),
    ("wind_share", FunctionTransformer(func=..., feature_names_out=...)),
]))

Feed the Result to a Forecaster¶

Put the transformer in the forecaster's forecast_transformer slot and pass the raw frame:

forecaster = PointReductionForecaster(
    Ridge(),
    forecast_transformer=PerVintageActualTransformer(StandardScaler()),
)
forecaster.fit(y_train, X_forecast=X_forecast, forecasting_horizon=24)

The slot fits the transformer on X_forecast and applies it before the step columns are derived, so the columns reaching the estimator are built from transformed values. Prefer this to transforming outside the forecaster:

# Works, but the transform is invisible to the forecaster.
forecaster.fit(y_train, X_forecast=features.fit_transform(X_forecast))

Transforming outside costs three things. The transform is not tunable, because there is no nested __ path for a search to reach; it is not carried by clone, so cross-validation and search never see it; and it must be re-applied by hand on every observe and rewind in a walk-forward loop. In the slot, forecast_transformer__transformer__lag is a search parameter like any other, and the lifecycle is handled for you.

Each slot takes the kind it is named for. A forecast-kind transformer belongs in forecast_transformer, which applies it to the vintage-indexed X_forecast. Passing one as actual_transformer or target_transformer raises a ValueError, because those slots process single-axis frames. The reverse also raises: an actual-kind transformer in forecast_transformer is rejected, and the message points you at lifting it with PerVintageActualTransformer.

Related¶

• How to Work with Forecast Vintages
• How to Compose Feature Pipelines
• How to Use Exogenous Features