The Toolkit and the Pipeline

Topic — Four pages of concepts. This one is the code. It covers the five libraries that do the actual work, and the seven-step pipeline that every project in this section — and every project after it — follows in the same order.

Learn the pipeline once and the rest of machine learning becomes "which algorithm goes in step 3".

---

Why Python

Python is a popular and powerful general-purpose programming language that emerged as the preferred language among data scientists.

You can write a machine learning algorithm yourself in Python, and it works very well. But there are a great many modules and libraries already implemented that make the work much easier — so in practice you almost never do.

That's the honest reason Python won: not the language itself, but the libraries built on top of it.

---

The five libraries

Library	What it gives you	You use it for
NumPy	A math library for n-dimensional arrays, computing efficiently and effectively	Arrays and matrices — the numbers underneath everything
SciPy	Numerical algorithms and tools for domains like signal processing, optimisation and statistics	The maths algorithms models are built from
Pandas	Powerful data structures like DataFrames for handling structured data (tables)	Loading, cleaning, manipulating and analysing data
Matplotlib	Creating interactive, animated visualisations, 2-D and 3-D plots	Seeing your data and your results
scikit-learn	Simple and efficient tools for classical machine learning	Building and evaluating standard statistical models
PyTorch / TensorFlow	Deep Learning Frameworks with automatic differentiation and GPU acceleration	Designing and training deep neural networks

How they stack

These aren't five alternatives — they're layers, and each depends on the ones below it:

   ┌──────────────────────────────────────────────┐
   │  PyTorch / TensorFlow     Deep Learning      │
   ├──────────────────────────────────────────────┤
   │  scikit-learn             Classical ML       │
   ├───────────────────────┬──────────────────────┤
   │  SciPy                │  Pandas              │
   │  numerical algorithms │  DataFrames, tables  │
   ├───────────────────────┴──────────────────────┤
   │  NumPy                 n-dimensional arrays  │
   └──────────────────────────────────────────────┘
              Matplotlib plots any of it

NumPy sits at the bottom of everything. A pandas DataFrame holds NumPy arrays; scikit-learn converts your DataFrame to a NumPy array on the way in and hands NumPy arrays back out. This is why shape errors so often surface as NumPy messages even when you never imported NumPy yourself.

NumPy

A math library to work with n-dimensional arrays, enabling computation efficiently and effectively.

"Efficiently" is not marketing. NumPy stores numbers in one contiguous block of memory of a single type and runs operations in compiled code, so an operation over a million values is a single call rather than a million interpreted loop iterations.

SciPy

Numerical algorithms and tools for various domains — signal processing, optimisation, and statistics.

You will rarely call SciPy directly early on. It matters because it's what scikit-learn calls: when a model is fitted, the optimisation routine finding the best parameters usually lives here.

Pandas

For data manipulation and analysis, providing powerful data structures like DataFrames for handling structured data — tables.

A DataFrame is the table you actually think in: named columns, mixed types, an index. It's where steps 1 and 2 of the pipeline happen.

Matplotlib

Creating interactive, animated visualisations, and 2-D and 3-D plots. The plotting module is Pyplot, conventionally imported as plt.

Its role in the pipeline is diagnostic. Summary numbers hide things that a single scatter plot makes obvious.

scikit-learn

Simple and efficient tools for data analysis, including classification, regression, clustering and more. Specifically:

• Free software machine learning library
• Classification, regression and clustering algorithms
• Works with NumPy and SciPy
• Great documentation
• Easy to implement

Most of the tasks that need to be done in a machine learning pipeline are already implemented in scikit-learn.

That sentence is the reason this page exists. The seven steps below are not seven programming problems — they are seven library calls.

---

The contract that makes it work

Every scikit-learn object follows the same tiny interface. Learn these four method names and you can use a component you've never seen before.

Method	Meaning	Who has it
.fit(X, y)	Learn from data	Everything
.predict(X)	Produce answers for new data	Models
.transform(X)	Change the data	Preprocessors
.score(X, y)	Evaluate against known answers	Models

Two kinds of object, distinguished by which they have:

• Transformers — fit + transform. A scaler, an encoder, PCA.
• Estimators — fit + predict. A classifier, a regressor.

fit_transform is just fit then transform in one call.

danger

