What Is Clustering?
Clustering is the process of separating different parts of data based on common characteristics. Disparate industries including retail, finance and healthcare use clustering techniques for various analytical tasks. In retail, clustering can help identify distinct consumer populations, which can then allow a company to create targeted advertising based on consumer demographics that may be too complicated to inspect manually. In finance, clustering can detect different forms of illegal market activity like orderbook spoofing in which traders deceitfully place large orders to pressure other traders into buying or selling an asset. In healthcare, clustering methods have been used to figure out patient cost patterns, early onset neurological disorders and cancer gene expression.
Python offers many useful tools for performing cluster analysis. The best tool to use depends on the problem at hand and the type of data available. There are three widely used techniques for how to form clusters in Python: Kmeans clustering, Gaussian mixture models and spectral clustering. For relatively lowdimensional tasks (several dozen inputs at most) such as identifying distinct consumer populations, Kmeans clustering is a great choice. For more complicated tasks such as illegal market activity detection, a more robust and flexible model such as a Guassian mixture model will be better suited. Finally, for highdimensional problems with potentially thousands of inputs, spectral clustering is the best option.
In addition to selecting an algorithm suited to the problem, you also need to have a way to evaluate how well these Python clustering algorithms perform. Typically, average withinclusterdistance from the center is used to evaluate model performance. Specifically, the average distance of each observation from the cluster center, called the centroid, is used to measure the compactness of a cluster. This makes sense because a good Python clustering algorithm should generate groups of data that are tightly packed together. The closer the data points are to one another within a Python cluster, the better the results of the algorithm. The sum within cluster distance plotted against the number of clusters used is a common way to evaluate performance.
For our purposes, we will be performing customer segmentation analysis on the mall customer segmentation data.
Data Clustering Techniques in Python
 Kmeans clustering
 Gaussian mixture models
 Spectral clustering
Reading in Data
Let’s start by reading our data into a Pandas data frame:
import pandas as pd
df = pd.read_csv("Mall_Customers.csv")
print(df.head())
We see that our data is pretty simple. It contains a column with customer IDs, gender, age, income, and a column that designates spending score on a scale of one to 100. The goal of our Python clustering exercise will be to generate unique groups of customers, where each member of that group is more similar to each other than to members of the other groups.
KMeans Clustering in Python
Kmeans clustering in Python is a type of unsupervised machine learning, which means that the algorithm only trains on inputs and no outputs. It works by finding the distinct groups of data (i.e., clusters) that are closest together. Specifically, it partitions the data into clusters in which each point falls into a cluster whose mean is closest to that data point.
Let’s import the Kmeans class from the clusters module in Scikitlearn:
from sklearn.clusters import KMeans
Next, let’s define the inputs we will use for our Kmeans clustering algorithm. Let’s use age and spending score:
X = df[['Age', 'Spending Score (1100)']].copy()
The next thing we need to do is determine the number of Python clusters that we will use. We will use the elbow method, which plots the withinclustersumofsquares (WCSS) versus the number of clusters. We need to define a forloop that contains instances of the Kmeans class. This forloop will iterate over cluster numbers one through 10. We will also initialize a list that we will use to append the WCSS values:
for i in range(1, 11):
kmeans = KMeans(n_clusters=i, random_state=0)
kmeans.fit(X)
We then append the WCSS values to our list. We access these values through the inertia attribute of the Kmeans object:
for i in range(1, 11):
kmeans = KMeans(n_clusters=i, random_state=0)
kmeans.fit(X)
wcss.append(kmeans.intertia_)
Finally, we can plot the WCSS versus the number of clusters. First, let’s import Matplotlib and Seaborn, which will allow us to create and format data visualizations:
import matplotlib.pyplot as plt
import seaborn as sns
Let’s style the plots using Seaborn:
sns.set()
Then plot the WCSS versus the clusters:
plt.plot(range(1, 11), wcss)
Next, add a title:
plt.title('Selecting the Numbeer of Clusters using the Elbow Method')
And finally, label the axes:
plt.xlabel('Clusters')
plt.ylabel('WCSS')
plt.show()
From this plot, we can see that four is the optimum number of clusters, as this is where the “elbow” of the curve appears.
We can see that Kmeans found four clusters, which break down thusly:

Young customers with a moderate spending score.

Young customers with a high spending score.

Middleaged customers with a low spending score.

