k-means clustering algorithm

k-means clustering algorithm computes the centroids and iterates until we it finds optimal centroid. it assumes that the number of clusters are already known. it is also called flat clustering algorithm. the number of clusters identified from data by algorithm is represented by 'k' in k-means.

in this algorithm, the data points are assigned to a cluster in such a manner that the sum of the squared distance between the data points and centroid would be minimum. it is to be understood that less variation within the clusters will lead to more similar data points within same cluster.

working of k-means algorithm

we can understand the working of k-means clustering algorithm with the help of following steps −

step 1 − first, we need to specify the number of clusters, k, need to be generated by this algorithm.
step 2 − next, randomly select k data points and assign each data point to a cluster. in simple words, classify the data based on the number of data points.
step 3 − now it will compute the cluster centroids.
step 4 − next, keep iterating the following until we find optimal centroid which is the assignment of data points to the clusters that are not changing any more −
4.1 − first, the sum of squared distance between data points and centroids would be computed.

4.2 − now, we have to assign each data point to the cluster that is closer than other cluster (centroid).

4.3 − at last compute the centroids for the clusters by taking the average of all data points of that cluster.

k-means follows expectation-maximization approach to solve the problem. the expectation-step is used for assigning the data points to the closest cluster and the maximization-step is used for computing the centroid of each cluster.

while working with k-means algorithm we need to take care of the following things −

while working with clustering algorithms including k-means, it is recommended to standardize the data because such algorithms use distance-based measurement to determine the similarity between data points.
due to the iterative nature of k-means and random initialization of centroids, k-means may stick in a local optimum and may not converge to global optimum. that is why it is recommended to use different initializations of centroids.

the k-means algorithm is a straightforward and efficient algorithm, and it can handle large datasets. however, it has some limitations, such as its sensitivity to the initial centroids, its tendency to converge to local optima, and its assumption of equal variance for all clusters.

objective of k-means clustering

the main goals of cluster analysis are −

to get a meaningful intuition from the data we are working with.
cluster-then-predict where different models will be built for different subgroups.

implementation of k-means algorithm using python

python has several libraries that provide implementations of various machine learning algorithms, including k-means clustering. let's see how to implement the k-means algorithm in python using the scikit-learn library.

example 1

it is a simple example to understand how k-means works. in this example, we generate 300 random data points with two features. and apply k-means algorithm to generate clusters.

step 1 − import required libraries

to implement the k-means algorithm in python, we first need to import the required libraries. we will use the numpy and matplotlib libraries for data processing and visualization, respectively, and the scikit-learn library for the k-means algorithm.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import kmeans

step 2 − generate data

to test the k-means algorithm, we need to generate some sample data. in this example, we will generate 300 random data points with two features. we will visualize the data also.

x = np.random.rand(300,2)

plt.figure(figsize=(7.5, 3.5))
plt.scatter(x[:, 0], x[:, 1], s=20, cmap='summer');
plt.show()

output

step 3 − initialize k-means

next, we need to initialize the k-means algorithm by specifying the number of clusters (k) and the maximum number of iterations.

kmeans = kmeans(n_clusters=3, max_iter=100)

step 4 − train the model

after initializing the k-means algorithm, we can train the model by fitting the data to the algorithm.

kmeans.fit(x)

step 5 − visualize the clusters

to visualize the clusters, we can plot the data points and color them based on their assigned cluster.

plt.figure(figsize=(7.5, 3.5))
plt.scatter(x[:,0], x[:,1], c=kmeans.labels_, s=20, cmap='summer')
plt.scatter(kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1],
marker='x', c='r', s=50, alpha=0.9)
plt.show()

output

the output of the above code will be a plot with the data points colored based on their assigned cluster, and the centroids marked with an 'x' symbol in red color.

example 2

in this example, we are going to first generate 2d dataset containing 4 different blobs and after that will apply k-means algorithm to see the result.

first, we will start by importing the necessary packages −

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import kmeans

the following code will generate the 2d, containing four blobs −

from sklearn.datasets import make_blobs
x, y_true = make_blobs(n_samples=400, centers=4, cluster_std=0.60, random_state=0)

