A good score can still be a bad answer

Introduction

Clustering groups data by similarity. Teams use it for customer segmentation, fraud detection, and finding patterns nobody assigned anyone to look for. The hard part was never running the algorithm — any of them will happily produce clusters from almost any data you feed them. The hard part is knowing whether the clusters it found mean anything.

Taliferro learned this the hard way building TODD, our own product. An early version clustered incoming customer signals to decide which ones needed follow-up first. The clustering scored well — a silhouette score above 0.8, genuinely tight and well-separated groups. But when we looked at what actually separated the clusters, it was which integration the signal came from (Slack versus email versus a form), not anything about how urgent it was. Mathematically clean clusters. Useless for the actual decision.

Clustering: A Brief Overview

Clustering algorithms group data points into clusters based on similarity or density so that points within a cluster are more similar to each other than to points in other clusters. Common choices in 2025 include:

• K-Means: Partitions data into K clusters by minimizing within-cluster variance. Fast and effective for convex, similarly sized clusters.
• Hierarchical (Agglomerative/Divisive): Builds a tree (dendrogram) of clusters; useful when you want multi-scale structure.
• DBSCAN: Density-based; finds arbitrarily shaped clusters and flags outliers—no need to pre-specify K.
• HDBSCAN: A hierarchical, parameter-robust extension of DBSCAN that handles variable density better and often needs less tuning.
• Spectral Clustering: Uses graph Laplacian eigenvectors to separate non-convex clusters when Euclidean assumptions break down.
• Gaussian Mixture Models (GMM): A probabilistic approach that models clusters as mixtures of Gaussians; gives soft assignments and uncertainty.

Why Choosing the Right Cluster Count Is Hard

Pick too few clusters and you flatten real differences together. Pick too many and you get noise that looks like insight — three clusters that are really just one group split by chance. The Elbow method narrows the guesswork, but it's still a guess. That's the actual reason silhouette scoring exists: to put a number on how well-separated the clusters you picked really are.

How Silhouette Scores Actually Work

The score compares how close a point is to others in its own cluster versus the nearest different cluster. It ranges from −1 to 1, and it's most reliable on compact, well-separated groups — the geometric assumption baked into the metric, which is exactly what can mislead you if your real-world groups don't happen to be shaped that way.

• 1: The data point is well clustered.
• 0: The data point is on or very close to the decision boundary between two neighboring clusters.
• -1: The data point is incorrectly clustered.

The overall silhouette score is the mean across samples. In practice, complement it with a silhouette plot to spot imbalanced clusters, and consider alternatives when clusters are non‑convex or densities vary:

• Davies–Bouldin Index (DBI): Lower is better; penalizes overlapping clusters.
• Calinski–Harabasz (CH): Higher is better; balances within/between dispersion.

For large datasets, computing pairwise distances can be expensive. Use stratified sampling (e.g., 10–20% of points), mini‑batch K‑Means, or approximate nearest neighbors to estimate silhouette efficiently, then validate results on a held‑out slice.

How to Use Silhouette Scores the Right Way

1. Choose and fit a clustering method (K‑Means, HDBSCAN, Spectral, GMM) appropriate to your data’s shape and noise.
2. Evaluate multiple clusterings: sweep K (for K‑Means/GMM) or parameters (for DBSCAN/HDBSCAN), computing silhouette on a sample if needed.
3. Inspect the silhouette plot to detect skinny or overlapping clusters that a single average may hide.
4. Cross‑check with DBI/CH and domain metrics (e.g., downstream accuracy, revenue lift) to select the most useful segmentation.

Quick Example (scikit‑learn)

Install once: pip install scikit-learn matplotlib. The snippet below sweeps K to maximize the silhouette score, then plots a silhouette diagram for the chosen clustering.

from sklearn.datasets import make_blobs
          from sklearn.cluster import KMeans
          from sklearn.metrics import silhouette_score, silhouette_samples
          import numpy as np
          import matplotlib.pyplot as plt
          
          # 1) Synthetic dataset for demo (replace with your data matrix X)
          X, _ = make_blobs(n_samples=2000, centers=4, cluster_std=0.60, random_state=42)
          
          # 2) Sweep K and compute silhouette score
          scores = []
          ks = range(2, 9)
          for k in ks:
              km = KMeans(n_clusters=k, n_init="auto", random_state=42)
              labels = km.fit_predict(X)
              scores.append(silhouette_score(X, labels))
          
          best_k = ks[int(np.argmax(scores))]
          print(f"Best k by silhouette: {best_k}, score={max(scores):.3f}")
          
          # 3) Fit best model and compute per‑sample silhouette
          km = KMeans(n_clusters=best_k, n_init="auto", random_state=42)
          labels = km.fit_predict(X)
          s = silhouette_samples(X, labels)
          
          # 4) Silhouette plot
          fig, ax = plt.subplots()
          y_lower = 10
          for i in range(best_k):
              ith_s = np.sort(s[labels == i])
              size = ith_s.shape[0]
              ax.fill_betweenx(np.arange(y_lower, y_lower + size), 0, ith_s, alpha=0.7)
              ax.text(-0.05, y_lower + 0.5 * size, str(i))
              y_lower += size + 10
          
          ax.axvline(np.mean(s), linestyle="--")
          ax.set_xlabel("Silhouette coefficient")
          ax.set_ylabel("Cluster")
          ax.set_yticks([])
          plt.show()

Related Reading

• Why silhouette scores fail on imbalanced data
• When high clustering scores still break decisions
• Bias Drift Detection: Keep AI Fair Over Time
• Consistent Output Protocol (COP): Make AI Reliable

What the score actually tells you — and what it doesn't

It's still worth computing. It just answers a narrower question than people treat it as answering.

• It tells you: whether the points in a cluster are closer to each other than to points in other clusters, as a single number you can compare across runs.
• It tells you: which of several candidate values of K produced the geometrically tightest groupings.
• It does not tell you: whether those groupings correspond to anything a human would recognize or act on.
• It does not tell you: whether the feature you clustered on was even the right one to split customers, transactions, or signals by in the first place.

Before you trust the number

Run these checks before you let a silhouette score justify a decision:

1. Pull a handful of records from each cluster and read them. Do the groupings make sense to someone who knows the business, or only to the algorithm?
2. Check what's actually driving the separation. Plot the top features by cluster — if the split traces back to something incidental (signup date, data source, timezone) instead of the thing you meant to segment by, the score is measuring the wrong axis.
3. Test the clusters against a real outcome. If you're segmenting customers, do the segments predict something that matters — churn, spend, response rate? If not, a high score is describing structure that doesn't pay off.

A silhouette score is a diagnostic, not a verdict. It tells you the clusters are mathematically clean. Only steps like these tell you whether they're actually useful.

Video: How Taliferro Group Does Machine Learning

Watch how Taliferro Group applies machine learning in real-world projects, complementing the clustering and silhouette analysis discussed in this article.

FAQ

What is a good silhouette score?

A score close to 1 indicates strong clustering. Scores near 0 suggest overlapping clusters, while negative values show misclassification.

Which clustering algorithm works best with silhouette scores?

Silhouette analysis works with K-Means, Hierarchical Clustering, and DBSCAN. The best choice depends on your dataset’s shape, scale, and noise.

Why should businesses care about silhouette scores?

They validate whether customer segments or operational groupings are statistically meaningful, improving the reliability of analytics used in decisions.

Tyrone Showers