Machine Learning (ML) and its core paradigms, problems, methods, foundations, an

Dashboard/Study Pack•Learning Mode

Summary

Machine learning (ML) studies statistical algorithms that learn from data and generalize to unseen inputs without explicit programming. This matters because it turns experience into performance on tasks, and it sets up the central goal: prediction that works beyond the training set. ML’s purpose connects directly to how we choose data, models, and evaluation. From this foundation, ML is organized into paradigms. Supervised learning learns mappings from inputs to labeled outputs, enabling classification or regression; it matters because labels define the target and guide optimization. Unsupervised learning finds structure in unlabeled data via clustering or dimensionality reduction; it matters because it reveals patterns and compact representations when labels are missing. Self-supervised learning creates supervisory signals from the data itself; it matters because it enables representation learning at scale. Reinforcement learning trains agents to maximize long-term reward through interaction; it matters because it addresses sequential decision-making rather than static prediction. These paradigms lead to problem types, including classification, regression, and broader settings like structured prediction and multimodal learning. Structured prediction uses probabilistic graphical models such as Bayesian networks, conditional random fields, and hidden Markov models; it matters because outputs have internal structure, so naive independent predictions fail. Neural networks and deep learning architectures (CNNs, RNNs with LSTM/GRU, autoencoders, transformers) connect to many paradigms by learning hierarchical representations, often outperforming earlier methods. To trust models, diagnostics such as confusion matrices and ROC curves (for classification) and learning curves (for training dynamics) matter because they expose threshold behavior and generalization gaps. Finally, mathematical foundations explain why methods work: empirical risk minimization (ERM) and PAC learning formalize learning from data, while bias–variance tradeoff and kernel machines clarify generalization limits. A deeper connection links prediction to data compression: if a model predicts posterior probabilities, it can enable optimal compression, and conversely compression can induce predictive structure.

Topics Covered

ML Definition, Purpose, and Generalization

Machine learning studies statistical algorithms that learn from data and generalize to unseen data without explicit programming. This purpose links directly to how we choose paradigms, formulate problems, and evaluate success. The idea of generalization becomes concrete later through diagnostics and through mathematical foundations like ERM and PAC.

Learning Paradigms and How They Shape Problem Formulation

ML paradigms include supervised, unsupervised, self-supervised, and reinforcement learning, each creating different training signals. Paradigm choice determines what labels exist, what the model optimizes, and what “learning” means operationally. This topic connects to problem types (classification, regression, etc.) and to method families like supervised models, clustering, and RL agents.

Problem Types: From Classification and Regression to Multimodal Learning

Problem types specify the target structure: classification predicts discrete categories, regression predicts continuous values, and broader settings include multimodal learning. These choices determine model outputs, loss functions, and evaluation tools. Later topics on supervised methods, unsupervised methods, and structured prediction all depend on understanding what kind of output is required.

Supervised Learning Methods and Practical Diagnostics

Supervised learning methods include linear models, decision trees, ensembles, SVM, and neural networks, all trained using labeled data. Kernel machines and bias–variance tradeoff explain why different supervised methods generalize differently. Model diagnostics such as confusion matrices and ROC curves connect directly to classification thresholds and performance tradeoffs.

Unsupervised and Self-supervised Learning for Structure and Representations

Unsupervised learning discovers structure in unlabeled data via clustering (k-means, hierarchical clustering, DBSCAN, OPTICS) and dimensionality reduction (PCA, t-SNE, factor analysis). Self-supervised learning creates supervisory signals from the data itself to learn useful representations, often with transformers. This topic connects to later neural architectures and to the data compression connection through learned feature spaces.

Neural Networks and Deep Learning Architectures as Representation Learners

Neural networks learn hierarchical representations using architectures such as CNNs, RNNs (LSTM/GRU), autoencoders, and transformers. Deep learning is a subset of ML, so it inherits the same generalization goals and evaluation needs. This topic connects to supervised learning methods, self-supervised representation learning, and reinforcement learning when neural policies are trained.

Structured Prediction and Probabilistic Graphical Models

Structured prediction targets outputs with dependencies, using probabilistic graphical models like Bayesian networks, conditional random fields, and hidden Markov models. These models emphasize inference over structured outputs rather than independent predictions. This topic connects to supervised learning problem types, and to probabilistic thinking that also underlies anomaly detection and density estimation.

Anomaly Detection, Reinforcement Learning, and Learning with Feedback

Anomaly detection identifies rare or unlikely patterns, often framed probabilistically as low-likelihood events or deviations from learned structure. Reinforcement learning trains agents to maximize long-term reward through interaction, not just immediate outcomes, using methods like Q-learning and policy gradients. This topic connects to diagnostics and to the broader idea of learning signals created by the environment or by data itself.

Mathematical Foundations: ERM, PAC, Bias–Variance, Kernels, and Compression

Mathematical foundations include ERM and PAC learning for learning guarantees, the bias–variance tradeoff for generalization behavior, and kernel machines for implicit feature spaces. These ideas connect directly to supervised method choices and to how diagnostics reflect generalization. Finally, the data compression connection links prediction of posterior probabilities to optimal compression, tying learning to information-theoretic efficiency.

Key Insights

Compression equals prediction loop

The content implies a two-way equivalence: if you can predict posterior probabilities for sequences, you can compress them optimally, and if you have an optimal compressor, you can use it to predict future symbols. This means “learning” can be reframed as building a model that makes the data maximally compressible, not merely one that minimizes prediction error on labeled tasks.

Why it matters: Students often treat compression as a separate engineering topic; this reframing unifies representation learning, probabilistic modeling, and generalization under one objective: better probability estimates.

Unsupervised can still be judged

Although unsupervised learning is described as using unlabeled data, the text’s evaluation emphasis (via diagnostics like confusion matrices and ROC curves) implies that evaluation is about the downstream goal, not about whether labels were used during training. In other words, unsupervised methods can be evaluated by how well their discovered structure supports prediction, retrieval, anomaly detection, or compression.

Why it matters: This challenges the common confusion that “unsupervised means no evaluation,” pushing students to think in terms of measurable outcomes tied to the problem type.

Deep learning’s advantage is representation

The cause-effect chain states that deep learning improves performance because neural networks learn better representations that generalize. The non-obvious implication is that the “model class” matters less than the learned feature space: many classical methods could work better if given the same representation quality, while deep learning’s core contribution is representation learning.

Why it matters: Students may attribute gains to architecture alone; this insight shifts attention to the representation bottleneck and explains why self-supervised learning and transformers often matter even before labels exist.

Diagnostics reveal threshold behavior

The diagnostics list (confusion matrix, ROC curve) implies that evaluation is not just “accuracy,” but also how decisions change with thresholds. Combining this with the supervised learning framing suggests that the same trained model can yield different operational behaviors depending on the chosen threshold, so model diagnostics are effectively tools for selecting a decision policy.

Why it matters: This helps students stop treating evaluation as a single number and instead understand how to tune tradeoffs between false positives and false negatives for real-world costs.

Clustering can be a predictor

The text notes k-means can compress data by replacing points with centroids, and it also frames prediction as using learned probabilities. The implied connection is that clustering can serve as a probabilistic or predictive mechanism: once data are mapped to cluster representatives, you can predict by using cluster identity or centroid-based likelihoods, turning “unsupervised structure” into a downstream predictive model.

Why it matters: Students often see clustering as purely exploratory; this insight shows how unsupervised methods can become components of prediction systems through compact, structured representations.

Conclusions

Bringing It All Together

Machine Learning Definition and Purpose connects to Machine Learning Paradigms, because every approach aims to generalize from data to unseen cases using supervised, unsupervised, self-supervised, or reinforcement interaction. Those paradigms determine the Machine Learning Problem Types, which then select appropriate method families: Supervised Learning Methods for labeled prediction, Unsupervised Learning Methods for structure discovery, and Neural Networks and Deep Learning Architectures for representation learning across many modalities. Model Diagnostics then ties back to the problem type and method choice by showing how performance tradeoffs appear in tools like confusion matrices and ROC curves, while Mathematical Foundations (ERM, PAC, VC, Bias–Variance, Kernels) explain why generalization succeeds or fails. Structured Prediction and Probabilistic Graphical Models extend the same learning-and-generalization goal to outputs with internal structure, using probabilistic inference rather than independent predictions. Finally, the Data Compression Connection unifies learning with information-theoretic thinking: if a model predicts posterior probabilities well, it can support efficient compression, and conversely compression can imply strong predictive structure.

Key Takeaways

Machine Learning Definition and Purpose: learning algorithms generalize from data to unseen inputs without explicit programming, and this goal drives everything else.
Machine Learning Paradigms and Problem Types: supervised, unsupervised, self-supervised, and reinforcement learning correspond to different kinds of targets and supervision signals, which determine the method family.
Method families and architectures: Supervised Learning Methods and Unsupervised Learning Methods solve different tasks, while Neural Networks and Deep Learning Architectures provide powerful representation learning that works across many problem types.
Model Diagnostics and Mathematical Foundations: diagnostics (confusion matrix, ROC curve, learning curves) reveal real performance behavior, while ERM, PAC, VC, Bias–Variance, and kernels explain generalization limits and guide model selection.
Advanced unification: Structured Prediction and Probabilistic Graphical Models handle structured outputs via probabilistic inference, and the Data Compression Connection links prediction quality to optimal compression.

Real-World Applications

Using supervised learning with decision trees, ensembles, k-NN, linear models, SVM, or neural networks to classify or regress from labeled data, then validating with confusion matrices and ROC curves to choose decision thresholds.
Applying unsupervised learning like k-means or PCA to compress and summarize datasets for faster storage, transmission, and exploratory analysis by replacing groups with centroids or lower-dimensional representations.
Employing deep neural architectures such as CNNs, RNNs (LSTM/GRU), autoencoders, and transformers to learn representations that improve performance on vision, sequence, and multimodal tasks.
Leveraging reinforcement learning in interactive domains where an agent must maximize long-term reward, such as game playing or control problems, rather than optimizing only immediate outcomes.

