Learning paradigms

1. Intuition

Think about how people learn.

• A student with an answer key checks each practice problem and corrects mistakes. That is supervised learning: examples paired with correct answers (labels).
• Someone sorting a pile of unlabeled photos into piles that "look alike" has no answer key. That is unsupervised learning: find structure without being told what it is.
• A child learns language by hearing sentences and guessing the next word, then hearing the actual word. Nobody wrote labels; the data checks itself. That is self-supervised learning, and it is how large language models are pretrained.
• A student with a few worked examples and a big stack of unanswered problems learns from both. That is semi-supervised learning.
• Learning to ride a bike: no one labels each muscle movement; you get feedback (balance, falling) after sequences of actions. That is reinforcement learning.

2. Visualization

Try it (predict first, then check):

1. Before loading a scenario, decide which paradigm fits fraud detection. Then load it and compare.
2. Change only the first answer (the feedback signal) and watch the recommendation change. Why does the signal matter more than the output type?

3. The math

Symbols

Each paradigm as an objective

Supervised: labeled pairs $\mathcal{D} = \{(x_i, y_i)\}_{i=1}^n$. Minimize average loss.

Regression when $y$ is a number; classification when $y$ is a category.

Unsupervised: inputs only, $\mathcal{D} = \{x_i\}$. Optimize a structural objective instead of agreement with labels, for example K-means' within-cluster distance $\sum_i \lVert x_i - \mu_{c(i)} \rVert^2$, or PCA's retained variance.

Self-supervised: build $(x, y)$ pairs from unlabeled data with a rule. For language, the target at position $t$ is token $t$ and the input is everything before it:

The math is supervised; the labels are free.

Semi-supervised: a small labeled set $\mathcal{D}_L$ plus a large unlabeled set $\mathcal{D}_U$. One simple recipe (self-training): fit on $\mathcal{D}_L$, predict on $\mathcal{D}_U$, add confident predictions as pseudo-labels, refit.

Reinforcement learning: an agent in state $s_t$ takes action $a_t$, receives reward $r_t$, and moves to $s_{t+1}$. Find a policy that maximizes expected discounted return:

Worked example: making self-supervised labels

From the sentence "the model predicts the next token from the previous tokens" (10 words), next-word prediction creates 9 training pairs with no human labeling:

A sentence of $n$ tokens yields $n - 1$ examples. A trillion-token corpus yields about a trillion examples, which is why self-supervision scales so far beyond human labeling.

Worked example: choosing a paradigm

Problem: flag fraudulent card transactions.

1. Decision: block, review, or approve each transaction.
2. Prediction unit: one transaction.
3. Trustworthy target? Yes, but delayed: chargebacks confirm fraud weeks later. About 0.1% are fraud.
4. Information at prediction time: amount, merchant, device, recent account history, but not the chargeback outcome.
5. Metric: precision and recall at a threshold chosen from the cost of a missed fraud versus a blocked good customer; not accuracy (99.9% for "never fraud").
6. Baseline: rules such as "amount > 5× the customer's median."

Choice: supervised classification on confirmed labels, with a time-based split. Add an unsupervised anomaly score as a feature to catch new fraud patterns that have no labels yet.

4. Implementation

Build it from scratch

The point of this build: the same 200 points (two synthetic Gaussian blobs) are handled four ways, and the only thing that changes is the feedback signal. Each learner is a few lines of NumPy.

Supervised. Every row has a label, so we can minimize a loss against it. Logistic regression by gradient descent on log loss: X is $[n, 2]$, a bias column makes it $[n, 3]$, and w is $[3]$.

def fit_logistic(X, y, steps=2000, lr=0.1):
    """Supervised: gradient descent on log loss. X is [n, 2], y is [n] of 0/1."""
    Xb = np.c_[X, np.ones(len(X))]                # add a bias column -> [n, 3]
    w = np.zeros(3)
    for _ in range(steps):
        p = 1 / (1 + np.exp(-Xb @ w))             # predicted P(y = 1)
        w -= lr * Xb.T @ (p - y) / len(y)         # gradient of mean log loss
    return w

Predict: the line w -= lr * Xb.T @ (p - y) ... uses y. Which line would you have to delete if the labels did not exist?

Unsupervised. No y anywhere. K-means optimizes a structural objective (within-cluster distance) by alternating two steps. The [n, k] distance matrix is built by broadcasting [n, 1, 2] against [1, k, 2].

def kmeans(X, k, rng, iters=50):
    """Unsupervised: alternate 'assign each point to nearest centre' and 'move centre to its points' mean'."""
    centres = X[rng.choice(len(X), k, replace=False)]
    for _ in range(iters):
        d = ((X[:, None, :] - centres[None, :, :]) ** 2).sum(axis=2)   # [n, k] squared distances
        assign = d.argmin(axis=1)
        centres = np.array([X[assign == c].mean(axis=0) for c in range(k)])
    return assign, centres

Predict: K-means returns cluster ids 0 and 1. Is cluster 0 guaranteed to be the blob with label 0? How should you compare clusters with labels?

Semi-supervised. Only 6 rows are labeled (-1 marks the rest). Self-training fits on the labeled rows. It then promotes unlabeled rows the model is at least 90% sure about to pseudo-labels, and refits.

def self_train(X, y_partial, threshold=0.9, rounds=10):
    """Semi-supervised: fit on labeled rows, pseudo-label confident unlabeled rows, refit. -1 = unlabeled."""
    y = y_partial.copy()
    for _ in range(rounds):
        known = y != -1
        w = fit_logistic(X[known], y[known])
        p = predict_proba(w, X)
        confident = (~known) & ((p > threshold) | (p < 1 - threshold))
        if not confident.any():
            break
        y[confident] = (p[confident] > 0.5).astype(int)
    return w