fit on training data only — never on the test set

fit is where the object learns something: a scaler learns the mean and standard deviation of each column. If you fit a scaler on the whole dataset before splitting, the training data has been scaled using information from the test set — and your test score is no longer an honest estimate of performance on unseen data.

The rule, without exception:

scaler.fit(X_train)             # learn from train
X_train = scaler.transform(X_train)
X_test  = scaler.transform(X_test)   # apply to test — never fit on it

This mistake is called data leakage, it inflates your score, and it is invisible — nothing errors. The Pipeline object in the demo below exists largely to make it impossible.

🧠 Interactive Checkpoint: Preventing Data Leakage

Scenario: You want to train a model predicting customer lifetime value. You have a preprocessing step that centers the feature values (subtracts the mean). What is the correct sequence of calls to avoid data leakage?

---

The seven-step pipeline & MLOps Lifecycle

The classical seven-step machine learning pipeline represents a single iteration. Modern engineering frames this inside a continuous MLOps Model Lifecycle:

   1. Data preprocessing
            ↓
   2. Train / test split
            ↓
   3. Algorithm setup
            ↓
   4. Model fitting          ── train with the training set
            ↓
   5. Prediction             ── test with the test set
            ↓
   6. Evaluation             ── measure accuracy, show the result
            ↓
   7. Model export           ── save the model
            ↓
   ===============================================================
   [MLOps Lifecycle Continuous Stage]
            ↓
   8. Model Registry         ── versioning and archiving artifacts
            ↓
   9. Canary Deployment      ── shadow or canary deployment to routing
            ↓
   10. Drift Monitoring      ── monitoring real-world feature & prior drift
            ↓
   11. Retrigger Training    ── automatic model updates on performance drops

Step	What happens	Typical call
1. Preprocess	Load the data; handle missing values, encode categories, scale features; split into X and y	pd.read_csv, SimpleImputer, StandardScaler
2. Split	Hold back part of the data, untouched, for honest testing	train_test_split
3. Algorithm setup	Create the model object and choose its settings. Nothing is learned yet	LogisticRegression()
4. Fit	Train on the training set — this is where learning happens	model.fit(X_train, y_train)
5. Predict	Ask for answers on the test set	model.predict(X_test)
6. Evaluate	Compare predictions against the known answers	accuracy_score, classification_report
7. Export	Save the fitted model so it can be reused without retraining	joblib.dump

Three things about this sequence are worth stating plainly.

Step 2 comes before step 4 for a reason. The test set exists to answer one question: how will this do on data it has never seen? The moment the model learns anything from the test set, that question becomes unanswerable.

Step 3 is the only step that changes when you change algorithm. Swap LogisticRegression() for RandomForestClassifier() and steps 1, 2, 4, 5, 6 and 7 are untouched. That's the payoff of the shared contract, and the demo below shows it.

Step 7 must save the preprocessing too. A model expecting scaled input is useless without the scaler that produced that scaling. Save them together, or save a Pipeline that contains both.

---

Common Mistakes

Here are the most common conceptual pitfalls when setting up your machine learning pipelines, compared with the correct engineering principles.

🚨 Mistake 1: Pre-split Scaling

• The Pitfall: Fitting your scaling or encoding estimators on the full dataset before performing your partition.
• ❌ Wrong Thinking: scaler.fit(X)
• ✅ The Right Principle: Fit strictly on the training partition: scaler.fit(X_train). Fitting before splitting introduces data leakage, exposing testing statistics to the training pipeline.

🚨 Mistake 2: Fitting on Test Data

• The Pitfall: Overwriting your scaler coefficients by fitting again on testing rows.
• ❌ Wrong Thinking: scaler.fit(X_test) or scaler.fit_transform(X_test)
• ✅ The Right Principle: Apply training coefficients strictly: scaler.transform(X_test). The test set must remain completely unseen, mimicking future prediction requests.

🚨 Mistake 3: Monolithic Model Exports

• The Pitfall: Exporting and deploying a serialized model object without saving its associated preprocessing estimators.
• ❌ Wrong Thinking: joblib.dump(model, "model.joblib")
• ✅ The Right Principle: Export a combined Pipeline object containing both transformers and estimators, or serialize them as a dictionary. A model expecting scaled features will fail silently on raw deployment values.

