SciPy with scikit-learn pipeline

Introduction

We use SciPy with scikit-learn pipelines to clean and prepare data step-by-step, then train a model easily. It helps keep everything organized and repeatable.

When you want to apply multiple data processing steps before training a model.

When you need to combine SciPy functions for data transformation with scikit-learn models.

When you want to avoid repeating code and make your workflow clear and simple.

When you want to test different data cleaning and modeling steps quickly.

When you want to share your data science process with others in a neat way.

Syntax

SciPy

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
import scipy

pipeline = Pipeline([
    ('scipy_transform', FunctionTransformer(your_scipy_function)),
    ('model', LogisticRegression())
])

pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)

Pipeline lets you chain steps: first data changes, then model training.

FunctionTransformer wraps SciPy functions so they work inside the pipeline.

Examples

This example applies a log transform using NumPy before training a logistic regression model.

SciPy

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
import numpy as np
import scipy.stats

def log_transform(X):
    return np.log1p(X)

pipeline = Pipeline([
    ('log', FunctionTransformer(log_transform)),
    ('model', LogisticRegression())
])

This example smooths data using a SciPy Gaussian filter before modeling.

SciPy

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
import scipy.ndimage

def smooth_data(X):
    return scipy.ndimage.gaussian_filter(X, sigma=1)

pipeline = Pipeline([
    ('smooth', FunctionTransformer(smooth_data)),
    ('model', LogisticRegression())
])

Sample Program

This program loads iris data, normalizes features using SciPy's z-score inside a pipeline, trains logistic regression, and prints predictions.

SciPy

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import numpy as np
import scipy.stats

def zscore_transform(X):
    return scipy.stats.zscore(X, axis=0)

# Load data
iris = load_iris()
X, y = iris.data, iris.target

# Use only two classes for logistic regression
X = X[y != 2]
y = y[y != 2]

# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)

# Create pipeline with SciPy z-score normalization and logistic regression
pipeline = Pipeline([
    ('zscore', FunctionTransformer(zscore_transform)),
    ('model', LogisticRegression())
])

# Train model
pipeline.fit(X_train, y_train)

# Predict
predictions = pipeline.predict(X_test)

# Print predictions
print(predictions)

Important Notes

FunctionTransformer expects functions that take and return arrays.

Make sure SciPy functions do not change the shape unexpectedly.

Pipelines help avoid data leakage by applying the same transformations to train and test data.

Summary

SciPy functions can be used inside scikit-learn pipelines with FunctionTransformer.

Pipelines keep data processing and modeling steps organized and repeatable.

This approach helps beginners build clean, understandable data science workflows.

Practice

1. What is the main benefit of using a Pipeline in scikit-learn when combined with SciPy functions?

easy

A. It organizes data processing and modeling steps into one repeatable workflow.

B. It automatically improves model accuracy without tuning.

C. It replaces the need for any data cleaning.

D. It allows running code without importing any libraries.

Solution

1. Step 1: Understand the purpose of Pipeline

   A Pipeline in scikit-learn is designed to chain multiple steps like data transformation and modeling into a single object.

2. Step 2: Recognize the benefit of combining SciPy functions

   Using SciPy functions inside a Pipeline via FunctionTransformer keeps the workflow organized and repeatable.

3. Final Answer:

   It organizes data processing and modeling steps into one repeatable workflow. -> Option A

4. Quick Check:

   Pipeline = Organized workflow [OK]

Hint: Pipelines bundle steps for easy reuse and clarity [OK]

Common Mistakes:

• Thinking Pipeline improves accuracy automatically
• Assuming Pipeline removes need for data cleaning
• Believing Pipeline runs without imports

2. Which of the following is the correct way to include a SciPy function scipy_func inside a scikit-learn pipeline using FunctionTransformer?

easy

A. Pipeline([('transform', scipy_func), ('model', LogisticRegression())])

B. Pipeline([('transform', FunctionTransformer(scipy_func)), ('model', LogisticRegression())])

C. Pipeline([('transform', FunctionTransformer()), ('model', LogisticRegression())])

D. Pipeline([('transform', FunctionTransformer(scipy_func())), ('model', LogisticRegression())])

Solution

1. Step 1: Understand FunctionTransformer usage

   FunctionTransformer takes a function as an argument without calling it (no parentheses).