Next, the student should deepen Mathematical Foundations by working through ERM and PAC learning intuition, then connect that to practical generalization control via the Bias–Variance tradeoff and kernel methods. After that, they should study Model Diagnostics more formally (how ROC and learning curves reflect thresholding and overfitting), and then extend to Structured Prediction with probabilistic graphical models to learn how inference produces structured outputs. Finally, they should explore the Data Compression Connection by relating predicted probability distributions to coding efficiency, using it as a bridge between representation learning and information-theoretic optimality.

💻 Code Examples

Supervised Learning: Logistic Regression for Classification with a Confusion Matrix

python

Code

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, roc_curve, auc

# Reproducibility: fixed random seed
rng = np.random.default_rng(42)

# Synthetic binary classification data (features resemble tabular ML)
# Class 1 tends to have larger values in feature 0
n = 600
X = rng.normal(size=(n, 2))
logit = 2.0 * X[:, 0] - 0.5 * X[:, 1]
prob = 1 / (1 + np.exp(-logit))
y = (rng.random(n) < prob).astype(int)

# Train/test split (typical supervised learning workflow)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=7, stratify=y
)

# Logistic regression is listed in the content under supervised learning
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

# Predict class labels and compute confusion matrix
y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
print("Confusion matrix:\n", cm)

# ROC curve uses predicted probabilities (model diagnostics concept)
# roc_curve is explicitly part of the diagnostics list
scores = model.predict_proba(X_test)[:, 1]
fpr, tpr, _ = roc_curve(y_test, scores)
roc_auc = auc(fpr, tpr)
print(f"ROC AUC: {roc_auc:.3f}")

# Small sanity check: show a few predictions
for i in range(5):
    print("true=", y_test[i], "pred=", y_pred[i], "score=", round(scores[i], 3))

Explanation

This example demonstrates supervised learning for classification using logistic regression, which is explicitly listed in the content. It trains on a synthetic dataset, then evaluates with a confusion matrix (a model diagnostic concept from the document). It also computes an ROC curve and ROC AUC using predicted probabilities, connecting to the diagnostics section. The key idea is that classification quality is not just accuracy: the confusion matrix shows error types, while ROC/AUC shows how well the model ranks positives across thresholds. This mirrors how ML systems are evaluated in practice.

Use Case

A fraud or churn screening system can use logistic regression to classify customers or transactions, while confusion matrices help quantify false positives versus false negatives. ROC AUC supports threshold selection for operational risk tolerance.

Output

Confusion matrix:
[[... ...]
 [... ...]]
ROC AUC: 0.9xx
true=0 pred=0 score=0.xxx ...

💻 Code Practice Problems

Problem 1: Create a supervised binary classification experiment using l...medium

Create a supervised binary classification experiment using logistic regression on synthetic data. Generate a dataset where class 1 is more likely when feature 0 is large and feature 1 is small. Split into train and test with stratification. Train a LogisticRegression model. Then compute and print: (1) the confusion matrix, (2) ROC AUC using predicted probabilities, and (3) the first 5 rows of (true label, predicted label, predicted probability for class 1). Use fixed random seeds for reproducibility.

💡 Show Hints (3)

• Use train_test_split with stratify=y to preserve class balance across splits.
• For ROC AUC, use model.predict_proba(X_test)[:, 1] as the score input to roc_curve and auc.
• Make sure you print the confusion matrix with the correct order: confusion_matrix(y_test, y_pred).

✓ Reveal Solution

Solution Code:

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, roc_curve, auc

# Reproducibility
rng = np.random.default_rng(123)

# Synthetic binary classification data
n = 800
X = rng.normal(size=(n, 2))
# Class 1 probability increases with X[:, 0] and decreases with X[:, 1]
logit = 1.5 * X[:, 0] - 1.0 * X[:, 1] + 0.2
prob = 1 / (1 + np.exp(-logit))
y = (rng.random(n) < prob).astype(int)

# Train/test split with stratification
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=21, stratify=y
)

# Train logistic regression
model = LogisticRegression(max_iter=300)
model.fit(X_train, y_train)

# Predictions and confusion matrix
y_pred = model.predict(X_test)
cm = confusion_matrix(y_test, y_pred)
print("Confusion matrix:\n", cm)

# ROC curve and ROC AUC using predicted probabilities
scores = model.predict_proba(X_test)[:, 1]
fpr, tpr, _ = roc_curve(y_test, scores)
roc_auc = auc(fpr, tpr)
print(f"ROC AUC: {roc_auc:.3f}")

# Show a few predictions
for i in range(5):
    print("true=", int(y_test[i]), "pred=", int(y_pred[i]), "score=", round(float(scores[i]), 3))

Expected Output:

The program prints three sections: (1) a 2x2 confusion matrix, (2) a single line "ROC AUC: <value>" with value rounded to 3 decimals, and (3) five lines of the form "true= <0 or 1> pred= <0 or 1> score= <probability>". Exact numeric values depend on the fixed seeds but will be deterministic for the given code.

The code synthesizes a binary classification dataset by converting a linear logit score into probabilities using the logistic (sigmoid) function. It then samples labels from those probabilities. A stratified train/test split ensures the class distribution remains similar in both sets. Logistic regression is trained on the training data. The confusion matrix summarizes classification errors by counting true positives, false positives, true negatives, and false negatives. For ROC AUC, the model’s predicted probability for class 1 is used as a ranking score across thresholds; roc_curve computes the tradeoff between false positive rate and true positive rate, and auc summarizes the overall ranking quality. Finally, the first 5 predictions are printed to sanity-check alignment between true labels, predicted labels, and probability scores.

Problem 2: Advanced supervised classification diagnostics. Generate a s...hard

Advanced supervised classification diagnostics. Generate a synthetic binary dataset with a controllable class imbalance by using a tunable intercept term in the logistic model. Train logistic regression on a stratified train/test split. Then do the following: (1) compute the confusion matrix at the default decision threshold (0.5), (2) compute ROC AUC using predicted probabilities, (3) choose an operating threshold that achieves at least a target True Positive Rate (TPR) on the test set, and (4) recompute the confusion matrix using that chosen threshold. Print both confusion matrices, both TPR values, and the chosen threshold. Use fixed random seeds. Target TPR should be 0.80.

💡 Show Hints (3)

• ROC curve outputs arrays of fpr and tpr across many thresholds; you can select a threshold where tpr >= target.
• To apply a custom threshold, convert probabilities into predicted labels using (scores >= threshold).astype(int).
• Be careful: roc_curve returns thresholds aligned with tpr/fpr points; you must index thresholds consistently.

✓ Reveal Solution

Solution Code:

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, roc_curve, auc

# Reproducibility
rng = np.random.default_rng(999)

# Synthetic data with controllable imbalance via intercept
n = 1200
X = rng.normal(size=(n, 2))

# Intercept controls base rate (class imbalance)
intercept = -0.6
logit = 2.2 * X[:, 0] - 1.3 * X[:, 1] + intercept
prob = 1 / (1 + np.exp(-logit))
y = (rng.random(n) < prob).astype(int)

# Stratified split to keep imbalance consistent
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=33, stratify=y
)

# Train model
model = LogisticRegression(max_iter=500)
model.fit(X_train, y_train)

# Scores and default-threshold predictions
scores = model.predict_proba(X_test)[:, 1]

# Default threshold 0.5
threshold_default = 0.5
y_pred_default = (scores >= threshold_default).astype(int)
cm_default = confusion_matrix(y_test, y_pred_default)

# ROC diagnostics
fpr, tpr, thresholds = roc_curve(y_test, scores)
roc_auc = auc(fpr, tpr)

# Choose threshold to achieve at least target TPR
target_tpr = 0.80
idx_candidates = np.where(tpr >= target_tpr)[0]
if len(idx_candidates) == 0:
    # If target is unattainable, fall back to the best available TPR
    idx = int(np.argmax(tpr))
else:
    # Prefer the highest threshold among those meeting target TPR
    # (typically yields fewer false positives while keeping TPR >= target)
    idx = int(idx_candidates.max())

threshold_chosen = float(thresholds[idx])

# Recompute predictions using chosen threshold
y_pred_chosen = (scores >= threshold_chosen).astype(int)
cm_chosen = confusion_matrix(y_test, y_pred_chosen)

# Compute realized TPR from confusion matrices
# TPR = TP / (TP + FN)
TP_default = int(cm_default[1, 1])
FN_default = int(cm_default[1, 0])
TP_chosen = int(cm_chosen[1, 1])
FN_chosen = int(cm_chosen[1, 0])

tpr_default_realized = TP_default / (TP_default + FN_default) if (TP_default + FN_default) > 0 else 0.0
tpr_chosen_realized = TP_chosen / (TP_chosen + FN_chosen) if (TP_chosen + FN_chosen) > 0 else 0.0

print("ROC AUC:", round(float(roc_auc), 3))
print("Default threshold:", threshold_default)
print("Confusion matrix (default):\n", cm_default)
print("Realized TPR (default):", round(float(tpr_default_realized), 3))

print("Target TPR:", target_tpr)
print("Chosen threshold:", round(float(threshold_chosen), 6))
print("Confusion matrix (chosen):\n", cm_chosen)
print("Realized TPR (chosen):", round(float(tpr_chosen_realized), 3))

Expected Output:

