k-means clustering is a neat way to find ‘centers of density’ in a group of points. It’s useful for applications like finding natural groups, simplifying visualizations, and summarizing data.

There are plenty of libraries that implement the algorithm
in Javascript,
R and more.
While I’ve been working on an implementation
with some interesting properties, this article is about **understanding**
the algorithm.

Since it’s tricky to visualize the inner workings of the 2D form, let’s look at k-means in one dimension.

A cluster mean is a new point that represents the center of a cluster in the
data. k-means aims to equally distribute the cluster means by minimizing
the aggregate distance between means and values - technically the *within-cluster
sum of squares*.

Sum of squares should be familiar from simple linear regression, which also tries to minimize an aggregate distance, but between points and a line rather than points and other points.

This algorithm works by refining its guesses for cluster means iteratively until they’re ‘good enough’ - they minimize the sum of squares.

The most popular algorithm for calculating k-means is Lloyd’s algorithm - a
*heuristic*:
it comes up with a viable solution but not necessarily the best one.
Calculating the true, perfect k-means would take a whole lot longer, and offer
only a marginal improvement. It’s also *iterative*: it refines a guess
repeatedly until it’s ‘good enough.’

The input is a d-dimensional
**dataset** of length **n**, and a **k value** - which indicates how many
cluster means should be produced.

The algorithm iteratively improves the cluster means - but where do those come
from? They’re chosen randomly from the data - for **k** desired means,
we choose **k** values from the **n** values in the data.^{1}

These values are the *potential means* - hence `k-means`

. But since
we just chose them randomly, they likely aren’t that good - they
might even be terribly lopsided, inhabiting only one small part of
the dataset. This doesn’t matter - doing the next two steps repeatedly
will make them drift towards much better values.

Next, each point is grouped with the closest mean - effectively creating a voronoi tessellation with them as centers.

Comparing every point to every center can be very slow. Thus some implementations use shortcuts, like the polymaps implementation uses a k-d tree to speed things up.

The distance between points is measured as the euclidean distance. This is kind of neat in that it can work in many dimensions. My kmeans implementation has the following distance function that handles arbitrary dimensions.

At the end of this step, every point in your data is in a group belonging to a potential mean.

This one’s simple - just take the centroid of each group of points. In one dimension, this is just the average of all of the points. In two, it’s the average of each dimension.

The resulting averages are the new cluster means, and you can now go back to
**Assigning points to means** and repeat the process until the cluster mean
values stabilize.

If *k* is equal to *n* (the size of the data itself), the output
is the same as the input, since the distance between
each point and the representative mean is zero.

If *k* is one, then the eventual output will be the global mean -
the average of all the values.

Play with k-means: this shows the calculation, step by step, of cluster means from input values. Drag numbers in the first line to change the input. This requires a modern browser.

Wikipedia has a longer but less specific list

In **cartography** kmeans can be used for finding centers of density in 2D space.
However, it’s a different problem and a different solution
than the more common point ‘decluttering’ that intends to reduce
visual noise and overlapping
shapes: k-means is *not sensitive to symbolization*, so cluster points
can still overlap.

The algorithm can be used to select palettes for color reduction in images. What’s cool about that application is that the RGB color spaces is a three-dimensional cube, and thus the clustering happens in three dimensions.

- This actually turned out to be a bit of a stumper -
the algorithm in the polymaps implementation is suboptimal for when your
**k**value approaches**n**, and I didn’t want to settle for a random-sorting and slicing approach. I ended up implementing a Javascript version of Floyd’s algorithm for random subsets.