---

Summary

📦 The Data Stack Layer

• NumPy: N-dimensional arrays. Continuous memory structures storing numbers efficiently.
• Pandas: Tabular DataFrame manipulations. Coordinates preprocessing tasks.
• Matplotlib: Visualizes data distribution and diagnostic plots.

🤖 Model & Pipeline layer

• scikit-learn: Tightly structured APIs for statistical ML with consistent interfaces.
• PyTorch / TF: Deep learning framework with neural layer weights and auto-gradients.
• The Pipeline: Structured chain linking steps 1-7, locking out leakage vectors.

info

📌 Key Takeaways: Toolkit & Pipeline

• ⚡ NumPy Underpins All: Dataframes and scikit-learn models are simply high-level layers on top of contiguous NumPy array vectors. Shape errors are usually low-level NumPy array issues.
• 🔌 Consistent API Contract: Every scikit-learn object operates on four main methods: .fit(), .predict(), .transform(), and .score().
• ⚖️ Scalers are Estimators too: A StandardScaler learns mean and deviation vectors on .fit(). Fitting it on testing partitions or prior to splitting constitutes structural Data Leakage.
• 📐 Export Preprocessing: Always save your scaler parameters alongside your model weights using a unified Pipeline to prevent dimensional format mismatches in live APIs.

See also: Types of Learning for what goes in step 3 · Applications and Major Techniques for choosing the technique before the algorithm · What is Machine Learning? for why .fit replaces hand-written rules

---

Run It Yourself

tip

Lab Exercise: The End-to-End Machine Learning Pipeline

Run the complete classical seven-step machine learning pipeline sequentially on the Iris flower dataset. Condense the pipeline into a single scikit-learn object and run comparative swaps of classical classifiers in a single line.

How to run the lab:

1. Click the "Open In Colab" badge above to launch the interactive notebook.
2. Run each cell sequentially (Shift + Enter).
3. Experiment with inducing data leakage, skipping scaling, and optimizing decision tree depths.

Practice Questions

Test your understanding by working each problem out first, then click the card to reveal the detailed solution. Questions are tagged by type: [THEORY], [PROG], [OUT], or [ANALYZE].

The libraries

❓ L1. [THEORY] Name the five libraries and state, in one line each, what they provide.

• NumPy: High-performance n-dimensional arrays for foundational linear algebra operations.
• SciPy: Scientific algorithms for advanced statistics, optimization, and signal processing.
• Pandas: Efficient, labeled two-dimensional DataFrame containers for structured tabular manipulation.
• Matplotlib: Plotting engine and visualizations (pyplot) for diagnostic graphs.
• scikit-learn: Comprehensive toolkit for classical supervised/unsupervised machine learning algorithms.

❓ L2. [THEORY] Which library sits at the bottom of the stack, and why do shape errors often mention it even when you never imported it?

• Bottom Library: NumPy.
• Why shape errors occur: High-level libraries (Pandas and scikit-learn) store and pass numerical tables as contiguous NumPy array instances under the hood. Consequently, dimensional mismatch errors during training bubble up directly from low-level NumPy compiler layers.

❓ L3. [THEORY] Give five properties of scikit-learn.

1. Open Source: Free, community-driven statistical machine learning library.
2. API Consistency: Shares a strict object contract: .fit(), .predict(), .transform(), .score().
3. Comprehensive Toolkit: Features prebuilt algorithms for regression, classification, clustering, dimensionality reduction, and evaluation.
4. Ecosystem Integration: Works seamlessly with Pandas DataFrames and NumPy arrays.
5. Exemplary Documentation: Packed with complete, runnable code examples and rigorous theoretical derivations.

❓ L4. [THEORY] You will rarely call SciPy directly. Why does it still matter?

It serves as scikit-learn's underlying engine. When fitting weights (e.g. OLS regression or Logistic solvers), scikit-learn calls SciPy's optimized numerical solver libraries to perform the matrix calculus efficiently in compiled C/Fortran blocks.

❓ L5. [ANALYZE] Python is a general-purpose language, not a mathematical one. Explain why it became the preferred language anyway.

Python didn't win on syntax; it won because of its robust library ecosystem. By wrapping fast, low-level C libraries (NumPy/SciPy/Pandas) with highly readable high-level Python APIs, it allowed data scientists to prototype mathematical operations easily without sacrificing computation speed.

