Supervised vs Unsupervised Learning: A Clear Comparison

Machine learning is usually split into two families. Supervised learning learns from examples that come with the right answer, called labels, and predicts that answer for new cases. Unsupervised learning gets no answers and looks for structure on its own, such as groups, unusual points or a simpler representation (Google: supervised learning). The definitions are easy. What is less obvious is what labels actually buy you, how to judge unsupervised results when there is no answer key, and what to do when labels exist for only a few examples. The clearest way to see all three is to run both approaches on the same data.

The data: wines from three growers

The wine recognition dataset holds a chemical analysis of 178 wines grown in the same region of Italy by three different cultivators, with thirteen measurements per wine, such as alcohol, flavonoids and colour intensity (scikit-learn: wine recognition dataset). Each wine's grower is known, which lets us use that label for supervised learning and hide it for unsupervised learning.

Supervised: learn from the labels

import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.datasets import load_digits, load_wine
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import adjusted_rand_score, silhouette_score
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.semi_supervised import SelfTrainingClassifier

X, grower = load_wine(return_X_y=True)
print(X.shape, "| wines per grower:", np.bincount(grower).tolist())
supervised = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))
print("supervised accuracy (5-fold CV):", round(cross_val_score(supervised, X, grower, cv=5).mean(), 3))

(178, 13) | wines per grower: [59, 71, 48]
supervised accuracy (5-fold CV): 0.983

Given the labels, a simple logistic regression identifies the grower of wines it has not seen 98.3% of the time. Supervised learning has a clear target and a clear score, which is its great strength: you can measure exactly how well it works.

Unsupervised: find the groups without labels

Now hide the labels and ask k-means to split the wines into groups. Without labels, how many groups is itself a question. The silhouette score measures how well separated the clusters are, using only the data. Because we secretly know the growers, we can also check each clustering against them with the adjusted Rand index (ARI), which is 1 for perfect agreement and near 0 for random grouping (scikit-learn: Rand index):

X_scaled = StandardScaler().fit_transform(X)
for k in (2, 3, 4, 5):
    clusters = KMeans(n_clusters=k, n_init=10, random_state=0).fit_predict(X_scaled)
    print(f"k={k}: silhouette {silhouette_score(X_scaled, clusters):.3f} | agreement with grower (ARI) {adjusted_rand_score(grower, clusters):.3f}")
clusters = KMeans(n_clusters=3, n_init=10, random_state=0).fit_predict(X_scaled)
print(pd.crosstab(pd.Series(grower, name="grower"), pd.Series(clusters, name="cluster")))
unscaled = KMeans(n_clusters=3, n_init=10, random_state=0).fit_predict(X)
print("same clustering without scaling, ARI:", round(adjusted_rand_score(grower, unscaled), 3))

k=2: silhouette 0.268 | agreement with grower (ARI) 0.389
k=3: silhouette 0.285 | agreement with grower (ARI) 0.897
k=4: silhouette 0.246 | agreement with grower (ARI) 0.707
k=5: silhouette 0.203 | agreement with grower (ARI) 0.599
cluster   0   1   2
grower             
0         0   0  59
1        65   3   3
2         0  48   0
same clustering without scaling, ARI: 0.371

Three results stand out:

• The data suggested the right number of groups. The silhouette score, computed without labels, peaks at three clusters, and that is also where agreement with the true growers is highest.
• The clusters rediscover the growers. The cross-table shows only 6 of 178 wines in a cluster dominated by another grower. The cluster numbers are arbitrary; cluster 2 simply corresponds to grower 0.
• Preprocessing decided the outcome. Without scaling, the same algorithm's agreement falls from 0.897 to 0.371, because one measurement on a large scale, proline, accounts for over 99% of the total variance and so dominates the distances. Unsupervised methods are very sensitive to such choices, and there is no label to warn you.

That last point is the heart of the difference. Here the true groups happened to be known, so the clustering could be checked. In real unsupervised work, such as customer segmentation, there is no answer key: you judge clusters by internal scores like the silhouette, by stability across settings and samples, and above all by whether they are meaningful and useful to the people who will act on them. Clustering algorithms compared goes deeper into choosing and judging clusters.

In between: a few labels and lots of unlabelled data

Labels are often expensive: an expert must read each document, inspect each image or review each transaction. Semi-supervised learning uses a small labelled set together with a larger unlabelled one (scikit-learn: semi-supervised learning). Self-training is a simple version: train on the labels, predict the unlabelled examples, add the most confident predictions as new labels, and repeat. On handwritten digits, with only a handful of labels:

X_digits, y_digits = load_digits(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X_digits, y_digits, test_size=0.3, stratify=y_digits, random_state=0)
model = make_pipeline(StandardScaler(), LogisticRegression(max_iter=2000))
rng = np.random.default_rng(0)
for n_labels in (30, 100):
    labelled = rng.choice(len(y_train), n_labels, replace=False)
    only_labelled = model.fit(X_train[labelled], y_train[labelled]).score(X_test, y_test)
    partial = np.full(len(y_train), -1)                 # -1 marks an unlabelled example
    partial[labelled] = y_train[labelled]
    self_trained = SelfTrainingClassifier(model).fit(X_train, partial).score(X_test, y_test)
    print(f"{n_labels} labels: supervised on labelled only {only_labelled:.3f} | self-training with unlabelled too {self_trained:.3f}")
print(f"all {len(y_train)} labels: {model.fit(X_train, y_train).score(X_test, y_test):.3f}")

30 labels: supervised on labelled only 0.737 | self-training with unlabelled too 0.815
100 labels: supervised on labelled only 0.907 | self-training with unlabelled too 0.924
all 1257 labels: 0.972

With 30 labels, adding the unlabelled images lifts accuracy from 73.7% to 81.5%. With 100 labels the gain is smaller, and with all 1,257 labels a plain supervised model reaches 97.2%. Unlabelled data helps most when labels are scarce, but it is no substitute for more labels when you can get them. Self-training can also reinforce its own mistakes, so always check it against a labelled test set, as here.

Choosing between them

The two often work together. Unsupervised methods prepare data for supervised ones, for example by compressing features with PCA, as in dimensionality reduction explained, or by adding a cluster number as a feature. Unsupervised anomaly detection can flag cases for review, whose outcomes then become labels for a supervised model; anomaly detection techniques covers that path.

Supervised models such as regression, trees and SVMs, and unsupervised methods such as k-means, hierarchical clustering and DBSCAN, make up the machine learning modules of the Data Science course.

Sources

• Introduction to Machine Learning: supervised learning (Google) — Google for Developers
• Wine recognition dataset (scikit-learn) — scikit-learn documentation
• Clustering performance evaluation: Rand index (scikit-learn) — scikit-learn documentation
• Semi-supervised learning (scikit-learn) — scikit-learn documentation