LESSON 7: Unsupervised Learning – Customer Segmentation, Clustering, and Finding Hidden Patterns in Bank Data

1. LEARNING OBJECTIVES

By the end of this expansive, 20+ page lesson, you will be able to:

Understand the fundamental difference between Supervised Learning (predicting default/fraud) and Unsupervised Learning (discovering hidden groups in data).
Explain why an investment bank or retail bank needs to segment its customers into distinct behavioral groups.
Master the mathematics behind K-Means Clustering, the most widely used unsupervised algorithm in FinTech.
Use the Elbow Method to mathematically determine the exact number of customer segments in your database.
Understand the problem of high-dimensional data and why we use Principal Component Analysis (PCA) to visualize complex financial patterns in 2D.
Build a complete, beginner-friendly Python script using scikit-learn to cluster customers based on their spending, income, and credit behavior.
Interpreting the resulting clusters to create targeted marketing strategies and personalized credit card offers.
Understand the business application of Customer Lifetime Value (CLV) and how clustering drives higher profits.

2. SUPERVISED vs. UNSUPERVISED LEARNING

2.1 The “Answer Key” Dilemma
In Lessons 1 through 6, we exclusively studied Supervised Learning. In supervised learning, we always had a “Target” column (y).

When predicting loan defaults, y was “Paid = 0” or “Default = 1”.
When predicting stock prices, y was “Tomorrow’s closing price”.
This made training a model straightforward: we showed the machine the inputs and the answer key, and it learned the relationship.

2.2 Enter Unsupervised Learning
Unsupervised Learning occurs when we have no answer key. We give the machine a massive spreadsheet of data (e.g., 1 million customers with their ages, incomes, purchase histories, and credit scores), and we don’t tell it what to predict.
Instead, we say: “Machine, look at this massive pile of data and find me natural patterns, groupings, or structures that I didn’t know existed.”
It is like handing a detective a massive pile of clues without telling them who the criminal is, and asking them to find the hidden connections.

2.3 The Primary Business Use Case: Customer Segmentation
Banks have millions of customers. You cannot treat a 22-year-old college student the same as a 55-year-old CEO.
Customer Segmentation is the process of grouping your customers into distinct categories based on their behavioral similarities.

Segment A: “High-income, low-spending, conservative savers.”
Segment B: “High-income, high-spending, risk-taking traders.”
Segment C: “Low-income, high-fee sensitive, basic checking users.”
Once the bank finds these clusters, they can market the exact right product to the exact right group. (Segment B gets offered a premium margin trading account; Segment C gets offered a free checking account with ATM fee waivers).

3. THE MATHEMATICAL ENGINE: K-MEANS CLUSTERING

K-Means is the absolute gold standard algorithm for grouping data. It is mathematically beautiful yet surprisingly simple to implement.

3.1 The “Centroid” and The “Distance”
To understand K-Means, we must revisit high school geometry. Imagine plotting your customers on a 2D graph:

The horizontal axis (X) is Annual Income.
The vertical axis (Y) is Total Credit Card Debt.
Each customer is just a dot on this graph.
The goal of K-Means is to draw “circles” around groups of dots that are mathematically close to each other.

3.2 How K-Means Works in 4 Steps
Let’s walk through the algorithm exactly as the computer does it:

Initialization (Pick the seeds): Suppose we want to find 3 distinct groups. We tell the computer to drop 3 random points anywhere on the graph. These are the initial Centroids (the mathematical centers of our future groups).
Assignment (Group the dots): The computer measures the straight-line distance (using Euclidean distance: $(x^{2} - x^{1})^{2} + (y^{2} - y^{1})^{2}$ ) between every single customer dot and the 3 Centroids. It assigns every customer to the closest centroid. We now have 3 loose, messy groups.
Recalculation (Move the centers): The computer looks at every customer assigned to Group 1. It calculates the mathematical average (mean) of all their positions on the graph, and moves Centroid 1 to this new exact center. It does this for Group 2 and Group 3.
Iteration (Repeat until stable): Because the Centroids just moved, the distances have changed. The computer repeats Step 2 and Step 3 over and over again. Eventually, the Centroids stop moving entirely. The customers stop switching groups. The model has converged.

3.3 The Sum of Squared Errors (WCSS) – The “Inertia” Score
How does the computer know it has found the best groupings? It calculates WCSS (Within-Cluster Sum of Squares).
This measures the total distance between every customer and their centroid. A lower WCSS means the clusters are tightly packed and mathematically distinct. The algorithm will keep moving the centroids until it physically cannot lower the WCSS any further.

3.4 The “Elbow Method” – Choosing the right number of groups (K)
This is the most common question from beginners: “How do I tell the machine to look for 3 groups? Why not 5? Why not 50?”
If we ask for 50 clusters, we will just get 50 tiny groups of 2 customers each. That is useless for the bank.
We use the Elbow Method:

We run the K-Means algorithm once for $K = 1$ , calculate the WCSS.
We run it for $K = 2$ , calculate WCSS.
We run it for $K = 3, 4, 5, 6\dots$ up to 10.
We plot these numbers on a line graph. Initially, the WCSS drops sharply. But at a certain point, the line flattens out (looks like an arm bending at the elbow). That point is the perfect, optimal number of groups (K).

4. THE CURSE OF DIMENSIONALITY (AND HOW PCA FIXES IT)

4.1 The Problem of Too Many Factors
A bank doesn’t just have Income and Debt. It has 50 different attributes per customer: Age, Zip Code, Total Transactions last year, Average balance, Number of late payments, Frequency of ATM use, etc.
How do we plot a 50-dimensional graph? We can’t. Human brains can only see in 3 dimensions. Furthermore, K-Means breaks down in high dimensions because the distances between points become mathematically equal (it’s like being in a wide-open field vs a tight hallway).

4.2 Principal Component Analysis (PCA)
PCA is a mathematical technique for Dimensionality Reduction. It takes your 50-dimensional data and mathematically “squashes” it down to 2 or 3 dimensions, while preserving at least 80% of the important variance (information) in the data.
The simplified math: PCA uses linear algebra to find the “Principal Axes” (the primary directions where the data is spread out the most). It creates new columns (called Principal Components – PC1, PC2) that are linear combinations of your original 50 columns.
In FinTech: We apply PCA to reduce our 50 customer attributes down to 2, plot them on a 2D scatter plot, run K-Means, and instantly see distinct, colorful customer segments on a screen.

5. MASTERING THE FINANCIAL OUTPUT: INTERPRETING THE CLUSTERS

The machine just grouped 100,000 customers into 4 distinct buckets. The bank’s marketing team now asks: “What does each bucket represent?”
We interpret the clusters by looking at the Centroid Averages for each cluster.
Let’s say our clusters are:

Cluster 1 Centroid (Average Age: 22, Avg Income: $35k, Avg Account Balance: $2,000): We label this "The Young Accumulators". We pitch them low-fee savings accounts and educational investment apps.
Cluster 2 Centroid (Average Age: 55, Avg Income: $250k, Avg Account Balance: $500k): We label this "The High-Net-Worth Traders". We pitch them premium wealth management services and margin trading access.
Cluster 3 Centroid (Average Age: 45, Avg Income: $50k, Avg Account Balance: -$10k): We label this "The Over-Drafted". We pitch them debt consolidation loans and financial literacy workshops to help them get out of debt.

6. BEGINNER HANDS-ON LAB: CUSTOMER SEGMENTATION WITH K-MEANS & PCA

We will now build an end-to-end customer segmentation pipeline. We will generate mock customer financial data, run K-Means to find hidden groups, use PCA to visualize them on a 2D graph, and calculate the perfect number of groups using the Elbow Method. Every line is explained in detail.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.decomposition import PCA

# --- STEP 1: GENERATE A REALISTIC BANK DATASET ---
# In a real bank, this is a 1 million row SQL table. We generate 500 mock customers.
np.random.seed(42)
n_customers = 500

# We randomly distribute the data. Notice we create 3 hidden types of customers on purpose!
# Type A (Young, low income, low balance): 200 customers
type_a_age = np.random.normal(25, 3, 200)
type_a_income = np.random.normal(30000, 5000, 200)
type_a_balance = np.random.normal(2000, 500, 200)

# Type B (Middle aged, high income, massive balance): 150 customers
type_b_age = np.random.normal(45, 5, 150)
type_b_income = np.random.normal(120000, 20000, 150)
type_b_balance = np.random.normal(150000, 30000, 150)

# Type C (Older, low income, decreasing balance - risk group): 150 customers
type_c_age = np.random.normal(60, 4, 150)
type_c_income = np.random.normal(40000, 8000, 150)
type_c_balance = np.random.normal(-5000, 2000, 150) # Negative balance = overdraft!

# Combine them into a DataFrame
ages = np.concatenate([type_a_age, type_b_age, type_c_age])
incomes = np.concatenate([type_a_income, type_b_income, type_c_income])
balances = np.concatenate([type_a_balance, type_b_balance, type_c_balance])

df = pd.DataFrame({'Age': ages, 'Annual_Income': incomes, 'Account_Balance': balances})
print("Raw Financial Data (First 5 customers):")
print(df.head())

# --- STEP 2: STANDARD SCALING (CRITICAL FOR K-MEANS) ---
# K-Means uses distance. If Income is 100,000 and Age is 50, "Distance" will be dominated by Income.
# We MUST scale all features to the same range (mean=0, variance=1).
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

# --- STEP 3: THE ELBOW METHOD TO FIND OPTIMAL K ---
# We will test K from 1 to 10, and store the WCSS (Inertia).
wcss = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(df_scaled)
    wcss.append(kmeans.inertia_) # inertia_ is the WCSS score.