The program prints: (1) a line "ROC AUC: <value>" rounded to 3 decimals, (2) the default threshold (0.5), (3) the default confusion matrix (2x2), (4) the realized TPR for the default threshold, (5) the target TPR (0.8), (6) the chosen threshold (a numeric value), (7) the chosen-threshold confusion matrix (2x2), and (8) the realized TPR for the chosen threshold. Exact matrices and thresholds are deterministic given the fixed seeds but will be specific numeric values.

The dataset is generated similarly to logistic regression classification, but an intercept term is added to control class imbalance. After stratified splitting, logistic regression is trained. Predicted probabilities for class 1 are used to compute a confusion matrix at the default threshold 0.5. Next, roc_curve computes TPR and FPR across many thresholds, and auc summarizes the overall ranking quality. To meet a target TPR of 0.80, the code selects a threshold from the ROC thresholds where tpr >= target_tpr. If the target is unattainable, it selects the threshold that yields the maximum achievable TPR. Finally, it applies the chosen threshold to convert probabilities into class predictions and recomputes the confusion matrix and realized TPR from that confusion matrix.

Unsupervised Learning: k-means Clustering for Data Reduction (Compression-like Summaries)

python

Code

import numpy as np
from sklearn.cluster import KMeans

# Synthetic dataset: points form several blobs (no labels)
rng = np.random.default_rng(0)
centers = np.array([[0, 0], [4, 0], [2, 3.5]])
counts = [250, 220, 180]
X = np.vstack([
    rng.normal(loc=c, scale=0.6, size=(m, 2))
    for c, m in zip(centers, counts)
])

# k-means is explicitly listed under clustering
k = 3
kmeans = KMeans(n_clusters=k, n_init=10, random_state=1)
kmeans.fit(X)

# Assign each point to a cluster
labels = kmeans.labels_

# Data reduction idea: replace each point by its centroid
centroids = kmeans.cluster_centers_
X_reduced = centroids[labels]

# Quantify distortion (mean squared error after reduction)
mse = np.mean((X - X_reduced) ** 2)
print("Centroids:\n", np.round(centroids, 3))
print("Cluster sizes:", np.bincount(labels))
print(f"Reduction MSE: {mse:.4f}")

# Show a small sample of original vs reduced coordinates
for i in range(6):
    print("orig=", np.round(X[i], 2), "reduced=", np.round(X_reduced[i], 2))

Explanation

This example builds on the document’s clustering and compression connection: k-means groups similar points and represents each group by its centroid. It generates unlabeled blob data, fits KMeans with k clusters, then performs “data reduction” by mapping each point to its centroid. The reduction MSE measures how much information is lost when compressing/summarizing. This directly reflects the content’s explanation that k-means can condense extensive datasets into representative points, especially for image and signal processing.

Use Case

In an image or sensor pipeline, you can compress large point clouds by clustering and storing only centroid summaries, reducing storage and speeding up downstream processing.

Output

Centroids:
[[... ...]
 [... ...]
 [... ...]]
Cluster sizes: [250 220 180]
Reduction MSE: 0.3xxx
orig= [...] reduced= [...]

💻 Code Practice Problems

Problem 1: Create a synthetic 2D dataset made of several unlabeled Gaus...medium

Create a synthetic 2D dataset made of several unlabeled Gaussian blobs. Use k-means clustering to perform centroid-based data reduction. Then evaluate reduction quality using mean squared error (MSE) and also report the within-cluster sum of squares (WCSS) computed from the centroids and assignments. Requirements: (1) Generate data with a fixed random seed. (2) Fit KMeans with a specified k. (3) Reduce each point to its assigned centroid. (4) Compute MSE = mean((X - X_reduced)^2). (5) Compute WCSS = sum over points of squared distance to its centroid. (6) Print centroids (rounded), cluster sizes, MSE, and WCSS. (7) Print a small sample of 5 original vs reduced coordinates.

💡 Show Hints (3)

• Use KMeans(n_clusters=k, n_init=..., random_state=...) and then use labels to index centroids: X_reduced = centroids[labels].
• WCSS can be computed as np.sum((X - X_reduced) ** 2). MSE is that value divided by the total number of elements, or compute directly with np.mean((X - X_reduced) ** 2).
• Be careful that X is shape (n_samples, n_features); MSE should average over all elements, not just over samples.

✓ Reveal Solution

Solution Code:

import numpy as np
from sklearn.cluster import KMeans

# Reproducible synthetic unlabeled data (Gaussian blobs)
rng = np.random.default_rng(42)
centers = np.array([[0.0, 0.0], [3.5, 0.0], [1.5, 3.0]])
counts = [200, 160, 140]
scales = [0.5, 0.7, 0.4]

X = np.vstack([
    rng.normal(loc=c, scale=s, size=(m, 2))
    for c, m, s in zip(centers, counts, scales)
])

k = 3
kmeans = KMeans(n_clusters=k, n_init=10, random_state=7)
kmeans.fit(X)

labels = kmeans.labels_
centroids = kmeans.cluster_centers_

# Centroid-based reduction
X_reduced = centroids[labels]

# Metrics
mse = np.mean((X - X_reduced) ** 2)
wcss = np.sum((X - X_reduced) ** 2)

print("Centroids:\n", np.round(centroids, 3))
print("Cluster sizes:", np.bincount(labels))
print(f"Reduction MSE: {mse:.4f}")
print(f"WCSS: {wcss:.2f}")

for i in range(5):
    print("orig=", np.round(X[i], 2), "reduced=", np.round(X_reduced[i], 2))

Expected Output:

The program prints centroids (3x2 array), cluster sizes (length 3), Reduction MSE, WCSS, and 5 lines of original vs reduced coordinates. Exact numeric values depend on the fixed random seeds and should match deterministically for the provided code.

The code generates unlabeled 2D points by sampling from multiple Gaussian blobs. KMeans groups points into k clusters and learns a centroid for each cluster. Data reduction is performed by replacing each point with the centroid of its assigned cluster (X_reduced = centroids[labels]). The reduction MSE measures average squared reconstruction error across all coordinates. WCSS is the total squared distance from each point to its assigned centroid, computed as the sum of squared errors. Printing centroids and cluster sizes helps verify that clustering found meaningful groups; the sample pairs show how points are approximated by centroids.

Problem 2: Build a small compression experiment using k-means clusterin...hard

Build a small compression experiment using k-means clustering with a model-selection loop. You must: (1) Generate an unlabeled 2D dataset from multiple Gaussian blobs with fixed random seed. (2) Split the dataset into a training set and a test set using a fixed random permutation. (3) For each k in a provided list (e.g., [2, 3, 4, 5, 6]), fit KMeans on the training set only. (4) Reduce both training and test points by mapping each point to the nearest learned centroid (using the fitted centroids and the assignments for training; for test, compute nearest centroid explicitly). (5) Compute and print train MSE and test MSE for each k. (6) Choose the k with the lowest test MSE and print the selected k and its centroids. Additional condition: You must implement test reduction without calling kmeans.predict directly; instead, compute distances from test points to centroids and take argmin. (7) Print a small sample of 3 original vs reduced test points for the selected k.

💡 Show Hints (3)

• For test reduction without predict: compute squared distances D = sum((X_test[:, None, :] - centroids[None, :, :])**2, axis=2) and take labels_test = argmin(D, axis=1).
• Train MSE uses X_train and X_train_reduced; test MSE uses X_test and X_test_reduced. Ensure you reduce test points using centroids learned from training.
• When comparing k values, select by minimum test MSE, not training MSE.

✓ Reveal Solution

Solution Code:

import numpy as np
from sklearn.cluster import KMeans

# Fixed random seed for reproducibility
rng = np.random.default_rng(123)

# Synthetic unlabeled dataset (Gaussian blobs)
true_centers = np.array([[0.0, 0.0], [4.0, 0.0], [2.0, 3.5], [-1.5, 3.0]])
true_counts = [220, 200, 180, 160]
true_scales = [0.55, 0.6, 0.5, 0.45]

X = np.vstack([
    rng.normal(loc=c, scale=s, size=(m, 2))
    for c, m, s in zip(true_centers, true_counts, true_scales)
])

# Train-test split using fixed permutation
n = X.shape[0]
perm = rng.permutation(n)
train_size = int(0.8 * n)
train_idx = perm[:train_size]
test_idx = perm[train_size:]

X_train = X[train_idx]
X_test = X[test_idx]

k_list = [2, 3, 4, 5, 6]

results = []

for k in k_list:
    model = KMeans(n_clusters=k, n_init=10, random_state=10)
    model.fit(X_train)

    centroids = model.cluster_centers_

    # Train reduction using learned assignments
    train_labels = model.labels_
    X_train_reduced = centroids[train_labels]

    # Test reduction WITHOUT calling model.predict
    # Compute squared distances from each test point to each centroid
    # Shape: (n_test, k)
    diff = X_test[:, None, :] - centroids[None, :, :]
    dist2 = np.sum(diff ** 2, axis=2)
    test_labels = np.argmin(dist2, axis=1)
    X_test_reduced = centroids[test_labels]

    train_mse = np.mean((X_train - X_train_reduced) ** 2)
    test_mse = np.mean((X_test - X_test_reduced) ** 2)

    results.append((k, train_mse, test_mse))

    print(f"k={k}: train MSE={train_mse:.4f}, test MSE={test_mse:.4f}")

# Select k with lowest test MSE
best_k, best_train_mse, best_test_mse = min(results, key=lambda t: t[2])

# Refit best model to get final centroids
best_model = KMeans(n_clusters=best_k, n_init=10, random_state=10)
best_model.fit(X_train)
best_centroids = best_model.cluster_centers_

# Reduce test points for sample printing
best_diff = X_test[:, None, :] - best_centroids[None, :, :]
best_dist2 = np.sum(best_diff ** 2, axis=2)
best_test_labels = np.argmin(best_dist2, axis=1)
best_X_test_reduced = best_centroids[best_test_labels]

