Concepts / Inspecting Pipeline Steps

Inspecting Pipeline Steps

make_pipeline changes only how the step names are supplied. It does not change what the pipeline does with the data.

  • Programming

Why Step Names Matter

A pipeline is a chain of steps that data passes through in a fixed order. Each step is an estimator, such as a scaler that rescales features or a classifier that makes predictions. When something goes wrong in a long pipeline, you need a way to point at one particular step and ask what it is doing. Each step therefore needs a label that lets you find it again.

This article follows one question through the lesson: when you do not name the steps yourself, where do the names come from, and do those names still let you tell the steps apart when something goes wrong? The code trace attached to this lesson builds two pipelines from the same estimators and prints the steps attribute of each. As you read it, watch for two things. First, whether the two pipelines behave the same way. Second, how the steps in the shorter pipeline are labeled. The sections below explain the mechanism behind what you observe.

Two Ways to Build the Same Pipeline

The standard way to build a pipeline is to write out a name for every step. Each step becomes a pair of a string and an estimator object, and the pairs are collected into a list that is passed to Pipeline. The long form below is the standard syntax. It works well, but it can be cumbersome, especially when the names you invent carry no real information.

python
Output (expected)
[('minmaxscaler', MinMaxScaler()), ('svc', SVC())]
[('minmaxscaler', MinMaxScaler()), ('svc', SVC())]
Notes on the code
  • pipe_long names each step explicitly with a (name, estimator) pair
  • pipe_short passes only the estimators and lets make_pipeline choose the names
  • Both steps attributes print identically in this case

The shorter form makes the two calls equivalent in behavior. The pipeline built with explicit names and the pipeline built with make_pipeline do exactly the same thing. The only difference is that the steps of the shorter one were named automatically, so you do not have to invent names. In this example the automatic names happen to match the names you would have typed by hand.

Estimators onlyMinMaxScaler(), SVC()Pairs with names('minmaxscaler',MinMaxScaler())Same pipelinebehavioridentical stepsAutomatic namesminmaxscaler, svcNames you choseminmaxscaler, svcgeneratesusesyieldsyields
What each construction call takes as input and what it produces for the same estimators
Key point

make_pipeline changes only how the step names are supplied. It does not change what the pipeline does with the data.

Where Automatic Names Come From

make_pipeline builds each name from the class of its estimator. The rule is simple: the name is the lowercase version of the class name. MinMaxScaler becomes minmaxscaler, and SVC becomes svc. Once you know this rule, you can predict the name of any step before you print the pipeline.

Code walkthrough
pipe_short = make_pipeline(MinMaxScaler(), SVC())
names = [name for name, estimator in pipe_short.steps]
print(names)
  1. 1
    Line 1 creates the pipeline. The estimators are passed in order and no names are written.
  2. 2
    Line 2 reads the steps attribute, which holds every (name, estimator) pair in pipeline order, and collects the names.
  3. 3
    Line 3 prints the names. minmaxscaler comes from MinMaxScaler and svc comes from SVC, both lowercased.
  • make_pipeline receives the two estimator objects with no names attached
  • Each element of steps is a (name, estimator) pair
  • The list comprehension keeps only the name half of each pair
Output
['minmaxscaler', 'svc']

What do you think happens?

If you call make_pipeline(MinMaxScaler(), SVC()), what names will the two steps get before you print anything?

  • minmaxscaler and svc

  • step_0 and step_1

  • MinMaxScaler and SVC with their capital letters kept

Reveal answer
Answer:

minmaxscaler and svc

Each automatic name is the lowercase version of the estimator's class name, so MinMaxScaler becomes minmaxscaler and SVC becomes svc.

Repeated Classes and Numbered Names

The lowercase rule has a weakness. If the same class appears twice in one pipeline, two steps would receive the same name, and a pipeline cannot reliably find a step by a name that is shared. make_pipeline avoids this by appending a number to each repeated name. The number follows the class name, and the position of the repeated class in the pipeline determines which number it receives.

Code walkthrough
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

pipe = make_pipeline(StandardScaler(), PCA(), StandardScaler())
print([name for name, _ in pipe.steps])
  1. 1
    Line 1 and line 2 import the two estimator classes used in this pipeline.
  2. 2
    Line 3 builds a pipeline with a StandardScaler, then a PCA step, then a second StandardScaler.
  3. 3
    Line 4 prints only the names. The first scaler becomes standardscaler-1, the PCA step becomes pca, and the second scaler becomes standardscaler-2.
  • StandardScaler appears twice, so both copies receive a number
  • PCA appears once, so it keeps the plain lowercase name
  • The numbers follow pipeline order: the first scaler is 1 and the second is 2
Output
['standardscaler-1', 'pca', 'standardscaler-2']
standardscaler-1StandardScalerpcaPCAstandardscaler-2StandardScalerthenthen
When StandardScaler appears twice, each copy gets its own numbered name, and the name depends on where that copy sits in the pipeline