Predict: if the first model is confidently wrong on some points, what happens to those mistakes in later rounds?

Self-supervised. The labels come from the data itself: each word's target is the next word. A bigram counter is the smallest "language model" trained this way.

def next_word_pairs(text):
    """Self-supervised: every position becomes a (previous word, next word) example. No human labels."""
    words = text.split()
    return list(zip(words[:-1], words[1:]))

def fit_bigram(pairs):
    counts = defaultdict(Counter)
    for prev, nxt in pairs:
        counts[prev][nxt] += 1
    return {prev: c.most_common(1)[0][0] for prev, c in counts.items()}

Predict: a 33-word text gives how many training pairs? After training, fit_bigram is a supervised model. What made the setup self-supervised?

Use the library

The scikit-learn versions do the same jobs with better solvers (L-BFGS for logistic regression, k-means++ initialization with several restarts for K-means).

from sklearn.cluster import KMeans
from sklearn.linear_model import LogisticRegression
from sklearn.semi_supervised import SelfTrainingClassifier

# Supervised: features and labels
clf = LogisticRegression().fit(X, y)

# Unsupervised: features only
clusters = KMeans(n_clusters=2, n_init=10).fit_predict(X)

# Semi-supervised: -1 marks unlabeled rows
semi = SelfTrainingClassifier(LogisticRegression(), threshold=0.9).fit(X, y_partial)

# Self-supervised: build (context, next-token) pairs from raw text
tokens = text.split()
pairs = [(tokens[:i], tokens[i]) for i in range(1, len(tokens))]

Run it

From guide/:

uv run code/01-ml-vocabulary/paradigms_scratch.py

Key output:

Supervised, 200 labels:            accuracy 0.965
Unsupervised, 0 labels:            clusters match hidden labels 0.970
6 labels, supervised on those 6:   accuracy 0.965
6 labels, self-training on 200:    accuracy 0.975

Self-supervised: 33 words -> 32 (input, target) pairs, e.g. [('the', 'cat'), ('cat', 'sat'), ('sat', 'on')]
Learned next word: sat -> 'on', on -> 'the', cat -> 'sat'

scikit-learn, same data:
  LogisticRegression, 200 labels:  accuracy 0.970
  KMeans, 0 labels:                match 0.970
  SelfTrainingClassifier, 6 labels: accuracy 0.975

All four paradigms land near 97% here, because the two blobs are well separated. That is the honest lesson: when the structure in $X$ already lines up with the labels, few or no labels go a long way. On overlapping classes, clusters and pseudo-labels drift away from the truth, and labels matter much more. (Accuracies are on the same 200 training points, to compare paradigms, not to estimate generalization.) The figure comes from code/01-ml-vocabulary/paradigms.py.

5. Engineering

Labels are the expensive part. Supervised learning is the most predictable paradigm if labels exist and are trustworthy. Ask: who produces the labels, how noisy are they, how delayed, and do they drift? Weak labels (heuristics), active learning (label the most informative examples), and pretrained representations all reduce labeling cost.

Self-supervision as a first stage. Modern practice often pretrains a representation with self-supervision on huge unlabeled data, then adapts it with a small labeled set (fine-tuning) or uses it as-is (embeddings, prompting). That is the LLM recipe.

Reinforcement learning is expensive. It needs an environment or simulator, many interactions, and careful reward design (agents exploit loopholes in rewards). Many "RL problems" are better framed as supervised learning on logged decisions first. In LLMs, RL appears in preference optimization (RLHF), where a reward model is trained on human preference labels.

Paradigms combine. Recommendation systems mix self-supervised embeddings, supervised ranking on clicks, and sometimes RL-style exploration. Anomaly detection is unsupervised until labeled incidents accumulate, then becomes supervised.

Key distinction

A discovered cluster is not a verified category. Unsupervised methods always return structure, even in random data. Treat clusters as hypotheses to validate with domain experts and downstream outcomes.

Watch out

Failure modes. Labels that leak the future (a "was refunded" feature in a fraud model); proxy labels that measure the wrong thing (clicks instead of satisfaction); pseudo-labels that amplify the model's own mistakes in semi-supervised training; reward hacking in RL.

Common mistakes

• Choosing an algorithm before defining the target, the prediction unit, and the metric.
• Calling a problem "unsupervised" when labels could be collected cheaply.
• Evaluating an unsupervised model only by its own objective (inertia), not by usefulness.
• Assuming self-supervised pretraining removes the need for evaluation data. You still need labeled examples to measure the task.

6. Knowledge check

Practice exercise. For each problem, name the paradigm and the feedback signal: (a) predicting tomorrow's electricity demand from past demand and weather; (b) grouping support tickets into topics nobody has defined; (c) training an image model to predict a hidden patch of each image from the visible patches.

Implementation challenge. Using the script's synthetic data, vary the number of labeled points from 2 to 50 and plot accuracy for "train on labeled points only" versus SelfTrainingClassifier. Then make the blobs overlap more (cluster_std=2.5) and see whether self-training still helps.

Summary

• The feedback signal decides the paradigm: labels, no labels, self-made labels, few labels, or rewards.
• Supervised learning minimizes loss against labels; unsupervised optimizes a structural objective; self-supervised manufactures labels from raw data.
• LLMs are pretrained with self-supervision (next-token prediction) and then adapted with supervised and preference-based methods.
• Frame the problem first: decision, prediction unit, trustworthy target, available information, metric, baseline.
• Clusters are hypotheses, not facts.

Next: Workflow, splits, and leakage

Related: K-means · Tokenization and pretraining · The language of ML

Interview angle