next, the following code will help us to visualize the dataset −

plt.scatter(x[:, 0], x[:, 1], s=20);
plt.show()

next, make an object of kmeans along with providing number of clusters, train the model and do the prediction as follows −

kmeans = kmeans(n_clusters=4)
kmeans.fit(x)
y_kmeans = kmeans.predict(x)

now, with the help of following code we can plot and visualize the cluster's centers picked by k-means python estimator −

plt.scatter(x[:, 0], x[:, 1], c=y_kmeans, s=20, cmap='summer')
centers = kmeans.cluster_centers_
plt.scatter(centers[:, 0], centers[:, 1], c='blue', s=100, alpha=0.9);
plt.show()

example 3

let us move to another example in which we are going to apply k-means clustering on simple digits dataset. k-means will try to identify similar digits without using the original label information.

first, we will start by importing the necessary packages −

%matplotlib inline
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import kmeans

next, load the digit dataset from sklearn and make an object of it. we can also find number of rows and columns in this dataset as follows −

from sklearn.datasets import load_digits
digits = load_digits()
digits.data.shape

output

(1797, 64)

the above output shows that this dataset is having 1797 samples with 64 features.

we can perform the clustering as we did in example 1 above −

kmeans = kmeans(n_clusters=10, random_state=0)
clusters = kmeans.fit_predict(digits.data)
kmeans.cluster_centers_.shape

output

(10, 64)

the above output shows that k-means created 10 clusters with 64 features.

fig, ax = plt.subplots(2, 5, figsize=(8, 3))
centers = kmeans.cluster_centers_.reshape(10, 8, 8)
for axi, center in zip(ax.flat, centers):
   axi.set(xticks=[], yticks=[])
   axi.imshow(center, interpolation='nearest', cmap=plt.cm.binary)

output

as output, we will get following image showing clusters centers learned by k-means.

the following lines of code will match the learned cluster labels with the true labels found in them −

from scipy.stats import mode
labels = np.zeros_like(clusters)
for i in range(10):
   mask = (clusters == i)
   labels[mask] = mode(digits.target[mask])[0]

next, we can check the accuracy as follows −

from sklearn.metrics import accuracy_score
accuracy_score(digits.target, labels)

output

0.7935447968836951

the above output shows that the accuracy is around 80%.

advantages of k-means clustering algorithm

the following are some advantages of k-means clustering algorithms −

it is very easy to understand and implement.
if we have large number of variables then, k-means would be faster than hierarchical clustering.
on re-computation of centroids, an instance can change the cluster.
tighter clusters are formed with k-means as compared to hierarchical clustering.

disadvantages of k-means clustering algorithm

the following are some disadvantages of k-means clustering algorithms −

it is a bit difficult to predict the number of clusters i.e. the value of k.
output is strongly impacted by initial inputs like number of clusters (value of k).
order of data will have strong impact on the final output.
it is very sensitive to rescaling. if we will rescale our data by means of normalization or standardization, then the output will completely change.final output.
it is not good in doing clustering job if the clusters have a complicated geometric shape.

applications of k-means clustering

k-means clustering is a versatile algorithm with various applications in several fields. here we have highlighted some of the important applications −

image segmentation

k-means clustering can be used to segment an image into different regions based on the color or texture of the pixels. this technique is widely used in computer vision applications, such as object recognition, image retrieval, and medical imaging.

customer segmentation

k-means clustering can be used to segment customers into different groups based on their purchasing behavior or demographic characteristics. this technique is widely used in marketing applications, such as customer retention, loyalty programs, and targeted advertising.

anomaly detection

k-means clustering can be used to detect anomalies in a dataset by identifying data points that do not belong to any cluster. this technique is widely used in fraud detection, network intrusion detection, and predictive maintenance.

genomic data analysis

k-means clustering can be used to analyze gene expression data to identify different groups of genes that are co-regulated or co-expressed. this technique is widely used in bioinformatics applications, such as drug discovery, disease diagnosis, and personalized medicine.

Save or share this article