Introduction

Yes, TransformedTargetRegressor can be used with a scikit-learn pipeline, but not as a normal feature transformer step in the middle of the pipeline. It is a regressor wrapper that transforms y, so it belongs either as the final estimator inside a Pipeline or as a wrapper around an entire pipeline.

What TransformedTargetRegressor Actually Does

A normal pipeline step transforms X. TransformedTargetRegressor, by contrast, transforms the target variable y during fit and applies the inverse transform to predictions during predict.

That is why it is conceptually different from steps such as:

• 'StandardScaler'
• 'OneHotEncoder'
• 'PCA'

Those act on feature matrices. TransformedTargetRegressor acts on the regression target.

Pattern 1: Use It as the Final Estimator in a Pipeline

This is the most direct pattern when you want feature preprocessing on X and target transformation on y.

1import numpy as np
2from sklearn.compose import TransformedTargetRegressor
3from sklearn.linear_model import Ridge
4from sklearn.pipeline import Pipeline
5from sklearn.preprocessing import StandardScaler
6
7model = Pipeline([
8    ("scale", StandardScaler()),
9    (
10        "regressor",
11        TransformedTargetRegressor(
12            regressor=Ridge(),
13            func=np.log1p,
14            inverse_func=np.expm1,
15        ),
16    ),
17])

This works because the pipeline transforms X with StandardScaler, then passes the transformed features and original y into TransformedTargetRegressor.

Pattern 2: Wrap the Entire Feature Pipeline

You can also build a feature-processing pipeline first and then wrap that pipeline as the regressor.

1import numpy as np
2from sklearn.compose import TransformedTargetRegressor
3from sklearn.linear_model import Ridge
4from sklearn.pipeline import Pipeline
5from sklearn.preprocessing import StandardScaler
6
7feature_pipeline = Pipeline([
8    ("scale", StandardScaler()),
9    ("ridge", Ridge())
10])
11
12model = TransformedTargetRegressor(
13    regressor=feature_pipeline,
14    func=np.log1p,
15    inverse_func=np.expm1,
16)

This is often the cleaner mental model because the pipeline is simply “the regressor,” and TransformedTargetRegressor wraps it from the outside.

Which Pattern Is Better

Both are valid. The choice is mostly about readability.

Use final-step style when:

• you want one pipeline object that includes everything
• you prefer standard pipeline parameter naming

Use wrapper style when:

• you want to think of the whole feature pipeline as one regressor
• the target transform is conceptually outside the model stack

Functionally, both approaches can integrate with cross-validation and grid search.

Why the Target Transform Helps

Target transformation is often useful when the regression target is skewed or strictly positive. For example, house prices, counts, and certain business metrics are often easier to model after a log transform.

func=np.log1p
inverse_func=np.expm1

This combination is common because it handles zero values safely while still compressing large target ranges.

The point is not to make the target “look nicer.” The point is to make the regression problem easier for the model to learn while still returning predictions on the original scale.

Example with Grid Search

1from sklearn.model_selection import GridSearchCV
2
3param_grid = {
4    "regressor__regressor__alpha": [0.1, 1.0, 10.0]
5}
6
7grid = GridSearchCV(model, param_grid=param_grid, cv=3)

The parameter path depends on which construction pattern you used. That is one of the few practical differences between the two styles.

What You Cannot Do

Do not treat TransformedTargetRegressor like an ordinary intermediate transformer step, because it does not implement the “transform X and pass it onward” role those steps play.

In other words, this would be conceptually wrong as an intermediate feature step:

• scale features
• transform target
• continue transforming features

The target transformation belongs at the estimator boundary, not in the middle of an X-only transformation chain.

Common Pitfalls

• Trying to insert TransformedTargetRegressor in the middle of a pipeline as if it were a normal feature transformer.
• Forgetting that it transforms y, not X, and therefore belongs at the estimator level.
• Using np.log on targets that may contain zero values instead of a safer transform such as np.log1p.
• Getting confused by nested parameter names during grid search when the regressor is wrapped inside multiple layers.
• Applying a target transform without thinking about whether the inverse-transformed predictions still make sense for the business problem.

Summary

• 'TransformedTargetRegressor works with scikit-learn pipelines, but it is an estimator wrapper, not a normal transformer step.'
• You can use it as the final pipeline estimator or wrap an entire feature pipeline with it.
• It is especially useful when the target distribution benefits from log-style transformation.
• Cross-validation and grid search still work, though parameter paths become more nested.
• The main rule is simple: transform y at the regressor boundary, not in the middle of feature preprocessing.