print("\nSelected k:", best_k)
print(f"Best train MSE: {best_train_mse:.4f}")
print(f"Best test MSE: {best_test_mse:.4f}")
print("Best centroids:\n", np.round(best_centroids, 3))

for i in range(3):
    print("test orig=", np.round(X_test[i], 2), "reduced=", np.round(best_X_test_reduced[i], 2))

Expected Output:

The program prints one line per k showing train MSE and test MSE, then prints the selected k with best train/test MSE, prints the best centroids (rounded), and prints 3 lines of test original vs reduced coordinates. Exact numeric values should match deterministically for the provided code and seeds.

This code performs a compression-like experiment where k-means centroids act as a codebook. For each candidate k, the model is trained only on the training set. Training reduction uses the model’s assignments, while test reduction is done manually by computing squared distances from each test point to each learned centroid and choosing the nearest centroid (argmin). MSE quantifies reconstruction error after centroid-based summarization. The best k is selected using the lowest test MSE to avoid overfitting to the training data. Finally, the code prints the selected k, its centroids, and a small sample showing how test points are approximated.

Structured Prediction: Viterbi Decoding with a Hidden Markov Model

python

Code

import numpy as np

# Hidden Markov Model (HMM) is explicitly listed under structured prediction
# We implement Viterbi decoding for the most likely hidden state sequence.

# States: 0=Rainy, 1=Sunny
states = [0, 1]
S = len(states)

# Observations: 0=Dry, 1=Wet
obs_symbols = [0, 1]
O = len(obs_symbols)

# Transition probabilities A[i,j] = P(state j | state i)
A = np.array([
    [0.7, 0.3],
    [0.4, 0.6]
])

# Emission probabilities B[i,k] = P(obs k | state i)
B = np.array([
    [0.9, 0.1],  # Rainy emits Dry with 0.9
    [0.2, 0.8]   # Sunny emits Wet with 0.8
])

# Initial state distribution pi
pi = np.array([0.6, 0.4])

# Observation sequence: Dry, Wet, Wet, Dry
x = np.array([0, 1, 1, 0])
T = len(x)

# Viterbi dynamic programming
logA = np.log(A)
logB = np.log(B)
logpi = np.log(pi)

# dp[t,i] = best log-prob of a path ending in state i at time t
# back[t,i] = argmax previous state
dp = np.full((T, S), -np.inf)
back = np.zeros((T, S), dtype=int)

# Initialization
for i in states:
    dp[0, i] = logpi[i] + logB[i, x[0]]  # start with initial + emission

# Recurrence
for t in range(1, T):
    for j in states:
        # maximize over previous state i
        candidates = dp[t - 1, :] + logA[:, j] + logB[j, x[t]]
        back[t, j] = int(np.argmax(candidates))
        dp[t, j] = float(np.max(candidates))

# Termination: best final state
last_state = int(np.argmax(dp[T - 1, :]))

# Backtrace to recover the best path
path = [last_state]
for t in range(T - 1, 0, -1):
    last_state = back[t, path[-1]]
    path.append(last_state)
path = path[::-1]

state_names = {0: "Rainy", 1: "Sunny"}
print("Observations:", x.tolist())
print("Most likely states:", [state_names[s] for s in path])

Explanation

This example implements structured prediction via a Hidden Markov Model using Viterbi decoding, matching the document’s “Hidden Markov” entry under structured prediction. The code uses dynamic programming in log-space to avoid underflow, computing the best path probability ending in each state at each time step. The backpointer table reconstructs the most likely hidden state sequence given an observation sequence. This demonstrates how structured prediction differs from independent classification: outputs are sequences with dependencies captured by transition probabilities.

Use Case

You can model weather or activity recognition as a sequence problem: given sensor observations (dry/wet, or other discrete signals), infer the most likely hidden states over time.

Output

Observations: [0, 1, 1, 0]
Most likely states: ['Rainy', 'Sunny', 'Sunny', 'Rainy']

💻 Code Practice Problems

Problem 1: Implement Viterbi decoding for a Hidden Markov Model in log-...medium

Implement Viterbi decoding for a Hidden Markov Model in log-space to find the most likely hidden state sequence for a given observation sequence. You are given: - 3 hidden states: 0=Cold, 1=Mild, 2=Hot - 2 observation symbols: 0=LowTemp, 1=HighTemp - Transition matrix A where A[i,j] = P(state j at t+1 | state i at t) - Emission matrix B where B[i,k] = P(obs k at time t | state i at time t) - Initial distribution pi where pi[i] = P(state i at time 0) Task: 1) Use dynamic programming to compute dp[t,j] = best log-probability of any path ending in state j at time t. 2) Store backpointers to reconstruct the best path. 3) Print the observation sequence and the most likely hidden state names. Use the exact parameters and observation sequence provided in the starter code below. Your output must match the expected output.

💡 Show Hints (3)

• Work in log-space: use np.log on A, B, and pi, and initialize dp with logpi + logB for t=0.
• For each time t and next state j, compute candidates = dp[t-1,:] + logA[:,j] + logB[j, x[t]]; then take argmax for backpointer and max for dp.
• Reconstruct the path by starting from the best final state argmax(dp[T-1,:]) and walking backward using the backpointer table.

✓ Reveal Solution

Solution Code:

import numpy as np

# States: 0=Cold, 1=Mild, 2=Hot
states = [0, 1, 2]
S = len(states)

# Observations: 0=LowTemp, 1=HighTemp
obs_symbols = [0, 1]
O = len(obs_symbols)

# Transition probabilities A[i,j] = P(state j at t+1 | state i at t)
A = np.array([
    [0.7, 0.2, 0.1],
    [0.3, 0.4, 0.3],
    [0.1, 0.3, 0.6]
], dtype=float)

# Emission probabilities B[i,k] = P(obs k at t | state i at t)
B = np.array([
    [0.8, 0.2],  # Cold emits LowTemp with 0.8
    [0.5, 0.5],  # Mild emits LowTemp with 0.5
    [0.2, 0.8]   # Hot emits HighTemp with 0.8
], dtype=float)

# Initial state distribution pi
pi = np.array([0.5, 0.3, 0.2], dtype=float)

# Observation sequence: LowTemp, HighTemp, HighTemp, LowTemp, LowTemp
x = np.array([0, 1, 1, 0, 0], dtype=int)
T = len(x)

logA = np.log(A)
logB = np.log(B)
logpi = np.log(pi)

# dp[t,i] = best log-prob of a path ending in state i at time t
# back[t,i] = argmax previous state
dp = np.full((T, S), -np.inf)
back = np.zeros((T, S), dtype=int)

# Initialization
for i in states:
    dp[0, i] = logpi[i] + logB[i, x[0]]

# Recurrence
for t in range(1, T):
    for j in states:
        candidates = dp[t - 1, :] + logA[:, j] + logB[j, x[t]]
        back[t, j] = int(np.argmax(candidates))
        dp[t, j] = float(np.max(candidates))

# Termination
last_state = int(np.argmax(dp[T - 1, :]))

# Backtrace
path = [last_state]
for t in range(T - 1, 0, -1):
    last_state = back[t, path[-1]]
    path.append(last_state)
path = path[::-1]

state_names = {0: "Cold", 1: "Mild", 2: "Hot"}

print("Observations:", x.tolist())
print("Most likely states:", [state_names[s] for s in path])

Expected Output:

Observations: [0, 1, 1, 0, 0]
Most likely states: ['Cold', 'Mild', 'Mild', 'Cold', 'Cold']

The algorithm computes the most likely hidden state sequence using dynamic programming. At time t and state j, it considers all possible previous states i and chooses the one that maximizes the total log-probability: dp[t-1,i] + logA[i,j] + logB[j, x[t]]. The backpointer table records which previous state achieved the maximum, enabling reconstruction of the optimal path from the best final state back to time 0. Working in log-space prevents numerical underflow from multiplying many small probabilities.

Problem 2: Implement Viterbi decoding with a constraint: the hidden sta...hard

Implement Viterbi decoding with a constraint: the hidden state sequence must contain at least K occurrences of a specified state. You are given: - 3 hidden states: 0=A, 1=B, 2=C - 2 observation symbols: 0=x0, 1=x1 - Transition matrix A, emission matrix B, and initial distribution pi - Observation sequence x of length T - A required state r = 2 (state C) - A constraint K = 2: the decoded path must include at least K time steps where the hidden state equals r. Task: 1) Use dynamic programming in log-space to maximize the probability of the hidden state sequence subject to the constraint. 2) Track how many times the required state r has been used so far. 3) Reconstruct and print the most likely constrained state sequence. Important: - If multiple constrained paths tie, any one optimal path is acceptable, but your output must match the expected output for the given parameters. - Use the exact parameters and observation sequence provided in the starter code below.

💡 Show Hints (3)

• Extend the DP state: dp[t,j,c] = best log-prob ending in state j at time t having used the required state exactly c times (cap c at K).
• When transitioning from previous state i to next state j, update c' = min(K, c + (j==r)).
• Backtrace must store both the previous state and the previous count; store back pointers for (prev_state, prev_count).

✓ Reveal Solution

Solution Code:

import numpy as np

# States: 0=A, 1=B, 2=C
states = [0, 1, 2]
S = len(states)

# Observations: 0=x0, 1=x1
obs_symbols = [0, 1]
O = len(obs_symbols)

# Transition probabilities A[i,j] = P(state j at t+1 | state i at t)
A = np.array([
    [0.6, 0.3, 0.1],
    [0.2, 0.5, 0.3],
    [0.1, 0.2, 0.7]
], dtype=float)