The scikit-learn contract

❓ S1. [THEORY] Name the four core method names and say what each does.

• .fit(X, y): Fits model weights/coefficients by learning from a training matrix.
• .predict(X): Computes discrete categorical labels or continuous values for raw inputs.
• .transform(X): Applies learned transformations (e.g., standardizing offsets, categorical encoding) to clean raw tables.
• .score(X, y): Generates automated evaluation metrics (e.g. classification accuracy or regression $R^2$) on target labels.

❓ S2. [THEORY] Distinguish a transformer from an estimator by which methods each has. Give an example of both.

• Transformer: Has fit + transform (e.g. StandardScaler, OneHotEncoder). They manipulate the shape of the data itself.
• Estimator (Model): Has fit + predict (e.g. LogisticRegression, RandomForestClassifier). They predict outputs from input data.

❓ S3. [THEORY] What does fit_transform do that transform alone does not?

fit_transform learns characteristics (such as column mean and variance) and modifies the input dataset simultaneously in a single, computationally-optimized call. transform strictly applies pre-learned characteristics without rewriting coefficients.

❓ S4. [ANALYZE] Explain precisely what a StandardScaler learns during fit, and why fitting it on the whole dataset before splitting is an error. Would anything raise an exception?

• What it learns: The mean ($\mu$) and standard deviation ($\sigma$) of each column.
• Why it's an error: Fitting before splitting causes data leakage. The scaler incorporates boundary statistics from the testing set into training features, inflating testing scores artificially.
• Exceptions: No exception is raised. Data leakage fails silently and invisibly.

❓ S5. [ANALYZE] Name the one benefit of Pipeline that matters most, and explain the mechanism.

• Main benefit: Bypasses Data Leakage structurally.
• Mechanism: Tying preprocessors (StandardScaler) and classifiers into a single object restricts fit routines strictly to the training folds. The test data is only transformed during prediction calls, preventing downstream exposure of test boundaries.

The seven steps

❓ P1. [THEORY] List the seven steps of the pipeline in order.

1. Preprocess: Load, clean, and format variables.
2. Split: Partition into disjoint training and testing pools.
3. Algorithm Setup: Configure a blank model object (untrained).
4. Fit: Train the model using the training partition labels.
5. Predict: Generate answers for test features.
6. Evaluate: Measure score performance metrics against test ground truth.
7. Export: Serialize weights and transformers to disk for deployment.

❓ P2. [THEORY] Which step performs the learning? What has been learned after step 3?

• Step that learns: Step 4 (.fit()).
• Learned after step 3: Absolutely nothing. Step 3 merely allocates memory and configures structural hyperparameters, leaving all model coefficients blank.

❓ P3. [THEORY] Which single step changes when you switch from logistic regression to a random forest? What does this tell you about the design of the library?

• Changed Step: Step 3 (instantiating the model object).
• Library Design: Highlights the brilliance of scikit-learn's consistent contract design. Because all estimators share identical .fit() and .predict() structures, algorithms are completely interchangeable with zero code impact across downstream pipelines.

❓ P4. [ANALYZE] Why must step 2 come before step 4? State what becomes impossible if it doesn't.

Step 2 must precede training to isolate the test set completely. If split after step 4, the model would be trained on test bounds, making it mathematically impossible to calculate an unbiased, honest evaluation score on unseen future data.

❓ P5. [ANALYZE] A colleague saves only the fitted model in step 7, not the scaler. Describe what happens when the model is loaded and used, and why nothing errors.

• What happens: Raw, unscaled features are fed directly to the model. Since the model expects normalized standard deviations, the numerical prediction checks degrade significantly, producing nonsense outputs.
• Why nothing errors: Both scaled and unscaled inputs are 2-D float matrices of identical shape. The model runs standard matrix multiplication calculations cleanly with no dimension exception triggers.

Reading the output

❓ O1. [OUT] Step 4 reported learned 12 coefficients + 3 intercepts. The data has 4 features and 3 classes. Explain both numbers.

• 12 Coefficients: Multiclass logistic regression creates distinct linear models per target class: $4 \text{ features} \times 3 \text{ classes} = 12 \text{ coefficients}$.
• 3 Intercepts: Each of the 3 class boundary lines gets its own baseline bias offset intercept.