2. Step 2: Identify correct pipeline syntax

   The pipeline step should be ('transform', FunctionTransformer(scipy_func)) to wrap the function properly.

3. Final Answer:

   Pipeline([('transform', FunctionTransformer(scipy_func)), ('model', LogisticRegression())]) -> Option B

4. Quick Check:

   FunctionTransformer(function) no parentheses [OK]

Hint: Pass function name, not call, to FunctionTransformer [OK]

Common Mistakes:

• Calling the function inside FunctionTransformer
• Passing function directly without FunctionTransformer
• Using FunctionTransformer without function argument

3. What will be the output of the following code snippet?

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
import numpy as np

def add_one(X):
    return X + 1

pipe = Pipeline([
    ('add', FunctionTransformer(add_one)),
])

X = np.array([1, 2, 3])
result = pipe.transform(X)
print(result)

medium

A. Error: Pipeline has no transform method

B. [1 2 3]

C. [0 1 2]

D. [2 3 4]

Solution

1. Step 1: Understand FunctionTransformer behavior

   FunctionTransformer applies the function add_one to input data during transform.

2. Step 2: Apply the function to input array

   Input array [1, 2, 3] plus 1 becomes [2, 3, 4].

3. Final Answer:

   [2 3 4] -> Option D

4. Quick Check:

   Input + 1 = Output [OK]

Hint: FunctionTransformer applies function on transform call [OK]

Common Mistakes:

• Assuming pipeline has no transform method
• Forgetting function adds 1
• Confusing fit and transform methods

4. Identify the error in this pipeline code using a SciPy function inside FunctionTransformer:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
import numpy as np

def multiply_by_two(X):
    return X * 2

pipe = Pipeline([
    ('mult', FunctionTransformer(multiply_by_two())),
])

X = np.array([1, 2, 3])
result = pipe.transform(X)
print(result)

medium

A. Using transform instead of fit_transform

B. Missing import for numpy

C. Calling multiply_by_two() instead of passing the function

D. Pipeline missing a model step

Solution

1. Step 1: Check FunctionTransformer argument

   FunctionTransformer expects a function, not the result of a function call.

2. Step 2: Identify the error in code

   Code calls multiply_by_two() immediately, which causes an error because it returns an array, not a function.

3. Final Answer:

   Calling multiply_by_two() instead of passing the function -> Option C

4. Quick Check:

   Pass function, don't call it [OK]

Hint: Pass function name, avoid parentheses in FunctionTransformer [OK]

Common Mistakes:

• Calling function instead of passing it
• Assuming pipeline needs a model step
• Confusing transform with fit_transform

5. You want to build a pipeline that first applies a SciPy function to normalize data, then fits a logistic regression model. Which of the following code snippets correctly implements this?

hard

A. from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
import scipy.stats as stats

pipe = Pipeline([
('normalize', FunctionTransformer(stats.zscore)),
('model', LogisticRegression())
])

B. from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
import scipy.stats as stats

pipe = Pipeline([
('normalize', stats.zscore()),
('model', LogisticRegression())
])

C. from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
import scipy.stats as stats

pipe = Pipeline([
('normalize', FunctionTransformer(stats.zscore())),
('model', LogisticRegression())
])

D. from sklearn.pipeline import Pipeline
from sklearn.preprocessing import FunctionTransformer
from sklearn.linear_model import LogisticRegression
import scipy.stats as stats

pipe = Pipeline([
('normalize', FunctionTransformer(stats.zscore)),
('model', LogisticRegression)
])

Solution

1. Step 1: Use FunctionTransformer correctly with SciPy function

   Pass the function stats.zscore without calling it, wrapped by FunctionTransformer.

2. Step 2: Ensure LogisticRegression is instantiated

   Use LogisticRegression() with parentheses to create the model instance.

3. Final Answer:

   Code snippet with FunctionTransformer(stats.zscore) and LogisticRegression() -> Option A

4. Quick Check:

   FunctionTransformer(function) + model instance [OK]

Hint: Wrap function, instantiate model with parentheses [OK]

Common Mistakes:

• Calling SciPy function instead of passing it
• Not instantiating LogisticRegression
• Passing function call to FunctionTransformer