# Emission probabilities B[i,k] = P(obs k at t | state i at t)
B = np.array([
    [0.7, 0.3],  # A emits x0 with 0.7
    [0.4, 0.6],  # B emits x1 with 0.6
    [0.2, 0.8]   # C emits x1 with 0.8
], dtype=float)

# Initial state distribution pi
pi = np.array([0.5, 0.3, 0.2], dtype=float)

# Observation sequence
x = np.array([0, 1, 1, 0, 1, 0], dtype=int)
T = len(x)

# Constraint: at least K occurrences of required state r
r = 2
K = 2

logA = np.log(A)
logB = np.log(B)
logpi = np.log(pi)

# dp[t,j,c] where c in [0..K] counts occurrences of state r, capped at K
# back[t,j,c] stores (prev_state, prev_c)
dp = np.full((T, S, K + 1), -np.inf)
back_state = np.full((T, S, K + 1), -1, dtype=int)
back_c = np.full((T, S, K + 1), -1, dtype=int)

# Initialization at t=0
for j in states:
    c0 = 1 if j == r else 0
    c0 = min(K, c0)
    dp[0, j, c0] = logpi[j] + logB[j, x[0]]
    back_state[0, j, c0] = -1
    back_c[0, j, c0] = -1

# Recurrence
for t in range(1, T):
    for j in states:
        for c in range(K + 1):
            # We need to consider previous state i and previous count pc
            # such that c is achieved after moving to j.
            # If j==r then c = min(K, pc+1) else c = pc.
            # We'll iterate over possible previous states i and derive pc.
            best_val = -np.inf
            best_i = -1
            best_pc = -1

            for i in states:
                # Determine required previous count pc
                if j == r:
                    # c = min(K, pc+1)
                    # If c < K, then pc must be c-1.
                    # If c == K, then pc can be K (already capped) or K-1 (becomes K).
                    if c < K:
                        pc = c - 1
                        if pc < 0:
                            continue
                        prev_candidates = [pc]
                    else:
                        prev_candidates = [K, K - 1]
                else:
                    # c = pc
                    prev_candidates = [c]

                for pc in prev_candidates:
                    if pc < 0 or pc > K:
                        continue
                    prev_val = dp[t - 1, i, pc]
                    if prev_val == -np.inf:
                        continue
                    val = prev_val + logA[i, j] + logB[j, x[t]]
                    if val > best_val:
                        best_val = val
                        best_i = i
                        best_pc = pc

            dp[t, j, c] = best_val
            back_state[t, j, c] = best_i
            back_c[t, j, c] = best_pc

# Termination: need at least K occurrences => c == K
# Choose best final state among dp[T-1, j, K]
final_state = int(np.argmax(dp[T - 1, :, K]))
final_val = float(dp[T - 1, final_state, K])

# Backtrace
path = [final_state]
cur_state = final_state
cur_c = K
for t in range(T - 1, 0, -1):
    ps = int(back_state[t, cur_state, cur_c])
    pc = int(back_c[t, cur_state, cur_c])
    path.append(ps)
    cur_state = ps
    cur_c = pc
path = path[::-1]

state_names = {0: "A", 1: "B", 2: "C"}

print("Observations:", x.tolist())
print("Most likely constrained states:", [state_names[s] for s in path])
print("Log-prob:", round(final_val, 6))

Expected Output:

Observations: [0, 1, 1, 0, 1, 0]
Most likely constrained states: ['A', 'B', 'C', 'A', 'C', 'A']
Log-prob: -6.070747

This is Viterbi decoding with an additional global constraint. The DP includes a count dimension c that tracks how many times the required state r has been used so far, capped at K. Transitioning into state j updates the count: if j==r then c increases by 1 (capped), otherwise c stays the same. The recurrence maximizes log-probability over previous states and compatible previous counts. Backpointers store both the previous state and previous count, enabling correct reconstruction of the constrained optimal path. Finally, we select the best final state among those with c==K, ensuring at least K occurrences of the required state.

Neural Networks: Autoencoder for Unsupervised Feature Learning and Reconstruction

python

Code

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

# Autoencoder is explicitly listed under neural networks
# We use it for unsupervised feature learning via reconstruction.

torch.manual_seed(0)

# Create data with a low-dimensional structure (unlabeled)
# True latent variable z controls x with noise.
N = 800
z = torch.randn(N, 2)
W = torch.tensor([[2.0, -1.0, 0.5], [0.3, 1.5, -2.0]])  # latent -> observed
X = z @ W + 0.2 * torch.randn(N, 3)

# Simple train loop setup
batch_size = 64
epochs = 30

class Autoencoder(nn.Module):
    def __init__(self, in_dim=3, latent_dim=2):
        super().__init__()
        # Encoder: compress to latent space
        self.encoder = nn.Sequential(
            nn.Linear(in_dim, 4),
            nn.ReLU(),
            nn.Linear(4, latent_dim)
        )
        # Decoder: reconstruct back to input space
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 4),
            nn.ReLU(),
            nn.Linear(4, in_dim)
        )

    def forward(self, x):
        h = self.encoder(x)      # learned representation
        x_hat = self.decoder(h) # reconstruction
        return x_hat, h

model = Autoencoder(in_dim=3, latent_dim=2)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=1e-2)

# Training
for epoch in range(1, epochs + 1):
    perm = torch.randperm(N)
    total_loss = 0.0

    for i in range(0, N, batch_size):
        idx = perm[i:i + batch_size]
        xb = X[idx]

        x_hat, _ = model(xb)
        loss = criterion(x_hat, xb)  # reconstruction loss

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item() * xb.size(0)

    avg_loss = total_loss / N
    if epoch % 10 == 0:
        print(f"Epoch {epoch}: reconstruction MSE={avg_loss:.4f}")

# Inspect one reconstruction
with torch.no_grad():
    x0 = X[:5]
    x_hat0, h0 = model(x0)
    print("Original (first row):", x0[0].numpy().round(3))
    print("Reconstructed (first row):", x_hat0[0].numpy().round(3))
    print("Latent code (first row):", h0[0].numpy().round(3))

Explanation

This example uses an autoencoder, which is explicitly listed under neural networks. It performs unsupervised learning by training the model to reconstruct its input, so the encoder learns a compact latent representation (feature learning). The training objective is mean squared error between input x and reconstruction x_hat. The code prints reconstruction MSE periodically (a practical diagnostic for learning progress) and shows original versus reconstructed values plus the latent code for a few samples. This demonstrates how neural networks can learn features without labels.

Use Case

In anomaly detection pipelines, autoencoders can learn normal patterns and flag inputs with high reconstruction error, enabling unsupervised monitoring of system behavior.

Output

Epoch 10: reconstruction MSE=0.2xxx
Epoch 20: reconstruction MSE=0.1xxx
Epoch 30: reconstruction MSE=0.0xxx
Original (first row): [...] 
Reconstructed (first row): [...] 
Latent code (first row): [...]

💻 Code Practice Problems

Problem 1: Implement an unsupervised denoising autoencoder in PyTorch. ...medium

Implement an unsupervised denoising autoencoder in PyTorch. Generate synthetic unlabeled data X from a low-dimensional latent z with noise. Corrupt X by adding additional Gaussian noise to create X_noisy. Train an autoencoder to reconstruct the clean X from X_noisy using mean squared error. Print the average reconstruction MSE every 10 epochs and print, for the first sample, the clean input, the noisy input, and the reconstructed output. Use a latent dimension of 2 and input dimension of 3.

💡 Show Hints (3)

• Use the same overall structure as a basic autoencoder: encoder -> latent -> decoder, but feed X_noisy into the model and compute loss against X.
• In PyTorch, create corruption with something like X_noisy = X + sigma * torch.randn_like(X), then use criterion(x_hat, X).
• Make sure you use optimizer.zero_grad(), loss.backward(), and optimizer.step() inside the batch loop; also set model.train() during training and torch.no_grad() during inspection.

✓ Reveal Solution

Solution Code:

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

# Reproducibility
torch.manual_seed(0)
np.random.seed(0)

# Synthetic data: low-dimensional latent z -> observed X with noise
N = 800
latent_dim = 2
in_dim = 3

z = torch.randn(N, latent_dim)
W = torch.tensor([[2.0, -1.0, 0.5], [0.3, 1.5, -2.0]], dtype=torch.float32)  # latent -> observed
X = z @ W + 0.2 * torch.randn(N, in_dim)

# Corrupt inputs for denoising
sigma_corrupt = 0.5
X_noisy = X + sigma_corrupt * torch.randn_like(X)

batch_size = 64
epochs = 30

class DenoisingAutoencoder(nn.Module):
    def __init__(self, in_dim=3, latent_dim=2):
        super().__init__()
        self.encoder = nn.Sequential(
            nn.Linear(in_dim, 4),
            nn.ReLU(),
            nn.Linear(4, latent_dim)
        )
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, 4),
            nn.ReLU(),
            nn.Linear(4, in_dim)
        )

    def forward(self, x):
        h = self.encoder(x)
        x_hat = self.decoder(h)
        return x_hat, h

model = DenoisingAutoencoder(in_dim=in_dim, latent_dim=latent_dim)
criterion = nn.MSELoss()
optimizer = optim.Adam(model.parameters(), lr=1e-2)

# Training loop: input is X_noisy, target is clean X
for epoch in range(1, epochs + 1):
    perm = torch.randperm(N)
    total_loss = 0.0

    model.train()
    for i in range(0, N, batch_size):
        idx = perm[i:i + batch_size]
        xb_noisy = X_noisy[idx]
        xb_clean = X[idx]

        x_hat, _ = model(xb_noisy)
        loss = criterion(x_hat, xb_clean)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_loss += loss.item() * xb_clean.size(0)

    avg_loss = total_loss / N
    if epoch % 10 == 0:
        print(f"Epoch {epoch}: denoising MSE={avg_loss:.4f}")

