Categories › ML Foundations
ML Foundations
The math, statistics, and classical ML you keep reaching for when models stop behaving.
Linear algebra and probability at the depth an engineer actually uses, the supervised and unsupervised learning loop, evaluation and error analysis, feature engineering and leakage, and the debugging habits that separate people who can train a model from people who can fix one.
57 posts, from beginner to advanced. Each ends with what to read next.
Model Selection Guide: When to Use Which ML Algorithm
A practical decision framework for choosing the right machine learning algorithm - from linear models to gradient boosting to neural networks - based on your data, constraints, and goals.
Evaluation Metrics Guide: Which Metric to Use and When
Accuracy is rarely the right metric. This guide explains every major ML evaluation metric - classification, regression, ranking, and generation - with clear guidance on when to use each one.
Python ML Quick Reference
The NumPy, Pandas, and scikit-learn one-liners you reach for every day - organized by task so you spend less time searching and more time building.
Math for ML: The Cheat Sheet Every Practitioner Needs
The math you actually use in ML - vectors, matrices, gradients, probability, and the key calculus rules - distilled into a single reference you can return to again and again.
Backpropagation: The Intuition You Need Before the Math
Backpropagation is how neural networks compute gradients across many layers. The math is chain rule. The intuition is fault attribution - which weights caused the error?
Why Loss Functions Matter and How to Choose One
The loss function determines what your model is actually optimizing for. Wrong choice = optimizing for the wrong thing. This post explains the options and how to decide.
ML Glossary: Terms Every Practitioner Should Know
A practical reference glossary of ML terms - not textbook definitions, but the way these concepts are used in real engineering conversations and decisions.
The Train / Val / Test Split: Common Mistakes
Getting the data split right is the foundation of honest ML evaluation. These are the most common ways teams get it wrong - and what to do instead.
Regularization: L1, L2, and Dropout Without the Formulas
Models that overfit memorize training data instead of learning patterns. Regularization prevents this. This post explains the three main techniques and when to use each.
Embeddings: What They Are and Why They Work
Embeddings are the foundation of modern NLP and recommendation systems. This post explains the core idea, why it works, and how to use them in practice.
Cross-Validation Done Right
Cross-validation is the standard for honest model evaluation - but only when done correctly. This post covers the what, why, and the leakage mistakes that invalidate it.
The Bias - Variance Tradeoff: What It Actually Means
High bias or high variance - the two ways a model can fail. This post explains what they are, why they trade off, and how to diagnose which problem you have.
Gradient Descent Explained From Scratch
Gradient descent is the engine behind every trained neural network. This post builds it up from the intuition of walking downhill to the code that makes it work.
Model Evaluation and Experiment Tracking
Evaluation is harder than training. This guide covers choosing the right metrics, understanding confidence intervals in model comparison, A/B testing discipline, and experiment tracking that makes ML work reproducible and auditable.
Unsupervised Learning and Recommendation Basics
Clustering, dimensionality reduction, embeddings, and the fundamentals of recommendation systems - when you have no labels and still need to make decisions.
Linear Algebra for Gradient Descent
How vector geometry, scaling, and conditioning shape training behavior in real ML systems.
Data Cleaning and Feature Engineering
Better data beats better algorithms every time. This guide covers missing values, outliers, categorical encoding, feature engineering, and the silent killer - data leakage.
Experiment Tracking and Reproducibility Systems
Design a lightweight but serious reproducibility system for ML runs, artifacts, configs, and promotions.
Python for ML: Practical Workflow
Python for ML is not the same as Python for web dev. This guide covers the environment setup, project structure, notebook discipline, and workflow habits that actually matter in production ML teams.
Leakage-Proof Feature Pipelines
Turn feature engineering from a notebook habit into a disciplined contract with train/serve parity and leakage defenses.
Math and Stats for Machine Learning
Build the math intuition that makes ML make sense - linear algebra, probability, calculus, and statistics explained as engineering tools, not abstract theory.
Evaluation Metrics and Error Analysis Systems
Build a model evaluation practice that goes beyond leaderboard numbers into cohort behavior, threshold policy, and deployment risk.
Unsupervised Learning, Representation, and Dimensionality Reduction
Broaden intuition beyond supervised learning and prepare for embeddings and representation-focused systems.
Model Debugging and Error Analysis
Teach systematic debugging of poor models using slices, residuals, and ablations.
Evaluation, Metrics, and Experimental Design
Show how to decide what good means before training and how to design honest experiments.
Feature Engineering and Data Leakage Defense
Teach the practical levers that often matter more than algorithm novelty in real datasets.
Classical ML Algorithms and When to Use Them
Build model selection judgment so learners can choose strong baselines before chasing complexity.
Supervised Learning Foundations
Enter real machine learning with train-validation-test discipline and core supervised concepts.
Scikit-learn Pipelines, Reproducibility, and ML Project Structure
Bridge engineering discipline and ML lifecycle basics through reproducible project organization.
Data Visualization and Exploratory Analysis With Judgment
Use EDA to generate hypotheses, detect leakage, and guide modeling choices instead of plotting aimlessly.
ML Debugging and Iteration Loops
Teach systematic improvement loops for failing models.
Software Engineering Fundamentals for Data and ML Projects
Teach students to organize ML code with testing, logging, config discipline, and refactoring habits.
Evaluation, Experimentation, and Decision Metrics
Train engineers to define metrics, uncertainty, and experiment framing before shipping models.
SQL for Analytics and ML Pipelines
Teach the SQL needed to extract, validate, and aggregate data for ML systems.
Classical ML Model Selection and Feature Engineering
Teach practical model choice and the non-deep-learning strength most real products still rely on.
NumPy, Pandas, and Data Manipulation for Model Building
Turn messy data into reliable model inputs with vectorized operations and leakage awareness.
Supervised Learning End to End
From problem framing to a defensible model: the complete supervised ML loop - baselines, model selection, evaluation, debugging, and the iteration discipline that separates good ML engineers from great ones.
Math for ML III: Calculus, Optimization, and Gradients
Build enough calculus to understand loss surfaces, gradient descent, and training dynamics.
Data Workflows: NumPy, Pandas, SQL, and Data Quality
Make experienced engineers comfortable with messy data, joins, missingness, and validation workflows.
Math for ML II: Probability, Statistics, and Uncertainty
Teach probabilistic thinking so evaluation and experiments are not reduced to naive metric chasing.
Math and Statistics for Practical ML Judgment
Teach only the math that materially improves engineering decisions in ML systems.
Math for ML I: Linear Algebra That Actually Matters
Cover the linear algebra needed to understand embeddings, projections, and model internals.
Python for Experienced Engineers
Compress Python onboarding for engineers who already know how to program well.
Linux, Git, CLI, and Reproducible Dev Environments
Build terminal, version control, and environment habits that make ML work reproducible.
ML for Software Engineers: Mental Model Reset
Reset software-first instincts so the learner can reason about data-dependent, probabilistic systems.
Python for ML Engineers, Not Just Programmers
Move from toy Python usage to engineering-grade Python that can support real ML work.
Milestone Gate 1: ML Core Transition
Assess core transition readiness from SWE to applied ML engineering.
Training Pipelines and Experiment Strategy
Build training pipelines and experiment strategy for fast, trustworthy iteration.
Data Contracts, Quality, and Features
Design resilient data contracts and feature standards that reduce production breakage.
Applied Stats for Engineering Decisions
Use statistical reasoning to make better product and model decisions under uncertainty.
Python for ML Bridge for SWE
Translate software engineering strengths into ML workflows with disciplined experimentation.
Milestone Gate 1: Foundations Validation
A timed gate to validate core ML foundations before moving to model architecture depth.
Unsupervised + Recsys Foundations (Deep)
Build practical expertise in clustering, embeddings, retrieval signals, and ranking foundations for recommendation systems.
Supervised Learning End-to-End (Deep)
Run supervised ML with baselines, disciplined experiments, error analysis, and production-aware decisions.
Data Cleaning and Feature Engineering (Deep)
Build leakage-safe data pipelines and features that behave the same way in training and production.
Python for ML Workflow (Deep)
Build a production-grade ML project workflow with reproducibility, experiment lineage, and deployment-ready structure.
Math and Stats for ML (Deep)
Use linear algebra, probability, and optimization to reason about model behavior instead of treating libraries as black boxes.