This example demonstrates a complete Machine Learning workflow using Scikit-learn. It covers loading data, preprocessing, training, evaluation, saving the model, and making predictions.

Step 1: Import Required Libraries

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

Each import has a specific purpose.

Import	Purpose
`load_iris`	Loads the Iris dataset
`train_test_split`	Splits data into training and testing sets
`Pipeline`	Chains preprocessing and model together
`StandardScaler`	Standardizes feature values
`LogisticRegression`	Classification algorithm
`joblib`	Saves and loads trained models

Step 2: Load the Dataset

iris = load_iris()

This loads the Iris dataset into memory. Think of iris as a Python object containing everything about the dataset. You can inspect it:

print(iris.keys())

Output

dict_keys([
    'data',
    'target',
    'frame',
    'target_names',
    'DESCR',
    'feature_names',
    'filename',
    'data_module'
])

Dataset Contents

iris.data

Contains the feature values. Example

Sepal Length	Sepal Width	Petal Length	Petal Width
5.1	3.5	1.4	0.2
4.9	3.0	1.4	0.2

There are 4 numerical features.

iris.target

Contains the labels. Example

[0, 0, 0, 1, 2, 1, ...]

Where

→ Setosa
→ Versicolor
→ Virginica

Step 3: Separate Features and Labels

X = iris.data
y = iris.target

Machine Learning models always use:

X → Input Features

y → Target Labels

Here,

X =
[
 [5.1,3.5,1.4,0.2],
 [4.9,3.0,1.4,0.2],
 ...
]

y =
[
0,
0,
1,
2,
...
]

Step 4: Split the Dataset

X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

This divides the dataset into training and testing sets. Imagine you have 150 flowers.

Total Flowers = 150

Since

test_size = 0.2

20% goes to testing.

Training = 120 flowers

Testing = 30 flowers

Diagram

150 Samples

      │
      ▼

 ┌──────────────┐
 │ train = 120  │
 └──────────────┘

 ┌──────────────┐
 │ test = 30    │
 └──────────────┘

Why Split?

If we train and test on the same data:

Model memorizes answers

Instead,

Training Data
↓

Model Learns

↓

Testing Data

↓

Check if it generalizes

random_state=42

random_state=42

Makes the split reproducible. Without it, Run 1

Train
A B C D

Test
E F

Run 2

Train
B D E

Test
A C

Every run changes. With 42, every run produces the same split.

Step 5: Create a Pipeline

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", LogisticRegression())
])

This is one of the best features of Scikit-learn. Instead of writing

scaler.fit()

scaler.transform()

model.fit()

model.predict()

everything is combined into a single object. Pipeline structure

Input Data
      │
      ▼

StandardScaler

      │
      ▼

LogisticRegression

      │
      ▼

Prediction

First Step

("scaler", StandardScaler())

Standardizes every feature. Formula [
z=\frac{x-\mu}{\sigma}
] Example Original values

5
10
15

Scaled values

-1.22
0.00
1.22

Now all features have

Mean = 0

Standard Deviation = 1

This helps many algorithms converge faster and prevents features with larger scales from dominating.

Second Step

("classifier", LogisticRegression())

This is the Machine Learning algorithm. Its job:

Given flower measurements

↓

Predict flower species

Step 6: Train the Pipeline

pipeline.fit(X_train, y_train)

This is the most important step. Internally, the pipeline performs:

Step A

StandardScaler.fit(X_train)

Calculates

Mean

Standard deviation

using only the training data.

Step B

StandardScaler.transform(X_train)

Converts the training data into standardized values.

Step C

LogisticRegression.fit()

Learns the relationship

Flower Measurements

↓

Flower Species

So the pipeline effectively does:

Training Data

↓

Compute Mean & Std

↓

Scale Data

↓

Train Logistic Regression

All with one line:

pipeline.fit(...)

Step 7: Predict

predictions = pipeline.predict(X_test)

The pipeline automatically:

Test Data

↓

StandardScaler.transform()

↓

Logistic Regression

↓

Predictions

Notice that it does not call fit() on the scaler again. It reuses the mean and standard deviation learned from the training data. Example output

[1 0 2 1 1]

Meaning

Flower 1 → Versicolor

Flower 2 → Setosa

Flower 3 → Virginica

Step 8: Evaluate

print("Accuracy:", pipeline.score(X_test, y_test))