❓ O2. [OUT] After scaling, the training mean printed as 1.39e-17 rather than 0. Explain, and say what this implies about testing floats for equality.

• Explanation: Repetitive floating-point binary divisions induce negligible trailing remainders ($1.39 \times 10^{-17}$ is effectively zero).
• Implication: Never test floating-point numbers using exact equality (==). Always evaluate them using numerical tolerances (e.g., np.allclose()).

❓ O3. [OUT] Step 7 printed identical to before: True. What exactly was compared, and why does it matter?

• What was compared: Predictions from the original pipeline instance on memory vs predictions from the serialized .joblib pipeline loaded back from disk.
• Why it matters: Confirms 100% serialization integrity. It ensures our model weights and preprocessors reload flawlessly with zero prediction drift.

❓ O4. [OUT] The explicit seven steps and the three-line Pipeline both produced 0.967. What has been gained by using the Pipeline, given the accuracy is unchanged?

While accuracy remains identical on clean data, using Pipeline eliminates human error. It guarantees that test features cannot bypass the standardization scaling transform and strictly blocks data leakage.

❓ O5. [ANALYZE] Three algorithms scored 0.967 and a depth-1 decision tree scored 0.667. Explain the tie and the tree structure.

• Why the first three tie: The Iris dataset features simple, highly linear class boundaries. On straightforward datasets, most competent algorithms easily converge on identical bounds, rendering complex configurations unnecessary.
• Explain the 0.667: A depth-1 decision tree splits along exactly one feature boundary, partitioning the dataset into two sections. In a balanced, three-class flower set ($50/50/50$), a single split isolates Setosa ($50$) completely and groups Versicolor and Virginica ($100$) together, recovering exactly $\frac{2}{3} \approx 66.7\%$ of target assignments.
• Fourth row indicator: Shows our testing framework operates cleanly, discriminating and highlighting inferior model structures accurately.
• Effort Allocation: Focus your engineering effort on data cleansing, feature quality, and robust splitting frameworks. A fancy algorithm will not save a model built on corrupt, leaking, or unscaled data matrices.

Applying it

❓ A1. [PROG] Write the seven steps for load_wine instead of load_iris, printing test accuracy.

import joblib
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score
from sklearn.pipeline import Pipeline

# 1. Preprocess
wine = load_wine()
X, y = wine.data, wine.target

# 2. Split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

# 3. Setup & 4. Fit
pipe = Pipeline([
    ("scale", StandardScaler()),
    ("clf", LogisticRegression(max_iter=5000))
])
pipe.fit(X_train, y_train)

# 5. Predict & 6. Evaluate
y_pred = pipe.predict(X_test)
print(f"Wine Test Accuracy: {accuracy_score(y_test, y_pred):.3f}")

# 7. Export
joblib.dump(pipe, "wine_pipe.joblib")

❓ A2. [PROG] Build a Pipeline of StandardScaler and KNeighborsClassifier, fit it, and print both the training and test accuracy. Explain any gap.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42, stratify=iris.target)

pipe = Pipeline([
    ("scale", StandardScaler()),
    ("clf", KNeighborsClassifier(n_neighbors=3))
])
pipe.fit(X_train, y_train)

print(f"Training Accuracy: {pipe.score(X_train, y_train):.3f}")
print(f"Testing Accuracy: {pipe.score(X_test, y_test):.3f}")

• Explaining the gap: Models almost always score slightly higher on training folds because they fit decision margins to those coordinates directly. If a massive gap occurs (e.g. 100% train vs 60% test), it indicates overfitting—the model memorized training points instead of generalizable boundaries.

❓ A3. [PROG] Save a fitted Pipeline with joblib.dump, reload it in a fresh variable, and assert the predictions are identical.

import joblib
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=0)

pipe = make_pipeline(StandardScaler(), LogisticRegression())
pipe.fit(X_train, y_train)

pred1 = pipe.predict(X_test)
joblib.dump(pipe, "temp.joblib")

reloaded = joblib.load("temp.joblib")
pred2 = reloaded.predict(X_test)

assert np.array_equal(pred1, pred2), "Mismatch detected!"
print("Assertion passed! Predictions are perfectly identical.")