Notice what the numbers do not tell you. standardscaler-2 says that this is the second copy of a scaler, but it says nothing about why the scaler is there. That gap is the reason explicit names can be the better choice when several steps share a class. A pipeline with a scaler before and after a PCA step is correct, but a reader has to work out the purpose of each scaler from its position alone.

Reading the steps Attribute

The steps attribute is the place to check which name belongs to which step. It holds a list of (name, estimator) pairs, so you can print it directly to see every name next to its estimator. When you are debugging, you can also search this list for the name you want, which is faster than guessing the position of a step.

minmaxscalerMinMaxScaler()svcSVC()
Each name key in the steps list maps to the estimator stored beside it, so a debugger can search by name instead of by position
python
Output (expected)
SVC()
minmaxscaler
Notes on the code
  • dict(pipe.steps) turns the (name, estimator) pairs into a lookup by name
  • pipe.steps[0][0] reads the name of the first step by position
Worked example

Finding the step that raised an error

A pipeline built with make_pipeline(StandardScaler(), PCA(), StandardScaler()) fails somewhere in the middle. The error message names a step, and you need to find that step's estimator to inspect it.

  1. 1
    Read the names

    Print the names with [name for name, _ in pipe.steps]. The result is standardscaler-1, pca, standardscaler-2.

  2. 2
    Match the name to a class

    The name pca is unique in this pipeline, so it refers to the PCA step with no ambiguity.

  3. 3
    Retrieve the estimator by name

    Run dict(pipe.steps)['pca'] to get the PCA object, then inspect it directly.

  4. 4
    Handle the repeated class

    If the error names standardscaler-2, look up that exact key. Searching for StandardScaler alone would match two steps and would not tell you which one failed.

Result

The steps attribute lets you move from the name in an error message to the exact estimator that produced it, even when the same class appears more than once.

Mistakes When Reading Step Names

  • Common mistake

    Expecting the name to keep the capital letters of the class

    What it looks like

    Assuming MinMaxScaler appears in steps as MinMaxScaler

    Why it fails

    Automatic names are the lowercase versions of the class names

    Do this instead

    Look for minmaxscaler, the lowercase form

  • Common mistake

    Searching for a repeated class name as if it were unique

    What it looks like

    Looking up standardscaler in steps when the pipeline contains two scalers

    Why it fails

    The repeated names carry numbers, so the plain name does not appear as a key

    Do this instead

    Use the numbered name such as standardscaler-1 or standardscaler-2

  • Common mistake

    Assuming make_pipeline changes what the pipeline computes

    Why it fails

    The explicit and automatic forms produce the same pipeline behavior and differ only in naming

    Do this instead

    Compare the steps attribute to confirm the names, and rely on the estimators for behavior

  • Common mistake

    Assuming a numbered name explains the purpose of the step

Choosing Between the Two Forms

Use make_pipeline when the default names are enough and you want less typing. It is a good choice for short pipelines where each class appears only once, because the lowercase names are easy to read and easy to predict.

Use the standard Pipeline construction with explicit names when you want the steps to carry meaningful names. This is especially useful when several steps share a class, since a name you choose can say what each copy is for. Both forms produce the same pipeline behavior, so the decision is about how readable the steps will be when you come back to them later.

Predict and Check Step Names

MEDIUM

Without running code, predict the names that make_pipeline gives to the steps in make_pipeline(SVC(), StandardScaler(), SVC()). Then build the pipeline and print its steps to check your prediction. Explain why the two SVC steps do not share a name.

Hints
  • Start with the lowercase rule: SVC becomes svc and StandardScaler becomes standardscaler
  • Look at which class appears more than once and how repeated names are numbered
  • Numbers follow pipeline order, so the first SVC receives the lower number
MEDIUM

Build a pipeline with make_pipeline(MinMaxScaler(), PCA(), MinMaxScaler(), SVC()). Print the names, then use dict(pipe.steps) to retrieve the estimator named minmaxscaler-2. State which position in the pipeline that estimator occupies.

Hints
  • Print [name for name, _ in pipe.steps] first to see every generated name
  • The second MinMaxScaler sits after the PCA step

Key Takeaways

  • make_pipeline builds a pipeline from the estimators alone and names each step automatically, while the standard Pipeline syntax takes explicit (name, estimator) pairs.
  • Automatic step names are the lowercase versions of the class names, so MinMaxScaler becomes minmaxscaler and SVC becomes svc.
  • When a class appears more than once, make_pipeline appends a number to each repeat in pipeline order, such as standardscaler-1 and standardscaler-2.
  • The steps attribute holds every (name, estimator) pair, so printing it or converting it to a dictionary lets you locate a step by its name while debugging.
  • Both construction forms produce the same pipeline behavior; explicit names are the better choice when a meaningful label matters, especially when a class repeats.

Related Topics

Related concepts

More concepts starting with I