Senior customers with a moderate spending score.
This type of information can be very useful to retail companies looking to target specific consumer demographics. For example, if most people with high spending scores are younger, the company can target those populations with advertisements and promotions.
Gaussian Mixture Model (GMM) in Python
This model assumes that clusters in Python can be modeled using a Gaussian distribution. Gaussian distributions, informally known as bell curves, are functions that describe many important things like population heights and weights.
These models are useful because Gaussian distributions have welldefined properties such as the mean, variance and covariance. The mean is just the average value of an input within a cluster. Variance measures the fluctuation in values for a single input. The covariance is a matrix of statistics describing how inputs are related to each other and, specifically, how they vary together.
Collectively, these parameters allow the GMM algorithm to create flexible identity clusters of complex shapes. Whereas Kmeans typically identifies spherically shaped clusters, GMM can more generally identify Python clusters of different shapes. This makes GMM more robust than Kmeans in practice.
Let’s start by importing the GMM package from Scikitlearn:
from sklearn.mixture import GaussianMixture
Next, let’s initialize an instance of the GaussianMixture class. Let’s start by considering three Python clusters and fit the model to our inputs (in this case, age and spending score):
from sklearn.mixture import GaussianMixture
n_clusters = 3
gmm_model = GaussianMixture(n_components=n_clusters)
gmm_model.fit(X)
Now, let’s generate the cluster labels and store the results, along with our inputs, in a new data frame:
cluster_labels = gmm_model.predict(X)
X = pd.DataFrame(X)
X['cluster'] = cluster_labels
Next, let’s plot each cluster within a forloop:
for k in range(0,n_clusters):
data = X[X["cluster"]==k]
plt.scatter(data["Age"],data["Spending Score (1100)"],c=color[k])
And, finally, format out plot:
plt.title("Clusters Identified by Guassian Mixture Model")
plt.ylabel("Spending Score (1100)")
plt.xlabel("Age")
plt.show()
The red and blue clusters seem relatively welldefined. The blue cluster is young customers with a high spending score and the red is young customers with a moderate spending score. The green cluster is less welldefined since it spans all ages and both low to moderate spending scores.
Now, let’s try four clusters:
...
n_clusters = 4
gmm_model = GaussianMixture(n_components=n_clusters)
...
Although four clusters show a slight improvement, both the red and blue ones are still pretty broad in terms of age and spending score values. So, let’s try five clusters:
Five clusters seem to be appropriate here. They can be described as follows:

Young customers with a high spending score (green).

Young customers with a moderate spending score (black).

Young to middleaged customers with a low spending score (blue).

Middleaged to senior customers with a low spending score (yellow).

Middleaged to senior customers with a moderate spending score (red).
Gaussian mixture models are generally more robust and flexible than Kmeans clustering in Python. Again, this is because GMM captures complex cluster shapes and Kmeans does not. This allows GMM to accurately identify Python clusters that are more complex than the spherical clusters that Kmeans identifies. GMM is an ideal method for data sets of moderate size and complexity because it is better able to capture clusters in sets that have complex shapes.
Spectral Clustering in Python
Spectral clustering is a common method used for cluster analysis in Python on highdimensional and often complex data. It works by performing dimensionality reduction on the input and generating Python clusters in the reduced dimensional space. Since our data doesn’t contain many inputs, this will mainly be for illustration purposes, but it should be straightforward to apply this method to more complicated and larger data sets.
Let’s start by importing the SpectralClustering class from the cluster module in Scikitlearn:
from sklearn.cluster import SpectralClustering
Next, let’s define our SpectralClustering class instance with five clusters:
spectral_cluster_model= SpectralClustering(
n_clusters=5,
random_state=25,
n_neighbors=8,
affinity='nearest_neighbors'
)
Next, let’s define our model object to our inputs and store the results in the same data frame:
X['cluster'] = spectral_cluster_model.fit_predict(X[['Age', 'Spending Score (1100)']])
Finally, let’s plot our clusters:
fig, ax = plt.subplots()
sns.scatterplot(x='Age', y='Spending Score (1100)', data=X, hue='cluster', ax=ax)
ax.set(title='Spectral Clustering')
We see that clusters one, two, three and four are pretty distinct while cluster zero seems pretty broad. Generally, we see some of the same patterns with the cluster groups as we saw for Kmeans and GMM, though the prior methods gave better separation between clusters. Once again, spectral clustering in Python is better suited for problems that involve much larger data sets like those with hundred to thousands of inputs and millions of rows.
The code from this post is available on GitHub.
Add Clustering to Your Toolkit
Though we only considered cluster analysis in the context of customer segmentation, it is largely applicable across a diverse array of industries. The Python clustering methods we discussed have been used to solve a diverse array of problems. Kmeans clustering has been used for identifying vulnerable patient populations. Gaussian mixture models have been used for detecting illegal market activities such as spoof trading, pump and dump and quote stuffing. Spectral clustering methods have been used to address complex healthcare problems like medical term grouping for healthcare knowledge discovery.
Regardless of the industry, any modern organization or company can find great value in being able to identify important clusters from their data. Python provides many easytoimplement tools for performing cluster analysis at all levels of data complexity. Further, having good knowledge of which methods work best given the data complexity is an invaluable skill for any data scientist. What we’ve covered provides a solid foundation for data scientists who are beginning to learn how to perform cluster analysis in Python.