❓ A4. [PROG] Deliberately introduce leakage: fit the scaler on all of X before splitting, and compare the resulting test accuracy with the correct version. Report both.

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

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

# Leaking Scaler (Fit on All)
leaked_scaler = StandardScaler().fit(X)
X_l = leaked_scaler.transform(X)
X_tr_l, X_te_l, y_tr_l, y_te_l = train_test_split(X_l, y, test_size=0.3, random_state=42)
leaked_model = LogisticRegression().fit(X_tr_l, y_tr_l)
leaked_score = leaked_model.score(X_te_l, y_te_l)

# Correct Scaler (Fit strictly on Train)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, random_state=42)
scaler = StandardScaler().fit(X_tr)
X_tr_s = scaler.transform(X_tr)
X_te_s = scaler.transform(X_te)
model = LogisticRegression().fit(X_tr_s, y_tr)
correct_score = model.score(X_te_s, y_te)

print(f"Leaked Scaler Accuracy:  {leaked_score:.4f}")
print(f"Correct Scaler Accuracy: {correct_score:.4f}")

❓ A5. [ANALYZE] You are handed a dataset and asked for a model by tomorrow. Write the seven steps as a checklist with the specific decision you must make at each one.

1. Step 1 Checklist (Preprocess): Check columns. Locate missing parameters (How to impute?). Locate strings (Encode nominal vs ordinal?). Check feature ranges (Symmetric scaling required?).
2. Step 2 Checklist (Split): Define split ratio (80/20 standard?). Apply stratification (stratify=y enabled?) to preserve balanced class distributions.
3. Step 3 Checklist (Setup Algorithm): Pick baseline model (Simple classical baseline first like Logistic Regression?). Define maximum iterations to avoid compilation divergence.
4. Step 4 Checklist (Fit): Call model fit strictly on scaled training matrices (X_train_scaled, y_train).
5. Step 5 Checklist (Predict): Generate predictions strictly on scaled test variables (X_test_scaled).
6. Step 6 Checklist (Evaluate): Generate model evaluation metrics. Compile classification report, confusion matrix, or regression $R^2$/RMSE metrics.
7. Step 7 Checklist (Export): Bundle and serialize the scaler and model structures into a unified Pipeline using joblib.dump().

Quick self-check

🧠 1. Name the five libraries and one use for each.

• NumPy: Fast multi-dimensional arrays.
• SciPy: Advanced scientific mathematical solvers.
• Pandas: Efficient, labeled two-dimensional tabular manipulations.
• Matplotlib: Compiles visual data graphs.
• scikit-learn: Core classical statistical models.

🧠 2. Which library is underneath all the others?

NumPy is the foundation library for all statistical packages.

🧠 3. What is a DataFrame, and which library provides it?

• DataFrame: Labeled, two-dimensional tabular data structure with column indices.
• Library: Provided strictly by Pandas.

🧠 4. Which module of Matplotlib do you plot with?

matplotlib.pyplot (conventionally imported as plt).

🧠 5. Name the four scikit-learn method names.

1. .fit()
2. .predict()
3. .transform()
4. .score()

🧠 6. What is the difference between a transformer and an estimator?

• Transformer: Formats and standardizes features (fit + transform).
• Estimator: Predicts class labels or values (fit + predict).

🧠 7. On which data may you call fit?

Strictly on training data (X_train, y_train).

🧠 8. What is data leakage, and does it raise an error?

• Data Leakage: Exposing testing statistics to training phases.
• Does it error: No, it fails silently and invisibly, inflating validation scores misleadingly.

🧠 9. List the seven pipeline steps in order.

1. Preprocess $\to$ 2. Split $\to$ 3. Setup Algorithm $\to$ 4. Fit $\to$ 5. Predict $\to$ 6. Evaluate $\to$ 7. Export.

🧠 10. Is anything trained after step 3?

No. Step 3 simply allocates configurations. Training strictly initiates on step 4 (.fit()).

🧠 11. Which step changes when you swap the algorithm?

Only Step 3 (Setup Algorithm) is modified.

🧠 12. What must be saved in step 7 besides the model?

All associated preprocessing transformers (such as standard scalers and categorical encoders), ideally packed together inside a combined Pipeline object.