Machine Learning

220 topics across 6 chapters

Chapter 1

Math & Data Foundations for ML

Linear Algebra Essentials

4 subtopics

Vectors, dot products, norms

Matrices, transpose, inverse, rank

Eigenvalues/eigenvectors & SVD intuition

Geometric view of projections & least squares

Calculus & Optimization Basics

4 subtopics

Derivatives, partial derivatives, gradients

Chain rule & backprop intuition

Gradient descent variants (SGD, momentum, Adam)

Convexity basics & why it matters

Probability & Statistics for ML

5 subtopics

Random variables, distributions, expectation, variance

Bayes rule & conditional independence

Sampling, CLT, confidence intervals (intuition)

Maximum likelihood & MAP estimation

Hypothesis testing & common pitfalls (p-hacking, multiple tests)

Programming for ML (Python ecosystem)

5 subtopics

Python, NumPy arrays, vectorization

Pandas for tabular data: joins, groupby, missing values

Plotting & diagnostics (matplotlib/seaborn)

scikit-learn API: estimators, pipelines, transformers

Basic software engineering: packaging, tests, typing, notebooks vs scripts

Data Preparation & Feature Engineering

6 subtopics

Data cleaning: duplicates, outliers, missingness mechanisms

Encoding categorical variables (one-hot, target, embeddings)

Feature scaling & normalization (standardization, robust scaling)

Feature generation: interactions, polynomials, datetime, text basics

Dimensionality & curse of dimensionality (practical signs)

Train-time transforms vs serving-time transforms (feature parity)

Experimentation Basics (reproducibility)

4 subtopics

Version control for data/code (Git + data versioning concepts)

Random seeds, determinism, and run logging

Notebook hygiene & experiment notes

Baseline-first mindset & ablation studies

Chapter 2

Core ML Concepts & Workflow

Problem Framing & ML Use-Cases

4 subtopics

Types of ML problems (classification, regression, ranking, forecasting)

Choosing ML vs rules vs analytics; ROI & constraints

Label definition and label noise

Data collection plan & measurement (instrumentation)

Train/Validation/Test & Data Leakage

4 subtopics

Holdout splits vs cross-validation (when to use which)

Stratification, grouping, and time-aware splits

Leakage patterns in features, labels, and preprocessing

Data shift: covariate shift, concept drift, label shift

Loss Functions & Objective Design

4 subtopics

Common losses: MSE, MAE, log loss, hinge

Bias-variance tradeoff (practical intuition)

Surrogate losses & why we optimize them

Cost-sensitive learning & custom objectives

Regularization & Generalization

5 subtopics

Overfitting/underfitting diagnostics (learning curves)

L1/L2 regularization and sparsity

Early stopping & checkpoints

Dropout, data augmentation (when applicable)

Ensembles and why they generalize better

Model Selection & Hyperparameter Tuning

4 subtopics

Search strategies (grid, random, Bayesian optimization)

Hyperparameters vs parameters; what to tune first

Cross-validation pitfalls & nested CV

Pipelines for tuning without leakage

Evaluation Metrics & Error Analysis

5 subtopics

Classification metrics: precision/recall/F1, ROC-AUC, PR-AUC

Regression metrics: RMSE/MAE/R2 and residual analysis

Calibration, thresholding, and decision curves

Error analysis: slicing, confusion matrix deep-dives

Uncertainty estimation basics (aleatoric vs epistemic)

Chapter 3

Supervised Learning

Linear Models (regression & classification)

4 subtopics

Ordinary least squares & gradient-based fitting

Logistic regression: odds, logits, decision boundary

Regularized linear models (ridge, lasso, elastic net)

↗ Common losses: MSE, MAE, log loss, hinge (see Chapter 2)

Tree-Based Models

5 subtopics

Decision trees: splitting criteria, depth, pruning

Random forests: bagging, feature subsampling

Gradient boosting: XGBoost/LightGBM/CatBoost concepts

Feature importance & SHAP-style explanations (practical use)

Tuning boosted trees: learning rate, depth, subsampling

Support Vector Machines & Kernels

4 subtopics

