Unsupervised Learning & Dimensionality Reduction

Finding Hidden Structure Without Labels

Not all data comes with labels. **Netflix** doesn't always know *why* a user watches a particular show—but it can discover hidden groups of similar users through **Clustering**. For **Visa**, the challenge is different: with hundreds of transaction features, **Dimensionality Reduction (PCA)** compresses the data into its most essential components without losing signal.

In this chapter, we explore **K-Means Clustering** for user segmentation, **PCA** for feature compression, and **Anomaly Detection** for catching outliers that don't belong to any cluster.

K-Means Clustering: User Segmentation

**K-Means** groups data points into **K** clusters by minimizing the distance between each point and its cluster center (centroid). For **Netflix**, this means grouping millions of users into "taste communities" (e.g., "Action Lovers," "Documentary Enthusiasts") without ever asking them to label themselves.

PythonRuns entirely in your browser — nothing is sent to a server.

# Netflix User Segmentation: K-Means Clustering
class KMeansClusterer:
    def __init__(self, k):
        self.k = k
        self.centroids = []

    def fit(self, data):
        # Initialize centroids as first K points (simplified)
        self.centroids = data[:self.k]
        
        print("K-MEANS CLUSTERING (K={0}):".format(self.k))
        # Assign each point to nearest centroid
        clusters = [[] for _ in range(self.k)]
        for point in data:
            distances = [abs(point[0] - c[0]) + abs(point[1] - c[1]) for c in self.centroids]
            nearest = distances.index(min(distances))
            clusters[nearest].append(point)
        
        labels = ["Action Lovers", "Drama Fans", "Doc Enthusiasts"]
        for i, cluster in enumerate(clusters):
            label = labels[i] if i < len(labels) else "Cluster {0}".format(i)
            print(" - {0}: {1} users -> {2}".format(label, len(cluster), cluster))

# Scenario: Segmenting users by (action_score, drama_score)
user_profiles = [[9, 2], [8, 3], [2, 9], [3, 8], [5, 5], [1, 7]]
kmeans = KMeansClusterer(k=3)
kmeans.fit(user_profiles)

# Netflix User Segmentation: K-Means Clustering
class KMeansClusterer:
    def __init__(self, k):
        self.k = k
        self.centroids = []

    def fit(self, data):
        # Initialize centroids as first K points (simplified)
        self.centroids = data[:self.k]
        
        print("K-MEANS CLUSTERING (K={0}):".format(self.k))
        # Assign each point to nearest centroid
        clusters = [[] for _ in range(self.k)]
        for point in data:
            distances = [abs(point[0] - c[0]) + abs(point[1] - c[1]) for c in self.centroids]
            nearest = distances.index(min(distances))
            clusters[nearest].append(point)
        
        labels = ["Action Lovers", "Drama Fans", "Doc Enthusiasts"]
        for i, cluster in enumerate(clusters):
            label = labels[i] if i < len(labels) else "Cluster {0}".format(i)
            print(" - {0}: {1} users -> {2}".format(label, len(cluster), cluster))

# Scenario: Segmenting users by (action_score, drama_score)
user_profiles = [[9, 2], [8, 3], [2, 9], [3, 8], [5, 5], [1, 7]]
kmeans = KMeansClusterer(k=3)
kmeans.fit(user_profiles)

PCA: Compressing Complex Data

**Principal Component Analysis (PCA)** finds the directions of maximum variance in your data and projects it onto fewer dimensions. For **Visa**, a transaction might have 200 features (time, location, merchant type, etc.). PCA can compress these into 10-20 "principal components" that capture 95% of the information, making models faster and more robust.

PythonRuns entirely in your browser — nothing is sent to a server.

# Visa Transaction Analytics: PCA Simulation
class PCAReducer:
    def __init__(self, n_components):
        self.n_components = n_components

    def reduce(self, feature_matrix):
        original_dims = len(feature_matrix[0])
        print("PCA DIMENSIONALITY REDUCTION:")
        print(" - Original Features: {0} dimensions".format(original_dims))
        print(" - Target Components: {0} dimensions".format(self.n_components))
        
        # Simulating variance explained
        variance_per_component = [round(60 / (i + 1), 1) for i in range(self.n_components)]
        total_variance = sum(variance_per_component)
        
        for i, v in enumerate(variance_per_component):
            print(" - PC{0}: Explains {1}% of variance".format(i + 1, v))
        
        print("\nTOTAL VARIANCE CAPTURED: {0:.1f}%".format(min(total_variance, 97.5)))
        print("COMPRESSION: {0}D -> {1}D (Reduced by {2}x)".format(original_dims, self.n_components, round(original_dims / self.n_components, 1)))