For LogisticRegression, .score() returns accuracy. Internally it is equivalent to:

from sklearn.metrics import accuracy_score

pred = pipeline.predict(X_test)

accuracy = accuracy_score(y_test, pred)

Suppose

flowers tested

correct

incorrect

Accuracy

29 / 30

=

0.9667

=

96.67%

Step 9: Save the Model

joblib.dump(pipeline, "iris_pipeline.pkl")

This saves the entire pipeline to a file.

iris_pipeline.pkl

contains:

StandardScaler (with learned mean and standard deviation)
LogisticRegression (with learned coefficients)

You don’t need to retrain the model every time you run your application.

Step 10: Load the Saved Model

loaded_model = joblib.load("iris_pipeline.pkl")

This restores the saved pipeline into memory. It is identical to the original trained pipeline.

Step 11: Predict Again

print(loaded_model.predict(X_test[:5]))

Here,

X_test[:5]

selects the first five test samples. For example:

30 test samples

↓

Take only first 5

These samples are automatically:

Standardized

↓

Passed into Logistic Regression

↓

Predicted

Possible output

[1 0 2 1 1]

What Happens Internally?

                Iris Dataset
                     │
                     ▼
        X (Features), y (Labels)
                     │
                     ▼
           train_test_split()
          /                   \
         ▼                     ▼
Training Data           Testing Data
     │                       │
     ▼                       │
 StandardScaler.fit()         │
     │                       │
     ▼                       │
 Transform Training Data      │
     │                       │
     ▼                       │
 LogisticRegression.fit()     │
     │                       │
     └───────────────┐        │
                     ▼        ▼
             pipeline.predict(X_test)
                     │
                     ▼
          StandardScaler.transform()
                     │
                     ▼
          Logistic Regression Predict
                     │
                     ▼
               Predicted Labels
                     │
                     ▼
             Compare with y_test
                     │
                     ▼
                 Accuracy Score
                     │
                     ▼
          Save Pipeline (.pkl file)
                     │
                     ▼
              Load Later with joblib
                     │
                     ▼
             Predict New Samples

Why use a `Pipeline`?

Without a pipeline, you’d manually write:

scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

model = LogisticRegression()
model.fit(X_train, y_train)

predictions = model.predict(X_test)

With a pipeline:

pipeline = Pipeline([
    ("scaler", StandardScaler()),
    ("classifier", LogisticRegression())
])

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

The pipeline automatically ensures that preprocessing is applied consistently during both training and prediction, making the code cleaner and reducing the risk of mistakes such as accidentally fitting the scaler on the test data.

Day 1

Day 2

Day 3

Day 4

Day 5

Day 6

Day 7

Day 8

Day 9

Day 10

Day 11

Day 12

Day 13

Day 14

Day 15

Day 16

Day 17

Day 18

Scikit Learn Code Example

Step 1: Import Required Libraries

Step 2: Load the Dataset

Dataset Contents

Step 3: Separate Features and Labels

Step 4: Split the Dataset

Why Split?

random_state=42

Step 5: Create a Pipeline

First Step

Second Step

Step 6: Train the Pipeline

Step A

Step B

Step C

Step 7: Predict

Step 8: Evaluate

Step 9: Save the Model

Step 10: Load the Saved Model

Step 11: Predict Again

What Happens Internally?

Why use a `Pipeline`?

​Step 1: Import Required Libraries

​Step 2: Load the Dataset

​Dataset Contents

​Step 3: Separate Features and Labels

​Step 4: Split the Dataset

​Why Split?

​random_state=42

​Step 5: Create a Pipeline

​First Step

​Second Step

​Step 6: Train the Pipeline

​Step A

​Step B

​Step C

​Step 7: Predict

​Step 8: Evaluate

​Step 9: Save the Model

​Step 10: Load the Saved Model

​Step 11: Predict Again

​What Happens Internally?

​Why use a Pipeline?

Step 1: Import Required Libraries

Step 2: Load the Dataset

Dataset Contents

Step 3: Separate Features and Labels

Step 4: Split the Dataset

Why Split?

random_state=42

Step 5: Create a Pipeline

First Step

Second Step

Step 6: Train the Pipeline

Step A

Step B

Step C

Step 7: Predict

Step 8: Evaluate

Step 9: Save the Model

Step 10: Load the Saved Model

Step 11: Predict Again

What Happens Internally?

Why use a `Pipeline`?