Max-margin intuition & soft margin (C)

Kernel trick and common kernels

SVM for classification vs SVR for regression

When SVMs work well vs fail (scaling, interpretability)

Instance-Based & Probabilistic Baselines

4 subtopics

k-NN: distance metrics, scaling sensitivity

Naive Bayes (text-friendly baseline)

Linear discriminant analysis (LDA) intuition

Baseline models & sanity checks for supervised learning

Imbalanced Learning & Calibration

4 subtopics

Imbalanced strategies: class weights, resampling, focal loss (idea)

Precision-recall tradeoffs and selecting thresholds

Probability calibration (Platt scaling, isotonic regression)

Evaluation under imbalance (PR-AUC, costs, stratified CV)

Time Series Supervised Learning

4 subtopics

Time series basics: stationarity, trend/seasonality, autocorrelation

Feature engineering for forecasting (lags, rolling stats, calendar)

Backtesting & time series cross-validation

Forecast evaluation metrics (sMAPE, MASE) and pitfalls

Supervised Learning Practice Projects

6 subtopics

Project: Kaggle-style tabular classification with strong baseline + tuning

Project: Regression with noisy labels (robust loss + diagnostics)

100

Project: Interpretability report for a tree model (SHAP/feature importance)

101

Project: Imbalanced classification (calibration + threshold selection)

102

Project: Time series forecasting with proper backtesting

103

Project: Build an end-to-end scikit-learn Pipeline + model card

Chapter 4

Unsupervised, Self-Supervised & Representation Learning

104

Clustering

4 subtopics

105

k-means: objective, initialization, choosing k

106

Gaussian Mixture Models (EM) intuition

107

Hierarchical clustering and linkage choices

108

Cluster validation and interpretation (silhouette, stability)

109

Dimensionality Reduction

4 subtopics

110

PCA: variance maximization, whitening (intuition)

111

t-SNE/UMAP: visualization vs modeling cautions

112

Autoencoders as learned representations (basic idea)

113

Choosing dimensionality and avoiding information leakage

114

Anomaly & Novelty Detection

4 subtopics

115

Density-based anomaly detection (Gaussian, KDE) basics

116

Isolation Forest and one-class SVM (idea + tradeoffs)

117

Evaluation of anomalies without labels (proxies, human-in-the-loop)

118

Practical pitfalls: contamination, drift, seasonality

119

Recommender Systems Basics

4 subtopics

120

Collaborative filtering basics (user-item matrix)

121

Matrix factorization intuition and implicit feedback

122

Ranking metrics (NDCG, MAP) and offline evaluation

123

Cold start and hybrid recommenders (content + CF)

124

Self-Supervised Learning (core ideas)

4 subtopics

125

Pretext tasks & augmentations (contrastive, masked modeling)

126

Contrastive learning: positives/negatives, temperature

127

Representation evaluation: linear probe & transfer learning

128

Common failure modes: collapse, shortcuts, leakage

129

Unsupervised Learning Practice Projects

6 subtopics

130

Project: Customer segmentation with clustering + narrative insights

131

Project: Dimensionality reduction for visualization with proper interpretation

132

Project: Anomaly detection for system logs (evaluation plan included)

133

Project: Build a simple movie recommender with offline ranking evaluation

134

Project: Train an autoencoder for representations + downstream classifier

135

Project: Self-supervised pretraining on images or text + transfer to a task

Chapter 5

Deep Learning & Modern Architectures

136

Neural Network Fundamentals

5 subtopics

137

Perceptrons, activations, and universal approximation (intuition)

138

Backprop in practice: computation graphs & autograd

139

Initialization (Xavier/He) and why it matters

140

Batching, epochs, and gradient noise

↗ Gradient descent variants (SGD, momentum, Adam) (see Chapter 1)

141

Training Deep Networks

6 subtopics

142

Normalization layers (BatchNorm, LayerNorm) and effects

143

Learning rate schedules and warmup

144

Overfitting controls for deep nets (augmentation, dropout, weight decay)

145

Mixed precision training (fp16/bf16) basics

146

Debugging training: exploding/vanishing gradients, NaNs, dead ReLUs