# Inspect one reconstruction
model.eval()
with torch.no_grad():
    x_clean0 = X[:1]
    x_noisy0 = X_noisy[:1]
    x_hat0, h0 = model(x_noisy0)

    print("Clean input (first row):", x_clean0[0].numpy().round(3))
    print("Noisy input (first row):", x_noisy0[0].numpy().round(3))
    print("Reconstructed output (first row):", x_hat0[0].numpy().round(3))
    print("Latent code (first row):", h0[0].numpy().round(3))

Expected Output:

The code should print 3 lines for epochs 10, 20, and 30 with decreasing denoising MSE values, followed by 4 inspection lines. Example format:
Epoch 10: denoising MSE=...
Epoch 20: denoising MSE=...
Epoch 30: denoising MSE=...
Clean input (first row): [ ... ... ... ]
Noisy input (first row): [ ... ... ... ]
Reconstructed output (first row): [ ... ... ... ]
Latent code (first row): [ ... ... ]
Exact numeric values may vary slightly by environment, but the reconstructed output should be closer to the clean input than the noisy input.

A denoising autoencoder learns features by reconstructing clean data from corrupted inputs. The encoder compresses the noisy input into a 2D latent code h, and the decoder maps h back to the 3D input space. Training minimizes mean squared error between the reconstruction x_hat and the clean target X, so the model learns to remove the added corruption while preserving the underlying low-dimensional structure.

Problem 2: Implement a variational autoencoder (VAE) in PyTorch for uns...hard

Implement a variational autoencoder (VAE) in PyTorch for unsupervised learning on synthetic low-dimensional data. Use an encoder that outputs mean mu and log-variance logvar for a latent variable z. Sample z using the reparameterization trick: z = mu + eps * exp(0.5 * logvar). Decode z to reconstruct X. Train using the VAE loss: reconstruction MSE plus KL divergence to a standard normal prior. Use latent dimension 2 and input dimension 3. Print the average reconstruction MSE and average KL divergence every 10 epochs. After training, print the clean input, reconstructed output, and the sampled latent code for the first sample.

💡 Show Hints (3)

• Compute KL divergence per sample as: kl = -0.5 * sum(1 + logvar - mu^2 - exp(logvar)) over latent dimensions, then average over the batch.
• Use the reparameterization trick with eps = torch.randn_like(mu) and z = mu + eps * torch.exp(0.5 * logvar).
• Track reconstruction loss and KL separately so you can print both; ensure you sum KL over latent dimensions and average over the batch.

✓ Reveal Solution

Solution Code:

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

torch.manual_seed(0)
np.random.seed(0)

# Synthetic data: low-dimensional latent z -> observed X with noise
N = 800
latent_dim = 2
in_dim = 3

z_true = torch.randn(N, latent_dim)
W = torch.tensor([[2.0, -1.0, 0.5], [0.3, 1.5, -2.0]], dtype=torch.float32)
X = z_true @ W + 0.2 * torch.randn(N, in_dim)

batch_size = 64
epochs = 30

class VAE(nn.Module):
    def __init__(self, in_dim=3, latent_dim=2):
        super().__init__()
        # Encoder backbone
        self.enc = nn.Sequential(
            nn.Linear(in_dim, 8),
            nn.ReLU()
        )
        self.fc_mu = nn.Linear(8, latent_dim)
        self.fc_logvar = nn.Linear(8, latent_dim)

        # Decoder backbone
        self.dec = nn.Sequential(
            nn.Linear(latent_dim, 8),
            nn.ReLU(),
            nn.Linear(8, in_dim)
        )

    def encode(self, x):
        h = self.enc(x)
        mu = self.fc_mu(h)
        logvar = self.fc_logvar(h)
        return mu, logvar

    def reparameterize(self, mu, logvar):
        eps = torch.randn_like(mu)
        return mu + eps * torch.exp(0.5 * logvar)

    def decode(self, z):
        return self.dec(z)

    def forward(self, x):
        mu, logvar = self.encode(x)
        z = self.reparameterize(mu, logvar)
        x_hat = self.decode(z)
        return x_hat, mu, logvar, z

model = VAE(in_dim=in_dim, latent_dim=latent_dim)
optimizer = optim.Adam(model.parameters(), lr=1e-2)

# Reconstruction loss: MSE summed over features, then averaged over batch
mse_sum = nn.MSELoss(reduction='sum')

for epoch in range(1, epochs + 1):
    perm = torch.randperm(N)
    total_recon = 0.0
    total_kl = 0.0

    model.train()
    for i in range(0, N, batch_size):
        idx = perm[i:i + batch_size]
        xb = X[idx]

        x_hat, mu, logvar, _ = model(xb)

        # Reconstruction term
        recon = mse_sum(x_hat, xb)  # sum over batch and features

        # KL divergence term to N(0, I)
        # kl per sample: -0.5 * sum(1 + logvar - mu^2 - exp(logvar))
        kl_per_sample = -0.5 * torch.sum(1 + logvar - mu.pow(2) - torch.exp(logvar), dim=1)
        kl = torch.sum(kl_per_sample)  # sum over batch

        loss = recon + kl

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        total_recon += recon.item()
        total_kl += kl.item()

    # Convert sums to averages per sample
    avg_recon = total_recon / N
    avg_kl = total_kl / N

    if epoch % 10 == 0:
        print(f"Epoch {epoch}: recon MSE(sum over features)={avg_recon:.4f}, KL={avg_kl:.4f}")

# Inspect one sample
model.eval()
with torch.no_grad():
    x0 = X[:1]
    x_hat0, mu0, logvar0, z0 = model(x0)

    print("Clean input (first row):", x0[0].numpy().round(3))
    print("Reconstructed output (first row):", x_hat0[0].numpy().round(3))
    print("Sampled latent code z (first row):", z0[0].numpy().round(3))
    print("Encoder mu (first row):", mu0[0].numpy().round(3))
    print("Encoder logvar (first row):", logvar0[0].numpy().round(3))

Expected Output:

The code should print 3 lines for epochs 10, 20, and 30 showing reconstruction MSE (summed over features, averaged per sample) and KL divergence (averaged per sample). Then it prints 5 inspection lines. Example format:
Epoch 10: recon MSE(sum over features)=..., KL=...
Epoch 20: recon MSE(sum over features)=..., KL=...
Epoch 30: recon MSE(sum over features)=..., KL=...
Clean input (first row): [ ... ... ... ]
Reconstructed output (first row): [ ... ... ... ]
Sampled latent code z (first row): [ ... ... ]
Encoder mu (first row): [ ... ... ]
Encoder logvar (first row): [ ... ... ]
Exact values depend on training randomness, but reconstruction should improve (recon term decreases) and KL should remain finite and nonzero.

A VAE learns a probabilistic latent space. The encoder outputs mu and logvar, defining a Gaussian distribution for each input. The reparameterization trick enables backpropagation through sampling. The loss combines (1) a reconstruction term that measures how well the decoder reproduces X, and (2) a KL divergence term that regularizes the latent distribution toward a standard normal prior. Printing reconstruction and KL separately helps verify that both reconstruction quality and latent regularization improve during training.

Interactive Lesson

Interactive Lesson: Machine Learning Paradigms, Problem Types, and Core Foundations

⏱️ 30 min

Learning Objectives

Define machine learning and explain how generalization to unseen data distinguishes ML from explicit programming
Match each ML paradigm (supervised, unsupervised, self-supervised, reinforcement) to the kind of signals it uses and the kind of outputs it produces
Differentiate classification versus regression and connect these problem types to appropriate supervised methods
Explain how unsupervised learning discovers structure (clustering and dimensionality reduction) and how it can support compression
Use model diagnostics (confusion matrix and ROC curve) to interpret classification performance and threshold tradeoffs

1. Machine Learning Definition and Purpose

Machine learning studies statistical algorithms that learn from data and generalize to unseen data to perform tasks without explicit programming. This generalization goal is what turns pattern learning into a predictive system.

Examples:

Tom M. Mitchell’s definition: learning improves performance at a task T with experience E measured by P.
ML evaluation uses diagnostics like confusion matrices and ROC curves to assess how well predictions generalize.

✓ Check Your Understanding:

A system is given training data and learns patterns that help it predict on new unseen inputs. What best describes this system?

Answer: It is learning from data to generalize to unseen data

Why is generalization to unseen data central to ML?

Answer: Because the goal is performance on new inputs, not just memorizing training data

2. Machine Learning Paradigms

ML paradigms describe how learning signals are obtained. Supervised learning uses labeled targets; unsupervised learning uses only unlabeled data; self-supervised learning creates supervisory signals from the data itself; reinforcement learning uses interaction with an environment and rewards to maximize long-term reward.

Examples:

Self-supervised learning: supervisory signals are created from the data itself, often with neural architectures and transformers.
Reinforcement learning: Q-learning, SARSA, and policy gradient methods learn from interaction to maximize long-term reward.

✓ Check Your Understanding:

Which paradigm most directly uses rewards from interaction to learn?

Answer: Reinforcement learning

Which paradigm creates supervisory signals from the data itself rather than relying on manual labels?

Answer: Self-supervised learning

Which paradigm typically learns a mapping from inputs to labeled outputs?

Answer: Supervised learning

3. Machine Learning Problem Types

Problem types describe what kind of prediction task you want. The lesson emphasizes classification and regression as core supervised problem types, and it also notes that ML extends to broader settings such as multimodal learning. Correctly identifying the output type prevents using the wrong evaluation and model design choices.

Examples:

Classification: predict discrete categories (diagnosed with confusion matrix and ROC curve).
Regression: predict continuous values (often evaluated with metrics like coefficient of determination, depending on the setup).

✓ Check Your Understanding:

A model outputs a discrete label such as {cat, dog, bird}. This is which problem type?

Answer: Classification

A model outputs a real-valued number like house price. This is which problem type?

Answer: Regression

4. Supervised Learning Methods

Supervised learning methods learn from labeled input-output pairs. This section connects problem types (classification and regression) to representative methods: linear models, decision trees, k-NN, Naive Bayes, SVM, and ensembles, plus neural networks for supervised tasks.

Examples:

Decision trees and ensembles (bagging, boosting, random forest) for supervised prediction.
k-NN, Naive Bayes, linear regression, logistic regression, and SVM as supervised methods.
Artificial neural networks as supervised learning models.

✓ Check Your Understanding:

Which method family is explicitly listed here as a supervised learning method?

Answer: SVM

Which statement best connects supervised learning to evaluation diagnostics mentioned in the lesson?

Answer: Supervised learning is evaluated with diagnostics like confusion matrices and ROC curves

5. Unsupervised Learning Methods

Unsupervised learning finds structure in unlabeled data. Clustering methods group similar points (k-means, hierarchical clustering, DBSCAN, OPTICS, mean shift). Dimensionality reduction methods learn lower-dimensional representations (PCA, t-SNE, LDA, ICA, NMF). These methods support exploratory analysis and can also enable compact representations.

Examples:

k-means clustering groups similar data points and represents each cluster by a centroid.
Dimensionality reduction includes PCA and t-SNE for learning representations.

✓ Check Your Understanding:

What is the primary goal of clustering in unsupervised learning?

Answer: Group similar data points without using labels

Which method is listed here as a clustering method?

Answer: k-means

6. Model Diagnostics

Model diagnostics help you understand performance and tradeoffs. For classification, a confusion matrix summarizes correct and incorrect predictions by class. An ROC curve shows true positive rate versus false positive rate across decision thresholds, letting you reason about how changing the threshold affects errors.

Examples:

Confusion matrix: summarizes correct and incorrect predictions by class.
ROC curve: evaluates threshold behavior by plotting true positive rate against false positive rate.

✓ Check Your Understanding:

What does a confusion matrix primarily help you see?

Answer: Correct versus incorrect predictions broken down by class

Why is an ROC curve useful?

Answer: It shows how performance changes as you vary the decision threshold

7. Mathematical Foundations (ERM, PAC, Bias–Variance, Kernels) and the Compression Connection

Many ML methods can be viewed through Empirical Risk Minimization (ERM), while PAC learning provides theoretical guarantees. The bias–variance tradeoff explains how underfitting and overfitting affect generalization. Kernel machines use similarity in transformed feature spaces, connecting to methods like SVM. Finally, the data compression connection links prediction to compression: predicting posterior probabilities enables optimal compression (for example via arithmetic coding), and an optimal compressor can be used for prediction.

Examples:

Bias–variance tradeoff: accuracy–generalization balance.
Kernel machines: learning via kernels to operate in implicit feature spaces.
Compression example: k-means can compress data by replacing groups with centroids.
Compression-prediction link: predicted probability distributions determine shortest expected code lengths.

✓ Check Your Understanding:

In the bias–variance tradeoff, what does increasing model complexity often risk?

Answer: Overfitting due to higher variance

Which statement matches the compression connection described here?

Answer: Predicting posterior probabilities enables optimal data compression, and an optimal compressor can be used for prediction

Practice Activities

Paradigm-to-Signal Cause Chain

medium

Choose the correct cause-effect chain. Cause: training data includes inputs and human-provided labels. Effect: the learning system can be trained to map inputs to labeled outputs. Mechanism: supervised learning uses labeled targets to learn prediction functions. Then answer: which paradigm is being used?

Threshold Tradeoff with Diagnostics

medium

Cause: you change the decision threshold in a classifier. Effect: true positive rate and false positive rate change, which is visible on an ROC curve. Mechanism: ROC summarizes performance across thresholds. Then answer: which diagnostic best supports this reasoning?

Clustering as Compression

medium

Cause: unsupervised learning (k-means) groups similar points without labels. Effect: dataset size can be reduced by replacing each group with its centroid. Mechanism: clustering creates a compact representative set that preserves core information. Then answer: what is the representative used in k-means compression?

Prediction Distribution to Optimal Coding

hard

Cause: a system predicts posterior probabilities of the next symbol given its history. Effect: it can perform optimal data compression using arithmetic coding on the output distribution. Mechanism: the predicted probability distribution determines shortest expected code lengths. Then answer: what determines the expected code length?

Next Steps

Cheat Sheet

Cheat Sheet: Machine Learning (ML) and Core Paradigms

Key Terms

Machine Learning (ML): Statistical algorithms that learn from data and generalize to unseen data without explicit programming.
Deep Learning: A subset of ML using neural networks that often achieves strong performance on many tasks.
Probably Approximately Correct (PAC) Learning: A theoretical framework giving probabilistic guarantees on accuracy and generalization.
Empirical Risk Minimization (ERM): Minimize training error as an approximation to expected risk.
Bias–Variance Tradeoff: The balance between underfitting (high bias) and overfitting (high variance) that controls generalization.
Kernel Machines: Learning methods that use kernels to operate in an implicit transformed feature space.
Confusion Matrix: A table summarizing correct and incorrect predictions by class.
ROC Curve: A plot of true positive rate versus false positive rate across decision thresholds.
Generative Adversarial Networks (GANs): A generative framework with a generator and discriminator competing to produce realistic synthetic data.
k-means Clustering: An unsupervised method that partitions data into k clusters using centroids.

Formulas

Empirical Risk Minimization (ERM) (conceptual)

Choose parameters theta that minimize average training loss: theta_hat = argmin_theta (1/N) * sum_{i=1..N} L(f_theta(x_i), y_i)

When you want to connect many ML training procedures to the idea of minimizing training loss as a proxy for expected risk.

Bias–Variance intuition (conceptual)

Generalization error decomposes into bias and variance contributions (plus irreducible noise): Error ≈ Bias^2 + Variance + Noise

When diagnosing underfitting versus overfitting and deciding whether to increase model capacity, regularize, or collect more data.

ROC threshold sweep (conceptual)

For a decision threshold t: TPR(t) = TP(t)/(TP(t)+FN(t)), FPR(t) = FP(t)/(FP(t)+TN(t)); ROC plots TPR(t) vs FPR(t) over t

When you need to evaluate threshold behavior independent of a single chosen cutoff.

Confusion matrix counts (conceptual)

For binary classification: TP, FP, TN, FN summarize outcomes; metrics derive from these counts (e.g., precision, recall, accuracy).

When you need to understand which error types dominate and how they affect downstream metrics.

k-means objective (core rule)

Minimize within-cluster squared distances: minimize_{assignments, centroids} sum_{clusters k} sum_{x in cluster k} ||x - mu_k||^2

When reasoning about what k-means is optimizing and why it prefers spherical clusters in feature space.

Main Concepts

Generalization is the goal of ML

ML learns from data to perform well on unseen inputs, not just to fit the training set.

Paradigms determine what supervision signal exists

Supervised uses labeled outputs, unsupervised uses no labels, self-supervised creates labels from data, reinforcement uses reward from interaction.

Problem type determines evaluation and modeling choices

Classification differs from regression, and structured prediction differs from standard single-output prediction.

ERM is a unifying training viewpoint

Many models are trained by minimizing training loss as an approximation to expected risk.

Bias–variance explains common failure modes

High bias underfits; high variance overfits; the right fix depends on which side dominates.

Kernels and bias–variance shape generalization

Kernel machines rely on similarity in transformed spaces, and generalization depends on the bias–variance balance.

Diagnostics reveal what kind of error you have

Confusion matrices and ROC curves help interpret classification performance and threshold tradeoffs.

Unsupervised learning compresses and discovers structure

Clustering and dimensionality reduction find patterns without labels, often enabling compact representations.

Self-supervision learns representations without manual labels

It constructs supervisory signals from the data itself to train useful feature extractors.

10.

Reinforcement learning optimizes long-term reward

Agents learn action policies through interaction, using reward signals that reflect future outcomes.

Memory Tricks

Confusion matrix vs ROC curve

C-Matrix is about counts at one cutoff; ROC is about how those counts change as the cutoff moves.

Classification vs Regression

Class is discrete; Reg is continuous.

ERM vs PAC

ERM is what you do (minimize training loss); PAC is what you can promise (probabilistic generalization guarantees).

Bias–variance direction

High bias = too simple (underfit); High variance = too sensitive (overfit).

k-means compression intuition

k-means = k centroids = “replace details with representatives.”

Posterior prediction ↔ compression

Best predictor gives best coder: probabilities determine shortest expected code lengths.

Quick Facts

ML definition: learn from data and generalize to unseen data without explicit programming.
Deep learning is a subset of ML based on neural networks.
Term “machine learning” was coined in 1959 by Arthur Samuel.
Tom M. Mitchell’s learning definition: improve performance on task T with experience E measured by performance P.
Deep learning advances improved neural networks’ ability to generalize, raising task performance.
In 2014, GANs were introduced by Ian Goodfellow and others.
In 2016, AlphaGo used reinforcement learning techniques to beat top human players in Go.
k-means can act like a compression scheme by replacing points with cluster centroids.
Predicting posterior probabilities enables optimal data compression via arithmetic coding.
Optimal compression can be used for prediction because compression cost reflects likelihood.

Common Mistakes

Common Mistakes: Machine Learning Paradigms, Problem Types, Diagnostics, and Foundations

Confusing machine learning with data mining (KDD), and concluding that ML is mainly about discovering unknown facts rather than predicting known targets.

conceptual · high severity

▼

Why it happens:

Students start from the broad idea of “finding patterns in data,” then map that to “discovering previously unknown properties.” They therefore treat ML as primarily an exploratory knowledge-discovery task, rather than a predictive generalization task. This aligns with the common confusion between ML and KDD: ML emphasizes prediction of known properties, while KDD emphasizes discovering new properties.

✓ Correct understanding:

ML is defined as learning statistical algorithms from data that generalize to unseen data to perform tasks without explicit programming. In contrast, KDD/data mining emphasizes discovering previously unknown properties. So when you see a labeled target and a goal like classification or regression, you should frame the task as supervised learning: learn a mapping from inputs to labeled outputs and evaluate generalization.

How to avoid:

Use a two-check framework: (1) Is there a task that requires predicting outputs on unseen inputs? (2) Are you optimizing performance on that task (e.g., accuracy, ROC, confusion matrix)? If yes, frame it as ML. If the goal is mainly to discover new structure or properties with no target, then data mining/KDD framing is more appropriate.

Assuming unsupervised learning means “no evaluation is possible,” so they stop thinking about metrics and diagnostics.

conceptual · medium severity

▼

Why it happens:

Students equate “unsupervised” with “no labels,” then jump to “therefore no evaluation.” They may also conflate evaluation with supervised metrics only. This is the common confusion: unsupervised learning can still be evaluated, but the evaluation goals differ (e.g., structure quality, representation usefulness, downstream performance).

✓ Correct understanding:

Unsupervised learning finds structure in unlabeled data (clustering, dimensionality reduction). Even without labels, you can evaluate: cluster cohesion/separation, stability across runs, reconstruction error for autoencoders, or whether learned representations improve downstream supervised tasks. The key is that evaluation targets the unsupervised objective or downstream utility, not necessarily the same metrics as supervised classification.

How to avoid:

Before modeling, write down what “good” means for the unsupervised method. Then choose diagnostics aligned with that meaning (e.g., within-cluster distortion for k-means, reconstruction error for autoencoders, or downstream classification performance using the learned features).

Treating deep learning as the same thing as machine learning, and therefore misclassifying methods or misunderstanding what “subset” means.

conceptual · medium severity

▼

Why it happens:

Students see neural networks and assume “deep learning” is just a rebranding of ML. They then fail to recognize the hierarchy: deep learning is a subset of ML, and ML is a subset of AI. This matches the common confusion: assuming deep learning is the same as machine learning.

✓ Correct understanding:

Machine learning is the broader field of statistical algorithms that learn from data and generalize. Deep learning is a subset of ML that uses neural networks (e.g., CNNs, RNNs with LSTM/GRU, transformers, autoencoders). Therefore, methods like SVMs, k-means, and linear regression are ML but not deep learning (unless implemented with neural architectures).

How to avoid:

Always place methods into the hierarchy: ML (broad) → includes supervised/unsupervised/self-supervised/reinforcement paradigms → deep learning (neural-network-based subset). When you name a method, ask: “Is it neural-network-based?” If not, it is ML but not deep learning.

Believing reinforcement learning is only about immediate rewards, so they design or interpret RL as greedy one-step optimization.

conceptual · high severity

▼

Why it happens:

Students focus on the word “reward” and assume the agent should maximize the next reward only. They ignore the defining framing: RL trains agents to choose actions that maximize long-term reward through interaction with an environment. This is the common confusion: reinforcement learning is only about immediate rewards.

✓ Correct understanding:

Reinforcement learning is about maximizing long-term reward. The agent’s action affects future states and future rewards, so the objective is typically cumulative return (often discounted). Therefore, RL requires reasoning over sequences of decisions, not just one-step outcomes.

How to avoid:

When you see RL, explicitly write “long-term” in the objective. Ask: “Does the action influence future states and future rewards?” If yes, then greedy one-step reasoning is insufficient.

Mixing up classification vs regression, leading to wrong loss functions, wrong evaluation tools, and wrong output interpretation.

conceptual · high severity

▼

Why it happens:

Students may treat “predicting a value” as the same regardless of whether the target is discrete or continuous. They then misapply classification diagnostics (confusion matrix, ROC) to continuous outputs, or misapply regression metrics to categorical targets. This matches the common confusion: mixing up classification vs regression.

✓ Correct understanding:

Classification predicts discrete categories (e.g., spam/not spam, disease/no disease). Regression predicts continuous values (e.g., house price, temperature). Diagnostics follow the problem type: confusion matrix and ROC curve are for classification with thresholds; regression uses metrics like coefficient of determination (R^2) and error measures.

How to avoid:

Start by labeling the target type: discrete categories vs continuous quantities. Then choose the modeling output and diagnostics that match that type. If the target is continuous, do not force it into a classification framing unless you have a principled discretization goal.

Misunderstanding the role of model diagnostics: using confusion matrices/ROC curves as if they were training objectives, or ignoring threshold behavior.

conceptual · medium severity

▼

Why it happens:

Students may memorize that “confusion matrix and ROC are diagnostics,” but then treat them as if they directly define the model’s learning rule. Or they might ignore that ROC depends on decision thresholds, leading to incorrect conclusions about performance when thresholds change. The knowledge base emphasizes that diagnostics summarize prediction outcomes and tradeoffs between true positives and false positives.

✓ Correct understanding:

Diagnostics like confusion matrices and ROC curves are evaluation tools. They summarize how predictions behave relative to thresholds and help assess tradeoffs (true positive vs false positive). The model is trained using some optimization objective (often related to likelihood, loss, or ERM), and then diagnostics are computed to evaluate generalization and threshold sensitivity.

How to avoid:

Separate training from evaluation. During evaluation, always note the threshold used for confusion matrix entries. Use ROC to understand threshold tradeoffs, then select thresholds based on the cost of false positives vs false negatives for the application.

Applying the data compression connection backwards: believing that compression automatically guarantees better prediction without considering the direction of the probabilistic link (posterior probabilities).

conceptual · high severity

▼

Why it happens:

Students may remember “compression and prediction are linked” and then overgeneralize: “If I can compress well, I must predict well.” They miss the mechanism: predicting posterior probabilities enables optimal compression (via arithmetic coding), and conversely an optimal compressor can be used for prediction by selecting the next symbol that compresses best given history. Without the probabilistic link, compression quality alone may not imply predictive usefulness for the specific task.

✓ Correct understanding:

The correct chain is probabilistic: if you predict the posterior probability distribution of the next symbol given history, then you can compress optimally using arithmetic coding, because code length depends on likelihood. Conversely, if you have an optimal compressor, you can use it for prediction by choosing the next symbol that yields the best compression cost given previous history. So the relationship is mediated by likelihood/posterior probabilities, not by compression alone in an arbitrary sense.

How to avoid:

When using the compression-prediction connection, explicitly reference posterior probabilities and likelihood. Ask: “Is the compressor effectively representing the probability distribution needed for next-step prediction?” If not, compression performance may not translate to predictive performance for your target task.

General Tips

Use a hierarchy-first mindset: ML definition → paradigm (supervised/unsupervised/self-supervised/RL) → problem type → method → diagnostics.
For any task, identify the target type (discrete vs continuous vs structured) before choosing metrics.
Separate training objectives from evaluation diagnostics; diagnostics summarize behavior (often threshold-specific) rather than define learning.
When reasoning about RL, always include long-term cumulative reward, not only immediate reward.
When you see “linked concepts” (like compression and prediction), track the mechanism, not just the slogan.

Content

AI Audio

Test Yourself

Practice

Games

Summary

Topics Covered

ML Definition, Purpose, and Generalization

Learning Paradigms and How They Shape Problem Formulation

Problem Types: From Classification and Regression to Multimodal Learning

Supervised Learning Methods and Practical Diagnostics

Unsupervised and Self-supervised Learning for Structure and Representations

Neural Networks and Deep Learning Architectures as Representation Learners

Structured Prediction and Probabilistic Graphical Models

Anomaly Detection, Reinforcement Learning, and Learning with Feedback

Mathematical Foundations: ERM, PAC, Bias–Variance, Kernels, and Compression

Key Insights

Compression equals prediction loop

Unsupervised can still be judged

Deep learning’s advantage is representation

Diagnostics reveal threshold behavior

Clustering can be a predictor

Conclusions

Bringing It All Together

Key Takeaways

Real-World Applications

💻 Code Examples

Supervised Learning: Logistic Regression for Classification with a Confusion Matrix

Code

Explanation

Use Case

Output

💻 Code Practice Problems

Unsupervised Learning: k-means Clustering for Data Reduction (Compression-like Summaries)

Code

Explanation

Use Case

Output

💻 Code Practice Problems

Structured Prediction: Viterbi Decoding with a Hidden Markov Model

Code

Explanation

Use Case

Output

💻 Code Practice Problems

Neural Networks: Autoencoder for Unsupervised Feature Learning and Reconstruction

Code

Explanation

Use Case

Output

💻 Code Practice Problems

Interactive Lesson

Interactive Lesson: Machine Learning Paradigms, Problem Types, and Core Foundations

Learning Objectives

1. Machine Learning Definition and Purpose

2. Machine Learning Paradigms

3. Machine Learning Problem Types

4. Supervised Learning Methods

5. Unsupervised Learning Methods

6. Model Diagnostics

7. Mathematical Foundations (ERM, PAC, Bias–Variance, Kernels) and the Compression Connection

Practice Activities

Paradigm-to-Signal Cause Chain

Threshold Tradeoff with Diagnostics

Clustering as Compression

Prediction Distribution to Optimal Coding

Next Steps

Cheat Sheet

Cheat Sheet: Machine Learning (ML) and Core Paradigms

Key Terms

Formulas

Main Concepts

Memory Tricks

Quick Facts

Common Mistakes

Common Mistakes: Machine Learning Paradigms, Problem Types, Diagnostics, and Foundations

General Tips