# Plot the Elbow Method
plt.figure(figsize=(10,6))
plt.plot(range(1, 11), wcss, marker='o', linestyle='--')
plt.title('Elbow Method - Finding Optimal Customer Segments')
plt.xlabel('Number of Clusters (K)')
plt.ylabel('WCSS (Within Cluster Sum of Squares)')
plt.grid(True)
plt.show()
# Based on this graph, a human analyst looks at the bend. It usually bends sharply at K=3.

# --- STEP 4: APPLY K-MEANS WITH THE OPTIMAL K (K=3) ---
kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
# Train and assign cluster labels in one step
df['Cluster_Label'] = kmeans.fit_predict(df_scaled)

print("\nAssigning customers to clusters (0, 1, 2)...")
print(df.head())

# --- STEP 5: INTERPRET THE CLUSTERS (MEAN VALUES) ---
# We group by the cluster label and look at the average values.
cluster_summary = df.groupby('Cluster_Label').mean()
print("\nThe Financial Profile of each Cluster:")
print(cluster_summary)

# --- STEP 6: VISUALIZE THE CLUSTERS USING PCA (DIMENSIONALITY REDUCTION) ---
# We have 3 dimensions (Age, Income, Balance). Let's squash it down to 2 dimensions for visualization.
pca = PCA(n_components=2)
pca_result = pca.fit_transform(df_scaled)

# Create a new DataFrame for the 2D plot
pca_df = pd.DataFrame(data=pca_result, columns=['PCA_1', 'PCA_2'])
pca_df['Cluster'] = df['Cluster_Label']

# Plot the beautiful Segmented Scatter Plot
plt.figure(figsize=(12,8))
colors = ['red', 'blue', 'green']
for cluster in range(3):
    clustered_data = pca_df[pca_df['Cluster'] == cluster]
    plt.scatter(clustered_data['PCA_1'], clustered_data['PCA_2'], 
                c=colors[cluster], label=f'Customer Segment {cluster}', alpha=0.6, edgecolors='k')

plt.title('Visualizing 3 Hidden Customer Segments using PCA')
plt.xlabel('Principal Component 1 (Simplified representation of the data)')
plt.ylabel('Principal Component 2')
plt.legend()
plt.grid(True)
plt.show()

# --- STEP 7: BUSINESS INTERPRETATION ---
print("\n--- BUSINESS ACTION PLAN ---")
if len(cluster_summary) == 3:
    # We manually extract the summary rows
    seg0 = cluster_summary.iloc[0]
    seg1 = cluster_summary.iloc[1]
    seg2 = cluster_summary.iloc[2]
    
    print(f"Segment 0 (Age: {seg0['Age']:.0f}, Income: ${seg0['Annual_Income']:.0f}, Balance: ${seg0['Account_Balance']:.0f}):")
    if seg0['Account_Balance'] < 0:
        print("  -> RISK GROUP: Overdrawn accounts. Send debt consolidation alerts.")
    else:
        print("  -> STANDARD GROUP: Middle of the road. Send standard credit card offers.")
        
    print(f"\nSegment 1 (Age: {seg1['Age']:.0f}, Income: ${seg1['Annual_Income']:.0f}, Balance: ${seg1['Account_Balance']:.0f}):")
    if seg1['Account_Balance'] > 100000:
        print("  -> PREMIUM GROUP: High net worth. Offer Wealth Management & IPO access.")
    else:
        print("  -> GROWTH GROUP: Young earners. Offer student loan refinancing.")

    print(f"\nSegment 2 (Age: {seg2['Age']:.0f}, Income: ${seg2['Annual_Income']:.0f}, Balance: ${seg2['Account_Balance']:.0f}):")
    if seg2['Account_Balance'] < 0:
        print("  -> RISK GROUP: Overdrawn accounts. Send debt consolidation alerts.")
    else:
        print("  -> SENIOR GROUP: Established savers. Offer fixed-term CDs.")

Running this code will reveal:
You will see an “Elbow Plot” that clearly bends at 3. The machine will automatically group the customers perfectly into: (1) Young low-income, (2) High-net-worth, and (3) Overdrafted risk, purely based on the math. Finally, the PCA plot will show three beautifully separated colors (Red, Blue, Green), proving that unsupervised learning can find hidden, human-interpretable financial profiles without ever being told the answer key.

7. SUMMARY FOR THE FINANCE PRACTITIONER

Unsupervised Learning is the “Discovery Engine” of a modern bank. While Fraud Detection (Supervised) finds known criminals, Unsupervised Learning finds new market opportunities and hidden financial dangers.
When you present this to a business team, you can say: “We used K-Means clustering to look at our 2 million customers. We found a segment of 30,000 customers who are making over $150k a year but are currently using a free checking account. If we pitch them our premium Platinum card, we can generate an extra $3 million in annual interchange fees.”
Furthermore, the PCA component is crucial. Whenever you walk into a boardroom, you cannot show a 50-column spreadsheet. You use PCA to render the data into a 2D scatter plot so executive stakeholders can literally see the market segments with their own eyes.

Diploma in Financial Technology LESSON 7: Unsupervised Learning – Customer Segmentation, Clustering, and Finding Hidden Patterns in Bank Data