# Scenario: Compressing Visa's 200-feature transaction data
high_dim_data = [[1] * 200 for _ in range(5)] # 5 transactions, 200 features each
pca = PCAReducer(n_components=3)
pca.reduce(high_dim_data)

# Visa Transaction Analytics: PCA Simulation
class PCAReducer:
    def __init__(self, n_components):
        self.n_components = n_components

    def reduce(self, feature_matrix):
        original_dims = len(feature_matrix[0])
        print("PCA DIMENSIONALITY REDUCTION:")
        print(" - Original Features: {0} dimensions".format(original_dims))
        print(" - Target Components: {0} dimensions".format(self.n_components))
        
        # Simulating variance explained
        variance_per_component = [round(60 / (i + 1), 1) for i in range(self.n_components)]
        total_variance = sum(variance_per_component)
        
        for i, v in enumerate(variance_per_component):
            print(" - PC{0}: Explains {1}% of variance".format(i + 1, v))
        
        print("\nTOTAL VARIANCE CAPTURED: {0:.1f}%".format(min(total_variance, 97.5)))
        print("COMPRESSION: {0}D -> {1}D (Reduced by {2}x)".format(original_dims, self.n_components, round(original_dims / self.n_components, 1)))

# Scenario: Compressing Visa's 200-feature transaction data
high_dim_data = [[1] * 200 for _ in range(5)] # 5 transactions, 200 features each
pca = PCAReducer(n_components=3)
pca.reduce(high_dim_data)

Anomaly Detection: The Outlier Hunter

Anomaly Detection finds data points that don't belong to any cluster. For **Visa**, this is a second line of defense: even if a transaction passes rule-based checks, an anomaly detector can flag it as statistically "weird" compared to the user's typical behavior.

PythonRuns entirely in your browser — nothing is sent to a server.

# Visa Fraud: Anomaly Detection via Distance
class AnomalyDetector:
    def __init__(self, normal_data):
        self.baseline = normal_data
        # Calculate the "center" of normal behavior
        self.center = [sum(col) / len(col) for col in zip(*normal_data)]

    def detect(self, new_point, threshold=5.0):
        distance = sum((a - b) ** 2 for a, b in zip(new_point, self.center)) ** 0.5
        is_anomaly = distance > threshold
        
        print("ANOMALY DETECTION:")
        print(" - Baseline Center: {0}".format([round(c, 1) for c in self.center]))
        print(" - New Point      : {0}".format(new_point))
        print(" - Distance       : {0:.2f}".format(distance))
        print(" - Threshold      : {0}".format(threshold))
        print(" - Result         : {0}".format("ANOMALY DETECTED" if is_anomaly else "NORMAL"))

# Scenario: Checking a late-night, high-value foreign transaction
normal_behavior = [[50, 12, 0], [45, 14, 0], [60, 10, 0]] # [amount, hour, is_foreign]
detector = AnomalyDetector(normal_behavior)
detector.detect(new_point=[500, 3, 1])  # $500 at 3am, foreign

# Visa Fraud: Anomaly Detection via Distance
class AnomalyDetector:
    def __init__(self, normal_data):
        self.baseline = normal_data
        # Calculate the "center" of normal behavior
        self.center = [sum(col) / len(col) for col in zip(*normal_data)]

    def detect(self, new_point, threshold=5.0):
        distance = sum((a - b) ** 2 for a, b in zip(new_point, self.center)) ** 0.5
        is_anomaly = distance > threshold
        
        print("ANOMALY DETECTION:")
        print(" - Baseline Center: {0}".format([round(c, 1) for c in self.center]))
        print(" - New Point      : {0}".format(new_point))
        print(" - Distance       : {0:.2f}".format(distance))
        print(" - Threshold      : {0}".format(threshold))
        print(" - Result         : {0}".format("ANOMALY DETECTED" if is_anomaly else "NORMAL"))

# Scenario: Checking a late-night, high-value foreign transaction
normal_behavior = [[50, 12, 0], [45, 14, 0], [60, 10, 0]] # [amount, hour, is_foreign]
detector = AnomalyDetector(normal_behavior)
detector.detect(new_point=[500, 3, 1])  # $500 at 3am, foreign

Practice Questions

Question 1

Why is K-Means called 'unsupervised'?

Because the algorithm runs without electricity
Because it discovers groups in the data without needing pre-labeled examples
Because it only works at night
Because it requires a human supervisor to run

Question 2

What problem does PCA solve for Visa's 200-feature transaction data?

It makes the data look prettier
It reduces the number of features while preserving most of the important variance, making models faster and less prone to overfitting
It adds more features to improve accuracy
It encrypts the data for security