[Day 24] Unsupervised Machine Learning Type 7 – UMAP (with a Small Python Project)

🎯 What is UMAP?

UMAP (Uniform Manifold Approximation and Projection) is a machine learning technique for dimensionality reduction, just like PCA or t-SNE — but smarter, faster, and more scalable.

While PCA focuses on preserving variance and t-SNE on local neighbors, UMAP captures both the global shape and local clusters in your data — and works like a charm on real-world, messy datasets.

Unlike PCA, which focuses on broad trends, or t-SNE, which hones in on local cliques, UMAP does both—it keeps nearby points tight while respecting the bigger picture.

Example: Say you’ve got employee performance data with metrics like hours worked, sales closed, emails sent, meetings attended, etc. That’s a multidimensional headache. UMAP can shrink it into a 2D scatterplot where each dot is an employee, and similar performers—like the sales superstars or the chronic procrastinators—cluster together. It’s about spotting the patterns that matter.

Let's take one more:

👨‍💻 Real-World Use Case: Cybersecurity Session Monitoring

Imagine you're a cybersecurity analyst. You’re monitoring user sessions on a high-traffic application, trying to:

• Detect bot activity
• Identify suspicious patterns
• Group normal users by behavior

Each session comes with user activity metrics, like time spent, clicks, scroll depth, and login patterns. That’s a high-dimensional dataset — hard to plot, harder to interpret.

UMAP lets you squish that data into 2D, revealing meaningful clusters of:

• 👨 Normal users
• 🤖 Bots
• ❗ Suspicious users

See the video belowa for better understanding

⚡ Why Use UMAP in This Case?

• ⚡ Scales fast for real-time behavioral data
• 🔍 Detects behavioral patterns without needing labels
• 🚫 Flags outliers like bots or potential attackers
• 📊 Helps visualize user segmentation for risk monitoring
  

Python Project : Customer Behavior Explorer

Imagine you’re a retail analyst with customer data from an online store. Each customer has features like total spend, items bought, browsing time, and return rate. You want to see how these customer groups—maybe to tailor marketing campaigns—but the data’s in a high-dimensional space (4+ variables), and you need it in 2D. Let’s analyze a small dataset of 25 customers to see how UMAP reveals shopping behavior patterns.

Each customer is described by 4 features:

• Total Spend: Dollars spent in the last year (e.g., $50 to $2000).
• Items Bought: Number of items purchased (e.g., 1 to 50).
• Browsing Time: Minutes spent on the site per visit (e.g., 5 to 60).
• Return Rate: Percentage of items returned (e.g., 0% to 50%).

This is a 4D dataset—each customer is a point in 4D space, too tricky to visualize directly. UMAP will map it to 2D for us.

Data Set: Save it as customers_list.csv

✅ Python Code
?

# Import Libraries
import pandas as pd
import umap
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import StandardScaler
import warnings

# Suppress UMAP warning about n_jobs
warnings.filterwarnings("ignore", message="n_jobs value 1 overridden to 1 by setting random_state")

# Load the Dataset
df = pd.read_csv('customers_list.csv')

# Prepare Data for UMAP
X = df[['Total Spend', 'Items Bought', 'Browsing Time', 'Return Rate']]
y = df['Customer Type']

# Standardize the Features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Apply UMAP
umap_model = umap.UMAP(n_components=2, n_neighbors=5, random_state=42)
X_umap = umap_model.fit_transform(X_scaled)

# Create a DataFrame with UMAP Results
umap_df = pd.DataFrame(X_umap, columns=['UMAP1', 'UMAP2'])
umap_df['Customer Type'] = y

# Plot the Results
plt.figure(figsize=(10, 8))
sns.scatterplot(data=umap_df, x='UMAP1', y='UMAP2', hue='Customer Type', palette='deep', s=100, alpha=0.7)
plt.title('UMAP Visualization of 25 Customers Dataset')
plt.xlabel('UMAP Dimension 1')
plt.ylabel('UMAP Dimension 2')
plt.legend(title='Customer Type')
plt.grid(True)
plt.show()

Result:

What the Output Graph Looks Like

Layout Explanation:

• Clusters: Expect 4 distinct groups:
  • Casual: ~7 points (low spend ~$120–$180, few items, short browsing).
  • Big Spender: ~6 points (high spend ~$1100–$1500, many items, long browsing).
  • Returner: ~6 points (moderate spend ~$280–$350, high return rates).
  • Browser: ~6 points (low spend ~$60–$90, long browsing, few items).
• Separation: Clusters should be clear, with UMAP keeping similar customers close and dissimilar ones apart, while preserving some global relationships (e.g., Casual might be nearer to Browser than Big Spender).

How about doing another project?


"BotRadar – Visualizing User Sessions to Detect Anomalies"

Dataset:

📋 Cybersecurity Session Dataset (25 Samples)

✅ Python Code

# pip install umap-learn

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import umap
from sklearn.preprocessing import StandardScaler

# Step 1: Load the dataset
df = pd.read_csv("cyber_user_behavior_umap.csv")
X = df.drop(columns=["User Type"])
y = df["User Type"]

# Step 2: Scale the features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 3: Apply UMAP
reducer = umap.UMAP(n_components=2, n_neighbors=4, min_dist=0.4, random_state=42)
X_umap = reducer.fit_transform(X_scaled)

# Step 4: Visualize the results
umap_df = pd.DataFrame(X_umap, columns=["UMAP1", "UMAP2"])
umap_df["User Type"] = y

plt.figure(figsize=(10, 8))
sns.scatterplot(data=umap_df, x="UMAP1", y="UMAP2", hue="User Type", palette="Set2", s=120)
plt.title("UMAP Projection of Cybersecurity User Sessions")
plt.grid(True)
plt.xlabel("UMAP Dimension 1")
plt.ylabel("UMAP Dimension 2")
plt.legend(title="User Type")
plt.show()

Result:

🧑‍💻 Color Legend: What the User Types Mean

• 🟢 Normal users: Typical browsing behavior — steady clicks, scrolls, and login patterns.
• 🟠 Bots: Often low scroll, few pages, repetitive or fast activity.
• 🔵 Suspicious: In-between behavior — might be real users doing weird things, or bots trying to mimic users.

💬 Join the DecodeAI WhatsApp Channel for regular AI updates → Click here