147

Generalization in deep learning (double descent, inductive bias) overview

148

Convolutional Neural Networks (Vision)

4 subtopics

149

Convolutions, padding/stride, receptive fields

150

Classic CNN blocks: pooling, residuals, depthwise separable convs

151

Vision data augmentation and transfer learning

152

Evaluation for vision (top-k, mAP) and common pitfalls

153

Sequence Models (RNNs, LSTMs)

4 subtopics

154

Sequence modeling basics: teacher forcing, exposure bias

155

LSTMs/GRUs: gates and long-term dependencies

156

Sequence-to-sequence and attention (pre-transformer view)

157

When to use RNNs vs Transformers in practice

158

Transformers (NLP & beyond)

5 subtopics

159

Self-attention, positional encodings, multi-head attention

160

Transformer training: masking, causal vs encoder-decoder objectives

161

Fine-tuning vs prompting vs adapters/LoRA (overview)

162

Tokenization basics and context windows

163

Evaluation for NLP (BLEU/ROUGE vs task metrics) + hallucination awareness

164

Generative Modeling

4 subtopics

165

Autoregressive models and likelihood-based generation

166

Variational autoencoders (VAE) intuition

167

GANs: generator/discriminator game and stability issues

168

Diffusion models basics (denoising, sampling) overview

169

Deep Learning Practice Projects

6 subtopics

170

Project: Image classifier with transfer learning + robust evaluation

171

Project: Train a small transformer for text classification

172

Project: Fine-tune a pretrained model and write an evaluation report

173

Project: Build an embedding search / semantic retrieval demo

174

Project: Train a simple diffusion or GAN on a toy dataset

175

Project: Reproduce a paper result on a small dataset (with ablations)

Chapter 6

ML Engineering, Deployment & Responsible AI

176

ML System Design & Data Pipelines

5 subtopics

177

Data ingestion and validation (schemas, checks)

178

Feature stores & offline/online consistency (concepts)

179

Batch vs streaming pipelines; latency and freshness tradeoffs

180

Training pipelines: orchestration and retries (concepts)

181

System design: SLAs/SLOs, fallbacks, and graceful degradation

182

Deployment, Inference & Monitoring

6 subtopics

183

Packaging models for serving (serialization, preprocessing)

184

Serving patterns: online, batch, edge; choosing the right one

185

Monitoring: data drift, concept drift, performance degradation

186

A/B testing and experimentation in production

187

Incident response for ML systems (rollbacks, guardrails)

188

Human-in-the-loop review and feedback loops

189

MLOps & Experiment Tracking

5 subtopics

190

Experiment tracking tools concepts (metrics, artifacts, lineage)

191

Model registry & lifecycle (staging, prod, rollback)

↗ Version control for data/code (Git + data versioning concepts) (see Chapter 1)

192

CI/CD for ML (tests for data, features, models)

193

Reproducible training with containers (Docker basics for ML)

194

Performance, Scaling & Hardware Basics

4 subtopics

195

Compute basics: CPU vs GPU vs TPU; memory bandwidth

196

Profiling training/inference and finding bottlenecks

197

Distributed training basics (data/model parallelism concepts)

198

Inference optimization: batching, quantization, caching

199

Privacy & Security in ML

4 subtopics

200

Privacy basics: PII, de-identification limits, governance

201

Differential privacy (high-level) and tradeoffs

202

Adversarial examples and robustness overview

203

Secure ML pipelines: secrets, access control, supply chain risks

204

Fairness, Accountability & Transparency

4 subtopics

205

Bias sources: data, labels, measurement, objectives

206

Fairness metrics and tradeoffs (group vs individual)

207

Explainability: global vs local, pitfalls, stakeholder needs

208

Documentation: datasheets, model cards, and audit trails

209

ML Productization & Communication

4 subtopics

210

Communicating results: plots, baselines, and uncertainty

211

Writing a technical ML report (structure + reproducibility checklist)

212

Choosing deployment constraints: latency, cost, privacy, UX

213

Stakeholder alignment: success metrics, guardrails, and iteration plan