Unsupervised Learning: K-Means Clustering

What Is Unsupervised Learning?

In supervised learning, every training record comes with a label — for example, "churned" or "stayed." Unsupervised learning works differently: you hand the algorithm a dataset with no labels and ask it to find structure on its own. K-means clustering is the most widely used unsupervised technique. It groups records into k clusters so that observations inside a cluster are as similar to each other as possible and as different as possible from observations in other clusters.

Common business uses include customer segmentation, grouping city service requests by geographic pattern, detecting unusual usage behavior, and summarizing large surveys. Because the algorithm produces groups rather than predictions, your job as a data analyst is to interpret what each group means and communicate that meaning clearly to decision-makers.

How K-Means Works

K-means follows a straightforward iterative process:

1. Initialize — The algorithm places k centroids (center points) randomly in the feature space.

2. Assign — Every data point is assigned to the nearest centroid, measured by Euclidean distance.

3. Update — Each centroid moves to the mean position of all points assigned to it.

4. Repeat — Steps 2 and 3 repeat until centroid positions stop changing (convergence).

The scikit-learn `KMeans` class handles this automatically. You specify `n_clusters=k`, call `.fit()` on scaled data, and retrieve cluster labels with `.labels_`.

Feature scaling is essential. K-means uses Euclidean distance, so a feature measured in dollars (0–10,000) will dominate a feature measured in years (0–80) if you do not scale first. Use `StandardScaler` or `MinMaxScaler` before fitting. This is a data-quality and model-validity issue, not just a best practice.

Choosing k: The Elbow Method

K-means requires you to specify k before fitting. Two diagnostics help you choose a defensible value.

Inertia (within-cluster sum of squares) measures the total squared distance of each point from its centroid. Lower inertia means tighter clusters, but inertia always decreases as k increases — adding more clusters eventually assigns every point to its own cluster, reducing inertia to zero. The elbow curve plots inertia on the y-axis against k on the x-axis. Look for the point where the curve bends sharply — the "elbow" — after which adding more clusters yields diminishing returns. That bend is a candidate value for k.

In Python with yellowbrick:

```python

from yellowbrick.cluster import KElbowVisualizer

from sklearn.cluster import KMeans

model = KMeans()

visualizer = KElbowVisualizer(model, k=(2, 11))

visualizer.fit(X_scaled)

visualizer.show()

```

Choosing k: Silhouette Score

The silhouette score gives a second, more rigorous check. For each point it computes:

• a — average distance to all other points in the same cluster
• b — average distance to all points in the nearest neighboring cluster

The silhouette score for that point is (b − a) / max(a, b). Scores range from −1 to +1. A score near +1 means the point fits its cluster well. A score near 0 means the point sits on a cluster boundary. A negative score suggests the point may have been assigned to the wrong cluster.

You compute the mean silhouette score across all points for each candidate k and prefer higher values. Compare the elbow curve and silhouette scores together: the best k typically shows both a clear elbow and a peak (or near-peak) silhouette score.

```python

from sklearn.metrics import silhouette_score

for k in range(2, 11):

km = KMeans(n_clusters=k, random_state=42)

labels = km.fit_predict(X_scaled)

score = silhouette_score(X_scaled, labels)

print(f'k={k}, silhouette={score:.3f}')

```

Visualizing and Profiling Clusters

Once you select k, refit the model and attach the cluster labels back to your original (unscaled) dataframe. A color-coded scatter plot — using two features or the first two principal components — makes the separation visible. Label each color in the legend with the cluster number.

Next, compute summary statistics per cluster (mean, median, count) using `groupby`. These statistics are what let you describe each cluster in plain English. For example: "Cluster 2 contains ZIP codes with high library visits per capita but low digital-access scores — these locations may benefit from expanded in-branch computer stations."

Writing for a Business Audience

Technical plots alone rarely move decision-makers. Your business memo should:

• State what the analysis was and why it was done (one short paragraph).
• Describe each cluster in plain language, using the summary statistics as evidence.
• Offer one concrete, data-backed recommendation per cluster.
• Avoid jargon such as "centroid," "inertia," or "Euclidean distance" unless you define the terms.

Clarity and brevity matter as much as accuracy. A city department director needs to act on your findings, not grade your code.

Data Ethics and Safety Notes

Public city datasets often contain information that can be disaggregated by neighborhood in ways that reflect historical inequities. Before labeling a cluster "low-performing" or similar, consider whether the pattern reflects a genuine difference in service demand or a disparity in resource allocation. Report what the data shows; avoid language that stigmatizes communities. Always verify that the dataset is truly public and contains no personally identifiable information (PII) before loading it into your environment. If PII is discovered, stop work and notify your instructor — handle data with the same care you would handle any sensitive workplace material.