Iris Clustering Pipeline (K-Means)

Iris Clustering Pipeline

Iris Clustering Pipeline

A step-by-step guide to building a machine learning model to find natural groupings in data using a K-Means clustering algorithm.

Libraries Used

This pipeline uses a few key Python libraries. Here is a quick overview of their roles:

  • pandas: Used for data manipulation and analysis, primarily for working with DataFrames.
  • scikit-learn (sklearn): The core machine learning library. It provides all the necessary tools for loading the dataset, preprocessing, building the clustering model, and evaluating performance.

1. Load the Dataset

  • What the code does: It calls sk_datasets.load_iris() to fetch the Iris dataset. The `as_frame=True` argument ensures the data is returned as a pandas DataFrame.
  • Behind the scenes: The Iris dataset contains measurements of three different species of iris flowers. While the species labels are available, we will ignore them for clustering and use them later for evaluation.
  • Abstraction: The function call abstracts the process of locating, downloading, and loading the pre-packaged dataset into a structured format. 
import pandas as pd
from sklearn import datasets as sk_datasets

try:
    data = sk_datasets.load_iris(as_frame=True)
    df = data.frame
except Exception as e:
    print(f"Error loading dataset: {e}")
    exit()

2. Preprocessing with StandardScaler

  • What the code does: It instantiates a `StandardScaler`. This preprocessing step is vital for distance-based algorithms like K-Means, which are sensitive to the scale of the features.
  • Behind the scenes: The `StandardScaler` standardizes features by removing the mean and scaling to unit variance. This ensures all features contribute equally to the distance calculation used by the K-Means algorithm.
  • Abstraction: The `StandardScaler` abstracts the process of calculating the mean and standard deviation for each feature and applying the transformation formula `(x - mean) / std_dev` to every value. 
from sklearn.preprocessing import StandardScaler

preprocessor = StandardScaler()
X = preprocessor.fit_transform(df)

3. & 4. Build the Clustering Model and Predict

  • What the code does: It instantiates a KMeans model with `n_clusters=3` and then uses it to fit the data and predict the cluster labels.
  • Behind the scenes: The K-Means algorithm iteratively assigns data points to one of three clusters and then updates the cluster centers (centroids) to be the mean of all points assigned to that cluster. This process repeats until the centroids no longer move significantly.
  • Abstraction: The `KMeans` class abstracts the entire iterative process of finding the optimal cluster centroids. 
from sklearn.cluster import KMeans

kmeans_model = KMeans(n_clusters=3, random_state=42, n_init="auto")
labels = kmeans_model.fit_predict(X)

5. Evaluate the Model

  • What the code does: The silhouette_score() function from sklearn.metrics is used to calculate a measure of how well the data points are clustered.
  • Behind the scenes: The silhouette score ranges from -1 to +1. A score of +1 indicates that the clusters are well-separated from other clusters and are tightly grouped. A score of 0 indicates overlapping clusters. A score of -1 indicates that data points have been assigned to the wrong clusters.
  • Abstraction: The `silhouette_score` function abstracts the complex calculations required to compute this metric. 
from sklearn.metrics import silhouette_score

score = silhouette_score(X, labels)

print(f"Silhouette Score: {score:.4f}")

Comments

Post a Comment

Popular posts from this blog

Elevator Q-Learning Pipeline

Elevator Q-Learning Pipeline Elevator Q-Learning Pipeline A step-by-step guide to applying Q-learning to control a simple multi-floor elevator to minimize wait time. Libraries Used This project uses a few key Python libraries. Here is a quick overview of their roles: numpy: Used for numerical operations and managing arrays. random: Used for generating random numbers for the simulation. collections: Used for the `defaultdict` to store the Q-table. 1. Define the Environment What the code does: It defines an `ElevatorEnv` class that simulates an el...
Read more

MountainCar Q-Learning Pipeline

MountainCar Q-Learning Pipeline MountainCar Q-Learning Pipeline A step-by-step guide to applying Q-learning to the classic MountainCar environment from Gymnasium. Libraries Used This project uses a few key Python libraries. Here is a quick overview of their roles: numpy: Used for numerical operations and managing arrays. gymnasium: The library that provides the classic MountainCar-v0 environment. collections: Used for the `defaultdict` to store the Q-table. 1. Define the Discretization and Q-Learning Agent What the code does: It defines a `Discr...
Read more

SMS Spam Detection Pipeline

SMS Spam Detection Pipeline SMS Spam Detection Pipeline A step-by-step guide to building a machine learning model to classify SMS messages as spam or not-spam using a Naive Bayes classifier. Libraries Used This pipeline uses a few key Python libraries. Here is a quick overview of their roles: pandas: Used for data manipulation and analysis. scikit-learn (sklearn): The core machine learning library. It provides all the necessary tools for loading data, splitting, preprocessing text, building the model, and evaluating performance. 1. Load the Dataset What the code does: It uses pandas to read a CSV f...
Read more