agglomerative clustering in machine learning

agglomerative clustering is a hierarchical clustering algorithm that starts with each data point as its own cluster and iteratively merges the closest clusters until a stopping criterion is reached. it is a bottom-up approach that produces a dendrogram, which is a tree-like diagram that shows the hierarchical relationship between the clusters. the algorithm can be implemented using the scikit-learn library in python.

agglomerative clustering algorithm

agglomerative clustering is a hierarchical algorithm that creates a nested hierarchy of clusters by merging clusters in a bottom-up approach. this algorithm includes the following steps −

treat each data point as a single cluster
compute the proximity matrix using a distance metric
merge clusters based on a linkage criterion
update the distance matrix
repeat steps 3 and 4 until a single cluster remains

why use agglomerative clustering?

the agglomerative clustering allows easy interpretation of relationships between data points. unlike k-means clustering, we do not need to specify the number of clusters. it is very efficient and can identify small clusters.

implementation of agglomerative clustering in python

we will use the iris dataset for demonstration. the first step is to import the necessary libraries and load the dataset.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.cluster import agglomerativeclustering
from scipy.cluster.hierarchy import dendrogram, linkage

iris = load_iris()
x = iris.data
y = iris.target

the next step is to create a linkage matrix that contains the distances between each pair of clusters. we can use the linkage function from the scipy.cluster.hierarchy module to create the linkage matrix.

z = linkage(x, 'ward')

the 'ward' method is used to calculate the distances between the clusters. it minimizes the variance of the distances between the clusters being merged.

we can visualize the dendrogram using the dendrogram function from the same module.

plt.figure(figsize=(7.5, 3.5))
plt.title("iris dendrogram")
dendrogram(z)
plt.show()

the resulting dendrogram (see the following plot) shows the hierarchical relationship between the clusters. we can see that the algorithm has merged the closest clusters first, and the distance between the clusters increases as we move up the tree.

the final step is to apply the clustering algorithm and extract the cluster labels. we can use the agglomerativeclustering class from the sklearn.cluster module to apply the algorithm.

model = agglomerativeclustering(n_clusters=3)
model.fit(x)
labels = model.labels_

the n_clusters parameter specifies the number of clusters to be extracted from the data. in this case, we have specified n_clusters=3 because we know that the iris dataset has three classes.

we can visualize the resulting clusters using a scatter plot.

plt.figure(figsize=(7.5, 3.5))
plt.scatter(x[:, 0], x[:, 1], c=labels)
plt.xlabel("sepal length")
plt.ylabel("sepal width")
plt.title("agglomerative clustering results")
plt.show()

the resulting plot shows the three clusters identified by the algorithm. we can see that the algorithm has successfully separated the data points into their respective classes.

example

here is the complete implementation of agglomerative clustering in python −

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.cluster import agglomerativeclustering
from scipy.cluster.hierarchy import dendrogram, linkage

# load the iris dataset
iris = load_iris()
x = iris.data
y = iris.target
z = linkage(x, 'ward')

# plot the dendogram
plt.figure(figsize=(7.5, 3.5))
plt.title("iris dendrogram")
dendrogram(z)
plt.show()

# create an instance of the agglomerativeclustering class
model = agglomerativeclustering(n_clusters=3)

# fit the model to the dataset
model.fit(x)
labels = model.labels_

# plot the results
plt.figure(figsize=(7.5, 3.5))
plt.scatter(x[:, 0], x[:, 1], c=labels)
plt.xlabel("sepal length")
plt.ylabel("sepal width")
plt.title("agglomerative clustering results")
plt.show()

advantages of agglomerative clustering

following are the advantages of using agglomerative clustering −

produces a dendrogram that shows the hierarchical relationship between the clusters.
can handle different types of distance metrics and linkage methods.
allows for a flexible number of clusters to be extracted from the data.
can handle large datasets with efficient implementations.

disadvantages of agglomerative clustering

following are some of the disadvantages of using agglomerative clustering −

can be computationally expensive for large datasets.
can produce imbalanced clusters if the distance metric or linkage method is not appropriate for the data.
the final result may be sensitive to the choice of distance metric and linkage method used.
the dendrogram may be difficult to interpret for large datasets with many clusters.

applications of agglomerative clustering

you can find application of agglomerative clustering in many areas of unsupervised machine learning tasks. the following are some important areas of its applications in machine learning −

image segmentation
document clustering
customer behaviour analysis (customer segmentation)
market segmentation
social network analysis

Save or share this article