Introduction

Machine Learning becomes easier to understand when theoretical concepts are connected to a complete practical example. In this tutorial, you will follow a beginner-friendly Machine Learning workflow from problem definition and data exploration to model training, evaluation, and prediction.

We will build a classification model using the Iris flower dataset. The model will learn from flower measurements and predict the species of a flower it has not previously seen.

The Iris dataset is available directly through scikit-learn, so you do not need to download a separate file. It contains numerical measurements describing flowers and a target identifying the corresponding flower species.

Learning Objectives

Prerequisites

This tutorial is intended for beginners. You do not need previous experience building Machine Learning models, but basic familiarity with Python will make the code easier to understand.

Required Python Libraries

This tutorial uses pandas for tabular data, Matplotlib for visualization, and scikit-learn for loading data, splitting the dataset, training the model, and calculating evaluation metrics.

Create a Virtual Environment

python -m venv .venv

Activate the virtual environment using the command appropriate for your operating system.

Windows

.venv\Scripts\activate

Linux or macOS

source .venv/bin/activate

Install the Libraries

pip install pandas matplotlib scikit-learn jupyter

Machine Learning Workflow

A Machine Learning project is not only a call to a training method. It is a sequence of connected activities that begins with a clearly defined problem and continues after the model has been created.

Understanding the Tutorial Problem

The objective is to predict the species of an Iris flower from four numerical measurements. Because the output is a category, this is a classification problem.

Import the Required Libraries

import pandas as pd
import matplotlib.pyplot as plt

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import (
    accuracy_score,
    classification_report,
    confusion_matrix,
    ConfusionMatrixDisplay
)

Load the Dataset

iris = load_iris()

print(iris.DESCR)

The returned object contains the measurements, target identifiers, feature names, target names, and a description of the dataset.

print("Feature names:")
print(iris.feature_names)

print("\nTarget names:")
print(iris.target_names)

Convert the Data into a DataFrame

A pandas DataFrame provides a readable tabular structure and useful methods for inspecting rows, columns, data types, and missing values.

data = pd.DataFrame(
    iris.data,
    columns=iris.feature_names
)

data["target"] = iris.target
data["species"] = data["target"].map(
    dict(enumerate(iris.target_names))
)

print(data.head())

What the Code Does

Explore the Dataset

Data exploration helps identify the number of observations, data types, value ranges, missing values, class distribution, and possible quality problems.

Check the Dataset Dimensions

print("Dataset shape:", data.shape)

The first value represents the number of rows, and the second value represents the number of columns in the DataFrame.

Inspect Column Information

data.info()

Review Descriptive Statistics

print(data.describe())

Descriptive statistics help summarize the count, mean, standard deviation, minimum, maximum, and percentile values of numerical columns.

Check Missing Values

print(data.isnull().sum())

Check Duplicate Rows

print("Duplicate rows:", data.duplicated().sum())

Inspect the Class Distribution

print(data["species"].value_counts())

Separate Features and Target

The feature matrix is conventionally represented by \(X\), while the target vector is represented by \(y\).

Each \(\mathbf{x}^{(i)}\) represents the features of one flower, while \(y^{(i)}\) represents its known species.

X = data[iris.feature_names]
y = data["target"]

print("Feature matrix shape:", X.shape)
print("Target vector shape:", y.shape)

Split the Dataset

The model needs one portion of the data for learning and another portion for evaluation. Evaluating the model on its training data does not provide a reliable measure of performance on unseen observations.

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

print("Training features:", X_train.shape)
print("Test features:", X_test.shape)

Create the Model

This tutorial uses a Decision Tree Classifier. A decision tree learns a series of feature-based conditions that divide the data into increasingly specific groups.

model = DecisionTreeClassifier(
    max_depth=3,
    random_state=42
)

Limiting tree depth can make the model easier to inspect and may reduce the risk of learning overly specific patterns from the training data.

Train the Model

model.fit(X_train, y_train)

The fit() method trains the decision tree using the training features and their known target classes.

Generate Predictions

predictions = model.predict(X_test)

comparison = pd.DataFrame({
    "actual": y_test.to_numpy(),
    "predicted": predictions
})

comparison["actual_species"] = comparison["actual"].map(
    dict(enumerate(iris.target_names))
)

comparison["predicted_species"] = comparison["predicted"].map(
    dict(enumerate(iris.target_names))
)

print(comparison.head(10))

