Unsupervised learning is a type of machine learning where an algorithm learns patterns from data without being given labeled answers.
Imagine you have information about 1,000 customers.
You know things such as:
But you don't have a column telling you what type of customer each person is.
There might not be a column like:
| Customer | Income | Spending | Customer Type |
|---|---|---|---|
| A | 25,000 | 15,000 | Budget |
| B | 60,000 | 45,000 | Regular |
| C | 90,000 | 80,000 | Premium |
Instead, you give the data to an algorithm and ask it to discover patterns or groups.
It might discover:
Group 1 → Low income + low spending
Group 2 → Medium income + medium spending
Group 3 → High income + high spending
You didn't tell the algorithm that these groups existed.
It discovered them from the data.
That's the basic idea behind unsupervised learning.
One of the easiest ways to understand unsupervised learning is by comparing it with supervised learning.
In supervised learning, we have data with known answers.
Input Data → Known Labels → Machine Learning Model
For example:
House Size + Bedrooms → House Price
The model learns from historical examples where the correct answer is already known.
| House Size | Bedrooms | Price |
|---|---|---|
| 800 sq ft | 2 | $100,000 |
| 1,200 sq ft | 3 | $160,000 |
| 1,800 sq ft | 4 | $240,000 |
The model can then predict the price of a new house.
With unsupervised learning, there is no target label.
Input Data → Algorithm → Hidden Patterns
Customer Data
↓
Machine Learning Algorithm
↓
Discover Groups
↓
Customer Segments
The key difference is:
Supervised learning learns from known answers, while unsupervised learning searches for patterns without known answers.
A simple way to visualize the process is:
flowchart LR
A[Raw Data] --> B[Explore Data]
B --> C[Choose Features]
C --> D[Unsupervised Algorithm]
D --> E[Discover Patterns]
E --> F[Interpret Results]
The algorithm isn't necessarily trying to predict a specific answer.
Instead, it might be trying to answer questions such as:
Real-world datasets aren't always neatly labeled.
Sometimes we have thousands or millions of records but don't know what patterns exist inside them.
Unsupervised learning helps us explore these datasets.
Some common applications include:
Businesses can group customers according to:
This can help businesses create more targeted marketing strategies.
Unsupervised techniques can help identify products, movies, songs, or other items that are similar.
Customer purchases Product A
↓
Find similar customers/products
↓
Recommend Products B and C
Unsupervised algorithms can identify observations that look very different from normal behavior.
For example, a bank could analyze transaction behavior and identify unusual transactions.
Sometimes you don't even know what you're looking for.
Unsupervised learning can help you explore a dataset and discover hidden structures.
There are several important techniques you should understand as a beginner.
The three I recommend learning first are:
Clustering is one of the most common applications of unsupervised learning.
The goal is simple:
Group similar data points together.
Imagine having hundreds of points on a graph.
Before clustering, you might see something like:
• • •
• • • •
• •
• • •
• • • •
• •
• • •
• • • •
• •
The algorithm attempts to identify natural groups within those points.
After clustering:
Cluster A Cluster B Cluster C
• • • • • • •
• • • • • • • • • •
• • • • • •
Some popular clustering algorithms include:
Datasets can contain hundreds or even thousands of features.
Imagine having:
Feature 1
Feature 2
Feature 3
Feature 4
...
Feature 100
Trying to visualize 100 dimensions isn't practical.
Dimensionality reduction attempts to reduce the number of features while preserving important information.
A common technique is Principal Component Analysis (PCA).
flowchart TD
A[100 Features] --> B[PCA]
B --> C[Important Components]
C --> D[2D or 3D Visualization]
Other techniques include:
These techniques are especially useful when exploring complex datasets.
Anomaly detection focuses on finding observations that don't look like the rest of the data.
Imagine most transactions from a customer look like this:
$10
$25
$40
$15
$30
Then suddenly:
$5,000
That transaction might be considered unusual.
Anomaly detection algorithms can help identify observations like this.
Some algorithms include:
Let's make things more practical.
Suppose a company has customer data containing:
Our goal is to discover whether customers naturally form different groups.
We can use K-Means clustering.
Our dataset might look something like this:
| Customer | Annual Income | Annual Spending |
|---|---|---|
| A | 25,000 | 15,000 |
| B | 30,000 | 20,000 |
| C | 35,000 | 18,000 |
| D | 60,000 | 45,000 |
| E | 65,000 | 50,000 |
| F | 80,000 | 75,000 |
We can visualize this data using a scatter plot.
The x-axis represents income, while the y-axis represents spending.
Once K-Means is applied, the algorithm may discover three different groups.
K-Means is easier to understand when broken down into steps.
Suppose we want to create 3 clusters.
We tell the algorithm:
n_clusters = 3
The algorithm then roughly follows this process.
We decide how many clusters we want.
K = 3
The algorithm selects initial cluster centers called centroids.
X
Centroid
Each data point is assigned to the closest centroid.
Data Point → Closest Centroid
The algorithm calculates new centers based on the assigned data points.
The assignment and centroid calculation process continues until the clusters stabilize.
The basic process looks like this:
flowchart TD
A[Choose K] --> B[Initialize Centroids]
B --> C[Assign Points to Closest Centroid]
C --> D[Recalculate Centroids]
D --> E{Clusters Stable?}
E -->|No| C
E -->|Yes| F[Final Clusters]
Now let's put the concept into practice.
We'll use:
Install them with:
pip install pandas matplotlib scikit-learn
Then import the libraries:
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
Let's assume we have a file called:
customer_data.csv
We can load it using Pandas:
data = pd.read_csv("customer_data.csv")
print(data.head())
For this example, we'll use:
X = data[
["Annual Income", "Annual Spending"]
]
These are the features we want the algorithm to use when creating clusters.
Let's create three clusters:
kmeans = KMeans(
n_clusters=3,
random_state=42
)
Then train the model:
kmeans.fit(X)
We can obtain the cluster assigned to each customer:
data["Cluster"] = kmeans.labels_
Now each customer has a cluster number.
| Customer | Income | Spending | Cluster |
|---|---|---|---|
| A | 25,000 | 15,000 | 0 |
| B | 30,000 | 20,000 | 0 |
| C | 60,000 | 45,000 | 1 |
| D | 65,000 | 50,000 | 1 |
| E | 80,000 | 75,000 | 2 |
Remember:
Cluster 0, 1, and 2 don't automatically mean "bad", "average", and "good".
They are simply labels assigned by the algorithm.
We need to interpret what each cluster represents.
Visualization is one of the most useful parts of machine learning because it allows us to see what the algorithm discovered.
We can create a scatter plot:
plt.scatter(
X["Annual Income"],
X["Annual Spending"],
c=data["Cluster"]
)
plt.xlabel("Annual Income")
plt.ylabel("Annual Spending")
plt.title("Customer Segmentation Using K-Means")
plt.show()
The resulting visualization allows us to see how customers have been grouped.
A simplified representation looks like:
Annual Spending
↑
|
● ● ● Cluster 3
● ● ● ●
|
● ● ●
● ● ● Cluster 2
|
● ● ●
● ● ● Cluster 1
|
+------------------------→ Annual Income
The visualization makes the concept much easier to understand:
Customers that are closer together tend to belong to the same cluster.
K-Means relies heavily on the concept of distance.
A common distance measure is Euclidean distance.
For two points:
A = (x₁, y₁)
B = (x₂, y₂)
The Euclidean distance is:
distance = √((x₂ - x₁)² + (y₂ - y₁)²)
You don't need to memorize the mathematics immediately.
The important idea is:
K-Means uses distance to determine which data points are closest to each centroid.
This is one of the most important questions when working with K-Means.
We can't always simply guess:
n_clusters=3
So how do we choose K?
One popular approach is the Elbow Method.
The basic idea is to test different values of K and measure how well the clusters fit the data.
We can calculate the inertia for different values of K:
inertia = []
for k in range(1, 11):
model = KMeans(
n_clusters=k,
random_state=42
)
model.fit(X)
inertia.append(model.inertia_)
Then visualize the results:
plt.plot(
range(1, 11),
inertia,
marker="o"
)
plt.xlabel("Number of Clusters")
plt.ylabel("Inertia")
plt.title("Elbow Method")
plt.show()
(https://miro.medium.com/0*aY163H0kOrBO46S-.png)
You may see a graph where the improvement becomes much smaller after a certain point.
That bend is called the elbow.
The elbow can help us choose a reasonable number of clusters.
However, it isn't a magic rule.
Domain knowledge and other evaluation techniques can also be important.
K-Means is powerful, but it isn't perfect.
There are several things beginners should be aware of.
K-Means requires you to specify the number of clusters.
KMeans(n_clusters=3)
Choosing the wrong K can produce misleading groups.
Suppose one feature ranges from:
1–10
while another ranges from:
1–1,000,000
The larger-scale feature can dominate distance calculations.
This is why feature scaling is often important.
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
Then:
kmeans.fit(X_scaled)
The algorithm gives you:
Cluster 0
Cluster 1
Cluster 2
But the numbers themselves don't explain what the groups mean.
As a data analyst, you still need to investigate the characteristics of each cluster.
Cluster 0
→ Lower income
→ Lower spending
Cluster 1
→ Medium income
→ Medium spending
Cluster 2
→ Higher income
→ Higher spending
This is where data analysis and domain knowledge become extremely important.
Unsupervised learning appears in many different industries.
If you're learning unsupervised learning, one of the best projects you can build is a:
Your workflow could look like this:
flowchart LR
A[Find Dataset] --> B[Clean Data]
B --> C[Explore Data]
C --> D[Select Features]
D --> E[Scale Features]
E --> F[Apply K-Means]
F --> G[Choose K]
G --> H[Visualize Clusters]
H --> I[Interpret Results]
I --> J[Write Business Insights]
You could investigate questions such as:
This transforms machine learning from just writing Python code into actual data-driven problem solving.
Unsupervised learning is a powerful part of machine learning because it allows us to discover patterns, relationships, and structures hidden within data even when we don't have predefined labels.
The most important lesson is that machine learning isn't always about predicting a known outcome. Sometimes, the goal is simply to understand the data and discover what it is telling us.