The predict() method applies the trained decision tree to the unseen test examples. The comparison table makes it easier to inspect actual and predicted classes.

In this expression, \(f\) represents the trained model, \(X_{\text{test}}\) represents the unseen test features, and \(\hat{y}\) represents the predicted classes.

Evaluate the Model

Model evaluation checks how well the classifier performs on data that was not used for training.

Accuracy

accuracy = accuracy_score(
    y_test,
    predictions
)

print(f"Accuracy: {accuracy:.2f}")

Accuracy measures the proportion of test observations that were classified correctly. It is easy to understand, but it should not be used alone when classes are imbalanced or when different kinds of mistakes have different consequences.

Classification Report

report = classification_report(
    y_test,
    predictions,
    target_names=iris.target_names,
    zero_division=0
)

print(report)

Confusion Matrix

matrix = confusion_matrix(
    y_test,
    predictions
)

display = ConfusionMatrixDisplay(
    confusion_matrix=matrix,
    display_labels=iris.target_names
)

display.plot()
plt.title("Iris Classification Confusion Matrix")
plt.show()

A confusion matrix shows how actual classes were distributed across predicted classes. Correct predictions appear on the main diagonal, while off-diagonal values represent classification errors.

Make a Prediction for a New Flower

Once the model has been trained and evaluated, it can classify a new flower from the same four measurements used during training.

new_flower = pd.DataFrame(
    [[5.1, 3.5, 1.4, 0.2]],
    columns=iris.feature_names
)

predicted_class = model.predict(new_flower)[0]
predicted_species = iris.target_names[predicted_class]

print("Predicted species:", predicted_species)

The new observation must contain the same features used during training, with the same meanings, units, names, and order expected by the model.

Inspect Class Probabilities

probabilities = model.predict_proba(
    new_flower
)[0]

probability_table = pd.DataFrame({
    "species": iris.target_names,
    "probability": probabilities
})

print(probability_table)

Complete Working Code

The following code combines the major tutorial steps into one executable example.

import pandas as pd
import matplotlib.pyplot as plt

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import (
    accuracy_score,
    classification_report,
    confusion_matrix,
    ConfusionMatrixDisplay
)

# Load the dataset
iris = load_iris()

# Create a readable DataFrame
data = pd.DataFrame(
    iris.data,
    columns=iris.feature_names
)

data["target"] = iris.target
data["species"] = data["target"].map(
    dict(enumerate(iris.target_names))
)

# Inspect the data
print(data.head())
print("\nMissing values:")
print(data.isnull().sum())

print("\nClass distribution:")
print(data["species"].value_counts())

# Separate features and target
X = data[iris.feature_names]
y = data["target"]

# Create training and test sets
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.20,
    random_state=42,
    stratify=y
)

# Create and train the model
model = DecisionTreeClassifier(
    max_depth=3,
    random_state=42
)

model.fit(X_train, y_train)

# Predict the test classes
predictions = model.predict(X_test)

# Evaluate accuracy
accuracy = accuracy_score(
    y_test,
    predictions
)

print(f"\nAccuracy: {accuracy:.2f}")

# Display detailed evaluation metrics
print("\nClassification report:")
print(
    classification_report(
        y_test,
        predictions,
        target_names=iris.target_names,
        zero_division=0
    )
)

# Display the confusion matrix
matrix = confusion_matrix(
    y_test,
    predictions
)

display = ConfusionMatrixDisplay(
    confusion_matrix=matrix,
    display_labels=iris.target_names
)

display.plot()
plt.title("Iris Classification Confusion Matrix")
plt.show()

# Predict a new flower
new_flower = pd.DataFrame(
    [[5.1, 3.5, 1.4, 0.2]],
    columns=iris.feature_names
)

predicted_class = model.predict(new_flower)[0]
predicted_species = iris.target_names[predicted_class]

print("\nPredicted species:", predicted_species)

# Display predicted class probabilities
probabilities = model.predict_proba(
    new_flower
)[0]

probability_table = pd.DataFrame({
    "species": iris.target_names,
    "probability": probabilities
})

print("\nPredicted probabilities:")
print(probability_table)

Preventing Data Leakage

Data leakage occurs when information that would not legitimately be available at prediction time influences model training or evaluation. Leakage can create unrealistically high evaluation results.

Overfitting and Underfitting

Common Beginner Mistakes

Best Practices

Practice Exercise

Complete the following tasks to strengthen your understanding of the tutorial.

Knowledge Check

Tutorial Summary