Classical MLbeginnermust-know4 min

Bias–Variance Tradeoff

How to fix a model that makes bad predictions using simple error tuning.

When a machine learning model makes mistakes, the errors come from three main sources. First, bias happens when a model is too simple and misses the real pattern completely. Second, variance happens when a model is too complex and memorizes random noise instead of learning general patterns. Third, irreducible noise comes from unavoidable random mistakes in the data itself. Finding the right balance means tweaking model size until predictions are accurate on new data.

Read the deep dive →
Classical MLbeginnermust-know3 min

Overfitting vs Underfitting

Everyone can define it. Fewer can diagnose it from a learning curve.

Overfitting is learning the training set's noise as if it were signal — training error keeps dropping while validation error rises. Underfitting is failing to learn the signal at all — both errors stay high and close together. Detect it by tracking both curves as a function of training set size and epochs. Fix overfitting with more data, regularization, augmentation and early stopping; fix underfitting with capacity, features and longer training.

Read the deep dive →
Classical MLbeginnermust-know4 min

Linear Regression

Simple on paper, brutal in interviews. Most candidates fail when asked to derive OLS or explain heteroscedasticity.

Linear Regression models continuous targets as y = Xβ + ε. Ordinary Least Squares (OLS) minimizes squared residuals, yielding the closed-form solution β = (XᵀX)⁻¹Xᵀy. Under the Gauss-Markov assumptions, OLS is the Best Linear Unbiased Estimator (BLUE). Key interview topics include closed-form derivation, assumption validation, multicollinearity, and OLS vs Gradient Descent trade-offs.

Read the deep dive →
Classical MLbeginnermust-know4 min

Logistic Regression

The baseline classifier every ML candidate is expected to derive on a whiteboard.

Logistic Regression models binary probabilities using the Sigmoid activation: P(y=1|x) = σ(wᵀx + b). It maps linear log-odds to [0, 1]. Because OLS yields non-convex loss for probabilities, we use Binary Cross-Entropy (Log Loss), optimized iteratively via Gradient Descent or L-BFGS. Key interview topics include log-odds interpretation, loss derivation, linear decision boundaries, and multi-class extension via Softmax.

Read the deep dive →
Classical MLbeginnermust-know5 min

Cross-Validation Done Right

Evaluating model generalization accuracy across K-Fold, Stratified, Group, and Time Series validation splits.

Cross Validation evaluates how a machine learning model generalizes to unseen test data by partitioning training datasets into multiple validation splits. Standard K-Fold splits data into K equal folds. Stratified K-Fold preserves class label proportions across folds, essential for imbalanced classification. Group K-Fold prevents data leakage by ensuring all samples from a specific subject or user stay in the same fold. Time Series Split respects temporal causality, using past data to predict future time steps.

Read the deep dive →
Deep Learningbeginnermust-know4 min

Activation Functions

How non linear activation functions turn simple linear math into powerful deep learning models.

Activation functions introduce non linearity into neural networks, allowing them to learn complex non linear patterns. Without non linear activation steps, a multi layer neural network collapses into a simple linear model regardless of depth. Common activations include Sigmoid for probabilities between 0 and 1, Tanh for zero centered signals between minus 1 and plus 1, ReLU for fast computation, and GELU for modern transformer architectures.

Read the deep dive →
Deep Learningbeginnermust-know4 min

Dropout

Preventing neural network overfitting by randomly turning off neurons during training.

Dropout (Srivastava et al., 2014) is a popular regularization technique for neural networks. During training, dropout randomly deactivates a fraction p of hidden neurons at each forward step. This forces the network to learn redundant feature representations instead of relying on fragile co adaptations between specific neurons. During inference evaluation, all neurons remain active, and weights are scaled by 1 minus p so output magnitude stays constant.

Read the deep dive →
Metrics & Evaluationbeginnermust-know4 min

Precision, Recall & F1

Understanding the difference between catching every positive case and avoiding false alarms.

Precision measures how often your model is right when it flags something as positive. Recall measures how many of the actual positive cases your model managed to find. Raising precision usually lowers recall and vice versa. Choosing which metric matters most comes down to understanding which type of mistake causes more real world harm.

Read the deep dive →
Metrics & Evaluationbeginnermust-know4 min

Why Accuracy Lies

Why 99 percent accuracy can trick you into keeping a completely useless machine learning model.

The accuracy trap happens when you use simple accuracy to judge a model on unbalanced datasets. In a rare disease dataset where 99 percent of people are healthy, a simple guessing model that predicts healthy for everyone achieves 99 percent accuracy while missing every single sick person. Solving this problem requires switching to metrics like precision, recall, and cost matrices.

Read the deep dive →
Data & Feature Engineeringbeginnermust-know4 min

Feature Engineering Fundamentals

Better data beats fancy algorithms. Where 80% of real-world model accuracy improvements actually come from.

Feature engineering extracts predictive signals from raw data. Techniques must match the target model family: tree-based models need minimal scaling but benefit from target stats and ratios; linear/neural models require strict feature scaling, one-hot encoding, and non-linear log or cyclical transforms (sin/cos). Key topics include handling missingness, high-cardinality encodings, interaction features, and preventing target leakage.

Read the deep dive →
Responsible AI & Behaviouralbeginnermust-know5 min

Telling Your ML Project Story

Structuring impactful machine learning project stories using the STAR method to demonstrate technical leadership.

Telling Your ML Project Story covers behavioral interview techniques for machine learning engineers. Interviewers use project walkthrough questions to evaluate technical depth, system design intuition, business impact, and problem solving under constraints. Structuring responses using the Situation, Task, Action, and Result (STAR) framework ensures clear, compelling communication of technical achievements.

Read the deep dive →
Classical MLintermediatemust-know5 min

L1 vs L2 Regularization

Preventing model overfitting by penalizing large parameter weights using L1 Lasso and L2 Ridge penalties.

L1 (Lasso) and L2 (Ridge) Regularization prevent machine learning models from overfitting by adding weight penalty terms to the loss function. L1 Regularization adds the absolute sum of weights |w|, driving irrelevant feature weights to exact zero and performing automatic feature selection. L2 Regularization adds the squared sum of weights w^2, shrinking weight magnitudes smoothly without driving them to exact zero.

Read the deep dive →
Classical MLintermediatemust-know4 min

Gradient Descent & Its Variants

Comparing Batch, Stochastic, and Mini Batch Gradient Descent optimization strategies.

Gradient Descent is an optimization algorithm that iteratively minimizes a loss function by taking steps in the direction of steepest descent. Batch Gradient Descent calculates loss over the entire dataset before making one weight update. Stochastic Gradient Descent (SGD) updates weights after every single data sample. Mini Batch Gradient Descent updates weights after small batches of samples (such as size 32 to 256), combining hardware efficiency with gradient noise regularization.

Read the deep dive →
Classical MLintermediatemust-know5 min

Bagging vs Boosting

Contrasting parallel variance reduction in Bagging against sequential bias reduction in Boosting.

Bagging and Boosting are the two dominant ensemble learning paradigms in machine learning. Bagging (Bootstrap Aggregating) trains independent complex base models in parallel on random data subsets to reduce variance (Random Forest). Boosting trains simple weak base models sequentially, focusing each new model on errors made by previous models to reduce bias (AdaBoost, XGBoost).

Read the deep dive →
Classical MLintermediatemust-know5 min

Principal Component Analysis

Compressing high dimensional data into orthogonal principal components while maximizing preserved variance.

Principal Component Analysis (PCA - Pearson, 1901) is an unsupervised linear dimensionality reduction algorithm. PCA finds orthogonal linear combinations of features (Principal Components) that maximize data variance. It computes the covariance matrix of mean centered data, calculating eigenvectors (component directions) and eigenvalues (component variance magnitude) to project high dimensional data into lower dimensions.

Read the deep dive →
Classical MLintermediatemust-know5 min

Handling Imbalanced Datasets

Techniques for handling severe class imbalances in fraud, medical, and anomaly detection models.

Class Imbalance occurs when majority classes dominate minority target classes (e.g. 99.9% non-fraud vs 0.1% fraud). Standard models achieve 99.9% dummy accuracy by predicting majority class everywhere while completely missing minority events. Solutions include Resampling (Random Undersampling, SMOTE oversampling), Cost Sensitive Learning (class weighting, Focal Loss), and evaluating via PR-AUC and F1-Score rather than raw Accuracy.

Read the deep dive →
Deep Learningintermediatemust-know5 min

Backpropagation

The engine of deep learning. Most candidates know the intuition; few can trace matrix dimensions correctly.

Backpropagation computes gradients of scalar loss L with respect to all network weights W using the multivariable chain rule in reverse mode. Running backwards from output to input computes all ∂L/∂W in O(W) operations, whereas finite differences or forward-mode differentiation require O(W²) complexity. Key interview topics include computational graphs, local gradients, error signals (δ), and matrix shape matching.

Read the deep dive →
Deep Learningintermediatemust-know4 min

Vanishing & Exploding Gradients

Why deep neural networks fail when gradients shrink to zero or explode to infinity during backpropagation.

Vanishing and Exploding Gradients are major training instabilities in deep neural networks and recurrent models. The chain rule multiplies local derivatives across layers during backpropagation. If local derivatives are smaller than 1, multiplying them repeatedly causes gradients to shrink exponentially toward zero, preventing early layers from learning. If local derivatives are larger than 1, gradients grow exponentially, causing weight instability or NaN overflow.

Read the deep dive →
Deep Learningintermediatemust-know5 min

Batch Normalization

Accelerating deep network training by stabilizing layer input distributions across mini batches.

Batch Normalization (Ioffe and Szegedy, 2015) normalizes layer activations across mini batch samples during training. It computes mean and variance for each feature dimension over the mini batch, standardizes activations to zero mean and unit variance, and applies learned scale and shift parameters. Batch Normalization smooths the loss landscape, acts as a mild regularizer, and enables higher learning rates without exploding gradients.

Read the deep dive →
Deep Learningintermediatemust-know5 min

SGD, Momentum, Adam & AdamW

How optimizers update neural network weights from basic SGD to Momentum and AdamW.

Optimizers adjust neural network weights to minimize loss. Stochastic Gradient Descent (SGD) updates weights along the negative loss gradient. SGD with Momentum adds a velocity vector to smooth updates and push past small local bumps. Adam tracks both first moments (momentum) and second moments (uncentered variance) per weight. AdamW fixes weight decay regularization in Adam by applying weight decay directly to parameters rather than mixing it into momentum.

Read the deep dive →
Deep Learningintermediatemust-know4 min

Transfer Learning & Fine-Tuning

Leveraging pre-trained representations from massive datasets to achieve state-of-the-art results on small target tasks.

Transfer Learning adapts a model pretrained on a large source dataset (ImageNet, C4, Wikipedia) to a specific target task. Strategies range from Feature Extraction (freezing backbone weights and training a new linear classification head) to Full Fine-Tuning and Parameter-Efficient Fine-Tuning (PEFT / LoRA). Key decision factors include target dataset size and domain similarity to the source data.

Read the deep dive →
Deep Learningintermediatemust-know5 min

Debugging a Training Run

Systematic protocols for diagnosing exploding gradients, loss spikes, and silent bugs in neural network training.

Debugging a Training Run requires a structured diagnostic protocol to isolate bugs in data pipelines, loss functions, and model architectures. Key steps include overfitting a single batch of 10 samples to zero loss, verifying loss values at step zero, monitoring gradient norms, checking for NaN/Inf floats, and inspecting activation statistics. Systematic debugging prevents wasted GPU compute costs and resolves training stalls quickly.

Read the deep dive →
NLP & Transformersintermediatemust-know5 min

The Attention Mechanism

How dynamic weighting allows models to focus on relevant context across long sequences.

The Attention Mechanism (Bahdanau et al., 2014; Vaswani et al., 2017) allows neural networks to dynamically weight and focus on relevant parts of an input sequence. Instead of compressing an entire sequence into a single static context vector, Attention computes dynamic alignment scores between Query, Key, and Value vectors. Scaled Dot Product Attention calculates Attention(Q, K, V) = Softmax( Q K^T / sqrt(d_k) ) V, forming the core foundation of modern Transformer language models.

Read the deep dive →
NLP & Transformersintermediatemust-know5 min

Transformer Architecture

How parallel self attention blocks replaced recurrent loops to power modern AI.

The Transformer Architecture (Vaswani et al., 2017 - Attention Is All You Need) revolutionized artificial intelligence. By replacing sequential recurrent loops with parallel self attention mechanisms, Transformers allow GPUs to process entire text sequences simultaneously in parallel. The architecture consists of an Encoder stack (Multi Head Self Attention + Feed Forward layers) and a Decoder stack (Causal Masked Self Attention + Cross Attention + Feed Forward layers), connected by residual skip connections and layer normalization.

Read the deep dive →
NLP & Transformersintermediatemust-know5 min

Tokenization & BPE

Converting raw text strings into numerical subword tokens using Byte Pair Encoding.

Tokenization breaks raw text strings into numerical token IDs that neural networks can process. Character level tokenization creates tiny vocabularies but long sequences. Word level tokenization creates huge vocabularies with frequent out of vocabulary errors. Byte Pair Encoding (BPE) is a subword tokenization algorithm that iteratively merges the most frequent pairs of adjacent bytes or characters. BPE balances vocabulary size and sequence length, handling rare words and code efficiently without out of vocabulary errors.

Read the deep dive →
NLP & Transformersintermediatemust-know5 min

BERT vs GPT: Encoder vs Decoder

Contrasting bidirectional encoder understanding models against causal decoder autoregressive generation models.

BERT and GPT represent the two foundational paradigms of modern Transformer models. BERT (Devlin et al., 2018) is an Encoder Only model trained with Masked Language Modeling to look at past and future context simultaneously, excelling at text understanding, classification, and search embeddings. GPT (Radford et al., 2018) is a Decoder Only model trained with Causal Next Token Prediction to process text left to right, excelling at open ended text generation.

Read the deep dive →
LLMs & GenAIintermediatemust-know5 min

Pretraining → SFT → RLHF

Mapping the three stage lifecycle of building production Large Language Models from raw pretraining to alignment.

Building modern production Large Language Models involves three sequential training stages: Pretraining, Supervised Fine Tuning (SFT), and Reinforcement Learning from Human Feedback (RLHF / DPO). Pretraining consumes trillions of web text tokens via next token prediction to build raw world knowledge. SFT fine-tunes base models on high quality instruction prompt-response pairs to learn conversational formatting. RLHF / DPO aligns models with human preferences for helpfulness, honesty, and safety.

Read the deep dive →
LLMs & GenAIintermediatemust-know5 min

Fine-Tune vs RAG vs Prompt: Choosing

Evaluating trade-offs between Prompt Engineering, RAG, and Fine-Tuning for enterprise LLM systems.

Choosing between Prompt Engineering, RAG, and Fine Tuning depends on task requirements. Prompt Engineering adapts baseline LLM behavior quickly using zero shot instructions. Retrieval Augmented Generation (RAG) injects dynamic, up to date external knowledge into context to prevent hallucinations and cite sources. Fine Tuning modifies model weights to internalize specific formatting, style, tone, or specialized domain syntax.

Read the deep dive →
LLMs & GenAIintermediatemust-know5 min

Retrieval-Augmented Generation

Combining dense vector retrieval with LLM generation to answer questions using ground truth enterprise knowledge.

Retrieval Augmented Generation (RAG - Lewis et al., 2020) connects Large Language Models to external knowledge bases. A RAG pipeline retrieves relevant document chunks from a vector database using dense embedding similarity and inserts them directly into the LLM prompt context. RAG eliminates hallucinations, provides source citations, and allows live data updates without retraining model weights.

Read the deep dive →
LLMs & GenAIintermediatemust-know5 min

Why LLMs Hallucinate

Understanding root causes of un-grounded factual errors in autoregressive language generation.

Hallucination refers to instances where Large Language Models generate un-grounded, factually incorrect, or contradictory text with high confidence. Root causes include next token prediction probability sampling, noisy pretraining data, parametric memory degradation, and exposure bias during autoregressive decoding. Mitigations include RAG vector grounding, Chain of Thought reasoning, constrained decoding, self-consistency sampling, and external fact verification.

Read the deep dive →
Reinforcement Learningintermediatemust-know5 min

Value-Based vs Policy-Based Methods

Comparing the two core families of Reinforcement Learning algorithms: learning action values vs directly optimizing policy parameters.

Reinforcement Learning algorithms divide into Value-Based methods (Q-Learning, DQN) and Policy-Based methods (REINFORCE, PPO). Value-based methods learn action-value function Q(s, a), deriving implicit greedy policies a = argmax_a Q(s, a). Policy-based methods parameterize policy π_θ(a|s) directly, optimizing parameters θ via gradient ascent on expected return. Actor-Critic methods combine both: an Actor policy π_θ(a|s) and a Critic value function V_ϕ(s).

Read the deep dive →
Reinforcement Learningintermediatemust-know4 min

Multi-Armed Bandits

Optimizing online decision-making when actions yield stochastic rewards without full sequential state transitions.

A Multi-Armed Bandit (MAB) is a simplified Reinforcement Learning framework where an agent chooses among K independent actions ("arms") to maximize cumulative reward. Unlike full MDPs, bandits have no state transitions—each action choice is stateless and independent. MABs replace traditional static A/B testing in digital marketing, ad click optimization, and website UI layout experiments by dynamically routing traffic to high-performing variations while continuously testing alternatives.

Read the deep dive →
RecSys & Searchintermediatemust-know5 min

Collaborative Filtering

Recommending items based on past user interaction patterns without requiring manual item metadata.

Collaborative Filtering (CF) recommends items to users by leveraging preference patterns from a crowd of similar users or items. User-Based CF finds users with similar interaction histories; Item-Based CF finds items co-liked by the same users. Matrix Factorization (SVD / ALS) decomposes the sparse User-Item interaction matrix R (N × M) into low-rank user matrices U (N × k) and item matrices V (M × k), predicting unobserved ratings as R_ui ≈ u_i · v_j.

Read the deep dive →
RecSys & Searchintermediatemust-know4 min

The Cold Start Problem

How to recommend items or personalize feeds when zero interaction history exists for new users or items.

The Cold-Start Problem occurs in recommender systems when a new user joins (User Cold Start) or a new item is uploaded (Item Cold Start), resulting in zero historical interaction logs. Because Collaborative Filtering relies on interaction history, pure CF models fail. Production solutions include Content-Based embeddings (extracting text/image features via Multimodal models), Hybrid Architectures, Active Learning onboarding surveys, and Multi-Armed Bandit exploration algorithms (Epsilon-Greedy, Thompson Sampling).

Read the deep dive →
ML System Designintermediatemust-know5 min

A Framework for Any ML Design Round

The 45-minute whiteboard round that determines your engineering level at tier-1 tech companies.

ML System Design interviews evaluate end-to-end architectural thinking. To succeed, use a structured 6-step framework: Clarify Problem & Business Metrics -> Data Ingestion & Features -> Baseline & Model Design -> Offline/Online Evaluation -> Serving & Latency Budget -> Monitoring & Feedback Loops. Always lead with simple heuristics before complex deep learning, and state tradeoffs out loud.

Read the deep dive →
ML System Designintermediatemust-know5 min

Framing a Business Problem as ML

Translating ambiguous business goals into clear machine learning problem formulations and optimization targets.

Problem Framing translates vague real world business objectives into concrete machine learning problems. Key steps include identifying the core prediction target, defining input features and output labels, selecting appropriate loss functions, and establishing metrics that align model performance directly with business KPIs. Proper framing prevents building models that optimize high accuracy while completely failing business goals.

Read the deep dive →
ML System Designintermediatemust-know5 min

Online vs Offline Evaluation

Why a model with stellar offline AUC can fail completely when deployed to real production users.

Evaluating ML systems requires a two-stage process: Offline Evaluation on historical datasets (ROC-AUC, NDCG, RMSE) and Online Evaluation on live production traffic (A/B testing, CTR, Conversion Rate, Latency). A major challenge in applied ML is offline-online metric misalignment, caused by position bias, selection bias, feedback loops, and static offline data failing to capture dynamic user behavioral reactions.

Read the deep dive →
ML System Designintermediatemust-know5 min

Batch vs Real-Time Inference

Choosing between scoring predictions one at a time in real time versus processing millions of predictions in bulk overnight.

Batch vs Real-Time Inference represents the fundamental serving architecture choice in production ML systems. Batch inference precomputes predictions for all users or items offline (e.g. nightly Spark jobs) and stores results for fast lookup. Real-time inference computes predictions on demand when a request arrives, using the freshest features. Many production systems use a hybrid approach combining both.

Read the deep dive →
ML System Designintermediatemust-know5 min

Training–Serving Skew

When a model performs great during offline training but fails in live production due to mismatched data or logic.

Training Serving Skew happens when the data or environment during live inference does not match what was used during model training. Common causes include calculating features differently in real time versus offline batch jobs, data leakage during training, or feature values changing between training and serving. Engineers prevent skew by using unified feature stores, shared feature transformation code, and point in time data logging.

Read the deep dive →
ML System Designintermediatemust-know5 min

Communicating Tradeoffs Out Loud

Articulating technical architectural choices, trade offs, and compromises clearly during system design interviews.

Communicating Tradeoffs Out Loud is a critical skill in machine learning system design interviews. Every technical design choice involves compromises between latency, accuracy, cost, memory, and operational complexity. Strong candidates state their architectural choices explicitly, explain why alternative approaches were rejected, and justify how their compromises serve business goals.

Read the deep dive →
MLOps & Productionintermediatemust-know4 min

Data Drift vs Concept Drift

Why models that hit 99% accuracy in offline testing decay silently 3 months after deployment.

Data Drift (Covariate Shift) occurs when feature input distributions P(X) change over time while target rules P(Y|X) remain fixed. Concept Drift occurs when the relationship between features and target P(Y|X) changes. Detecting drift requires statistical tests like Population Stability Index (PSI), Kolmogorov-Smirnov (KS) test, and adversarial drift classifiers. Mitigations range from feature re-scaling to retraining schedules.

Read the deep dive →
MLOps & Productionintermediatemust-know5 min

What to Monitor in Production

The core observability pillars required to detect model failure, data drift, and latency degradation in production.

Model Monitoring tracks the health of deployed ML systems across four distinct layers: Software System Metrics (Latency, QPS, Memory), Input Data Drift (Feature distribution PSI/KS-tests), Prediction Drift (Output score distribution shifts), and Model Quality (Ground-truth performance). When true labels arrive with long delays (e.g. 30-day loan defaults), input and prediction drift act as early proxy indicators of performance degradation.

Read the deep dive →
Metrics & Evaluationintermediatemust-know4 min

ROC-AUC vs PR-AUC

With 0.1% positives, ROC-AUC of 0.97 can mean a useless model.

ROC-AUC plots true positive rate against false positive rate across all thresholds and equals the probability the model ranks a random positive above a random negative. It is threshold-free and prevalence-independent — which is exactly its weakness. Because FPR's denominator is the huge negative class, thousands of false positives barely move it. PR-AUC uses precision, whose denominator is what you flagged, so it collapses honestly when the positive class is rare. Use PR-AUC for imbalanced problems.

Read the deep dive →
Metrics & Evaluationintermediatemust-know4 min

Data Leakage

0.99 AUC in the notebook, 0.61 in production. Every time, it's leakage.

Leakage is any information in training that will not be available at prediction time. It comes in three flavours: target leakage (a feature is a consequence of the label), train–test contamination (preprocessing or duplicate rows cross the split), and temporal leakage (training on the future). The symptom is performance that looks too good and collapses in production. The defences are a strict per-fold pipeline, point-in-time correct feature joins, and asking of every feature "would I have known this then?"

Read the deep dive →
Metrics & Evaluationintermediatemust-know4 min

Slice-Based & Subgroup Evaluation

Why evaluating global aggregate metrics masks severe model failures on critical sub-populations and demographic slices.

Slice-Based Evaluation (Subgroup Analysis) evaluates model performance independently across critical data subsets (e.g. device types, user cohorts, rare categories). A model with 95% global accuracy may suffer a catastrophic 40% failure rate on low-end Android phones or minority demographic slices. Best practices require defining key slices upfront, running automated slicing frameworks (DataSlice, SliceFinder), and enforcing minimum performance floors per slice.

Read the deep dive →
Metrics & Evaluationintermediatemust-know5 min

Mapping Model Metrics to Business Metrics

Translating mathematical loss functions and offline AUC into bottom-line revenue, conversion, and user retention.

Machine learning models optimize offline mathematical surrogate losses (Log Loss, MSE, Cross-Entropy), whereas businesses care about online KPIs (Revenue, Conversion Rate, Customer Acquisition Cost, User Retention). Aligning model metrics to business outcomes requires mapping offline error thresholds to dollar utility functions, calibrating output probabilities, and running controlled A/B experiment loops.

Read the deep dive →
Data & Feature Engineeringintermediatemust-know5 min

SQL Questions in ML Interviews

Mastering the window functions, aggregation patterns, and point-in-time joins tested in ML engineering loops.

SQL is the universal data querying language for building training datasets and feature stores. ML interview SQL questions evaluate your ability to compute sliding window aggregates (Window Functions `OVER()`), avoid data leakage via point-in-time joins, calculate user engagement metrics (DAU/MAU ratios, retention cohorts), and handle missing values (`COALESCE`) or un-nesting arrays (`EXPLODE / UNNEST`).

Read the deep dive →
Coding for MLintermediatemust-know5 min

Implement Linear Regression from Scratch

Building a complete Linear Regression model from scratch using NumPy vector operations and Gradient Descent.

Implement Linear Regression from Scratch demonstrates foundational machine learning coding fundamentals. The model fits a linear equation predicting continuous outputs by minimizing Mean Squared Error loss. The implementation covers weight and bias vector initialization, forward pass matrix multiplication, analytical prediction error calculation, and gradient descent backpropagation updates.

Read the deep dive →
Responsible AI & Behaviouralintermediatemust-know5 min

Bias & Fairness in ML

Identifying and mitigating algorithmic bias across protected demographic groups in production machine learning.

Model Bias and Fairness evaluate whether machine learning systems produce equitable predictions across protected sub-groups (e.g. race, gender, age). Bias enters pipelines through historical data sampling, proxy features (e.g. ZIP code encoding race), and label bias. Key fairness criteria—Demographic Parity, Equalized Odds, and Predictive Parity—are mathematically incompatible (Impossibility Theorem of Fairness), requiring explicit product trade-offs across pre-processing, in-processing, and post-processing mitigation techniques.

Read the deep dive →
Responsible AI & Behaviouralintermediatemust-know4 min

Explainability: SHAP & LIME

Opening the black box: how game theory guarantees mathematically sound feature attribution in ML.

SHAP (SHapley Additive exPlanations) and LIME provide post-hoc model-agnostic explainability. SHAP is grounded in cooperative game theory, guaranteeing four essential axioms (Efficiency, Symmetry, Dummy, Additivity). SHAP computes a feature's marginal contribution across all feature subsets, ensuring local attributions sum up to (Model Output - Base Expected Value). TreeSHAP optimizes this to O(TL D²) for decision trees.

Read the deep dive →
Responsible AI & Behaviouralintermediatemust-know5 min

Explaining a Model to a Non-Technical Exec

Translating complex machine learning concepts into business impact, risk tradeoffs, and intuitive analogies for executive leaders.

Explaining a Model to a Non-Technical Exec evaluates communication clarity and business alignment. Technical executives care about revenue impact, risk mitigation, resource cost, and operational constraints rather than neural network mathematics or loss functions. Effective communication uses intuitive real-world analogies, translates metrics like Precision and Recall into dollars and risk, and focuses on actionable business outcomes.

Read the deep dive →
Classical MLadvancedmust-know5 min

Gradient Boosting (XGBoost/LightGBM)

Sequentially fitting decision trees to negative loss gradients for state of the art tabular predictions.

Gradient Boosting (Friedman, 2001) is a powerful ensemble method that builds decision trees sequentially to minimize a loss function. Unlike AdaBoost which reweights samples, Gradient Boosting fits each new decision tree directly to the negative gradient (pseudo residuals) of the loss function calculated from previous tree predictions. Shrinkage (learning rate) scales tree contributions, preventing overfitting while achieving top performance on tabular datasets.

Read the deep dive →
NLP & Transformersadvancedmust-know5 min

The KV Cache

Trading GPU VRAM memory for compute by caching historical Key and Value tensors during autoregressive generation.

The Key-Value (KV) Cache avoids redundant self-attention re-computation during autoregressive LLM token generation. Because historical tokens do not change during causal generation, their Key ($K$) and Value ($V$) projection matrices are computed once and stored in GPU VRAM. At step $t$, the LLM computes $Q, K, V$ for token $t$ only, appends $K_t, V_t$ to the KV cache, and evaluates attention over cached keys and values. This reduces generation time complexity per token from $O(N^2)$ to $O(N)$, but creates a massive GPU VRAM memory bottleneck.

Read the deep dive →
LLMs & GenAIadvancedmust-know5 min

RLHF Explained

Aligning language models with human preferences using reward models and proximal policy optimization.

Reinforcement Learning from Human Feedback (RLHF - Christiano et al., 2017; Ouyang et al., 2022 / InstructGPT) aligns LLMs with human values. It trains a Reward Model on human pairwise preference rankings to evaluate response quality. The LLM Policy is then fine tuned using Proximal Policy Optimization (PPO) to maximize reward scores while constrained by a KL divergence penalty to prevent policy drift.

Read the deep dive →
LLMs & GenAIadvancedmust-know5 min

LoRA & Parameter-Efficient Fine-Tuning

Fine tuning billion parameter language models by updating low rank rank decomposition matrices.

Low Rank Adaptation (LoRA - Hu et al., 2021) is a Parameter Efficient Fine Tuning (PEFT) technique for Large Language Models. Instead of updating all billions of pretrained model parameters, LoRA freezes base model weights and injects trainable low rank rank decomposition matrices A and B alongside weight matrices (W_new = W_base + B * A). LoRA reduces trainable parameter counts by 99 percent and VRAM memory requirements by 3 times with zero inference latency overhead.

Read the deep dive →
LLMs & GenAIadvancedmust-know5 min

Evaluating LLM Systems

Evaluating generative AI systems beyond static exact-match accuracy metrics.

Evaluating LLM Systems requires moving beyond classical ML metrics (Accuracy, F1) to handle non-deterministic, open-ended text generations. Evaluation methods form a 3-tier hierarchy: 1) Automated String & Overlap Metrics (ROUGE, BLEU, Exact Match), 2) Model-Based Evaluators (BERTScore, RAGAS, G-Eval), and 3) LLM-as-a-Judge or Human Preference Rating (Elo rating / A/B testing). A robust LLM evaluation pipeline combines continuous CI/CD automated test suites with golden dataset benchmarks.

Read the deep dive →
Reinforcement Learningadvancedmust-know5 min

Proximal Policy Optimization

Clipping probability ratio updates to achieve stable, sample-efficient policy gradient updates in RL and LLM alignment.

Proximal Policy Optimization (PPO - Schulman et al., 2017 / OpenAI) is the workhorse policy optimization algorithm for deep RL and LLM RLHF alignment. Standard policy gradient updates suffer from destructive large parameter steps that permanently collapse model performance. PPO introduces a Clipped Surrogate Objective function L_CLIP(θ) = E [ min( r_t(θ) A_t, clip(r_t(θ), 1-ε, 1+ε) A_t ) ], capping the probability ratio r_t(θ) = π_θ(a|s) / π_old(a|s) within [1-ε, 1+ε] to guarantee conservative, monotonic policy improvements.

Read the deep dive →
RecSys & Searchadvancedmust-know5 min

Two-Stage: Retrieval then Ranking

The industry-standard funnel architecture for recommending top items from millions of candidates in sub-50ms.

Production Recommender Systems (RecSys) use a multi-stage funnel architecture to balance latency and accuracy. Stage 1: Candidate Generation (Retrieval) filters millions of items down to top-100s in < 10ms using fast approximate vector search (ANN / Two-Tower models) or heuristics. Stage 2: Heavy Ranking scores and orders these 100s of candidates using complex multi-task deep learning models (DeepFM, DLRM). Stage 3: Re-ranking & Diversity applies business constraints, deduplication, position debiasing, and exploration.

Read the deep dive →
RecSys & Searchadvancedmust-know5 min

Learning to Rank: Point, Pair, List

Optimizing the relative ordering of search and recommendation lists across Pointwise, Pairwise, and Listwise loss formulations.

Learning to Rank (LTR) applies machine learning to construct optimal ranked lists of items for search queries or recommendation feeds. The three approaches differ in loss formulation: Pointwise predicts individual item relevance scores independently (Regression/BCE); Pairwise optimizes relative order between item pairs (RankNet, LambdaMART); Listwise optimizes metrics over the full ranked list simultaneously (ListNet, SoftRank). LambdaMART (Gradient Boosted Trees with Lambda gradients) remains the gold-standard algorithm for tabular ranking.

Read the deep dive →
MLOps & Productionadvancedmust-know5 min

Point-in-Time Correct Feature Joins

Preventing silent data leakage in training pipelines by joining features strictly as they existed at event observation time.

Point-in-Time Correctness (Time-Travel Join) ensures that training feature vectors contain only data available at or before event timestamp t. Joining features using standard SQL INNER JOIN or latest feature values causes Data Leakage (e.g. using user total 30-day spend computed today to train a model predicting a purchase 2 weeks ago). Modern Feature Stores (Feast, Hopsworks, Tecton) provide automated point-in-time joins using ASOF JOINs to guarantee zero feature leakage.

Read the deep dive →
MLOps & Productionadvancedmust-know5 min

Debugging a Production Model Incident

Systematic triage for production ML outages: when predictions degrade, latency spikes, or revenue drops.

Debugging a production ML incident requires a structured 5-step incident response playbook: 1) Immediate Mitigation (Triage & Fallback to rule-based baselines or previous model version), 2) Upstream Data & Pipeline Audit (Checking schema breaks, null rates, feature store lag), 3) Serving Infrastructure Verification (CPU/GPU utilization, OOMs, p99 latency), 4) Distribution Drift Analysis (PSI, feature distribution shifts), and 5) Post-Mortem & Safeguards (Adding automated schema contracts and integration tests).

Read the deep dive →
Coding for MLadvancedmust-know5 min

Implement Self-Attention from Scratch

Building Scaled Dot Product Self Attention from scratch using Query, Key, and Value linear projections in PyTorch.

Implement Self-Attention from Scratch builds the core mechanism of Transformer models. Scaled Dot-Product Attention transforms input sequence vectors into Query, Key, and Value matrices. The algorithm calculates query-key similarity dot products, scales by the square root of key dimension, applies Softmax normalization, and computes weighted sums over Value vectors.

Read the deep dive →
Math & Statisticsbeginner4 min

Bayes’ Theorem

The mathematical recipe for updating beliefs given evidence — and why intuition fails on rare events.

Bayes’ Theorem updates a prior probability P(A) into a posterior P(A|B) upon observing evidence B: P(A|B) = P(B|A)P(A) / P(B). In machine learning, it underpins Naive Bayes, MAP estimation, Bayesian optimization, and VAEs. The key interview insight is base-rate neglect: when prior probability is low, even a test with 99% accuracy yields more false positives than true positives.

Read the deep dive →
Math & Statisticsbeginner4 min

Central Limit Theorem

The magic theorem of statistics that guarantees sample means tend toward a Gaussian distribution regardless of original population shape.

The Central Limit Theorem (CLT) states that the sample mean of N independent, identically distributed (i.i.d.) random variables with finite variance approaches a Normal distribution N(μ, σ²/N) as N → ∞, regardless of the underlying population distribution. In ML and experimentation, CLT powers confidence intervals, hypothesis testing (z-test, t-test), A/B testing variance estimation, and mini-batch gradient descent stability.

Read the deep dive →
Math & Statisticsbeginner4 min

Law of Large Numbers

Why sample averages inevitably converge to true population expectations as sample size approaches infinity.

The Law of Large Numbers (LLN) guarantees that the sample mean X̄_N of N independent, identically distributed (i.i.d.) random variables converges to the true population expectation μ as N → ∞. The Weak LLN proves convergence in probability; the Strong LLN proves almost sure convergence. LLN underpins Monte Carlo integration, empirical risk minimization in ML, A/B testing sample size stability, and casino profitability.

Read the deep dive →
Math & Statisticsbeginner4 min

Expectation & Variance

The fundamental operators for measuring central tendency and dispersion in probability and machine learning.

Expectation E[X] is the probability-weighted average of all possible values of random variable X. Variance Var(X) = E[(X - E[X])²] measures expected squared deviation from the mean, with properties Var(aX + b) = a²Var(X). In machine learning, E[X] and Var(X) form the foundation of loss functions, MSE bias-variance decomposition, batch normalization, and weight initialization.

Read the deep dive →
Math & Statisticsbeginner4 min

Covariance vs Correlation

Covariance tells you direction; correlation tells you direction and strength independent of scale.

Covariance Cov(X,Y) = E[(X - E[X])(Y - E[Y])] measures joint variability of two random variables, but its magnitude depends on measurement units. Pearson Correlation r = Cov(X,Y) / (σ_X σ_Y) normalizes covariance to [-1, +1], providing a scale-invariant measure of linear association. Key interview topics include Pearson vs Spearman correlation, covariance matrix construction, and correlation vs causation.

Read the deep dive →
Math & Statisticsbeginner5 min

Distributions You Must Know

The probability distributions every AI/ML engineer is expected to recognize, parameterize, and apply.

Probability distributions model data generation processes. Discrete distributions include Bernoulli (binary trials), Binomial (k successes in N trials), Poisson (event rates in fixed intervals), and Categorical/Multinomial. Continuous distributions include Uniform, Gaussian/Normal (central limit theorem baseline), Exponential (time between events), and Beta/Dirichlet (priors over probabilities). Selecting the right parametric distribution dictates likelihood formulations and loss functions.

Read the deep dive →
Math & Statisticsbeginner4 min

Type I vs Type II Errors

False Positives vs False Negatives: why minimizing one error always inflates the other.

Statistical decisions suffer from two distinct error modes: Type I Error (α - False Positive / False Alarm) occurs when we reject a true null hypothesis H₀. Type II Error (β - False Negative / Missed Detection) occurs when we fail to reject a false null hypothesis H₀. Statistical Power (1 - β) is the probability of correctly detecting a real effect. Balancing α and β is a cost trade-off driven by business risk.

Read the deep dive →
Math & Statisticsbeginner4 min

Vector Norms (L1, L2, L∞)

Measuring vector magnitudes, distances, and regularization penalties across L1, L2, and Linf norms.

Vector Norms measure the size or length of a vector in vector space. The general L_p norm is defined as ||x||_p = ( ∑ |x_i|^p )^(1/p). The L1 Norm (Manhattan distance) sums absolute values, driving sparse feature selection in Lasso regression. The L2 Norm (Euclidean distance) measures straight-line distance, penalizing large outliers smoothly in Ridge regression. The L_infinity Norm (Chebyshev distance) measures the maximum absolute element.

Read the deep dive →
Math & Statisticsbeginner4 min

Dot Product & Cosine Similarity

Measuring vector alignment, magnitude projection, and semantic similarity in embedding spaces.

Dot Product and Cosine Similarity are the two core metrics for comparing vectors in machine learning. Dot product u · v = ∑ u_i v_i = ||u|| ||v|| cos(θ) combines both directional alignment and vector magnitude. Cosine similarity normalizes by vector lengths, measuring purely directional angle alignment cos(θ) on a [-1, 1] scale. When vectors are pre-normalized to unit length (||u|| = 1), Dot Product and Cosine Similarity become 100% mathematically identical.

Read the deep dive →
Math & Statisticsbeginner4 min

Correlation vs Causation

Distinguishing statistical association from true cause-and-effect relationships.

Correlation vs Causation is a foundational distinction in data science and empirical inference. Correlation measures linear statistical association between variables P(Y | X), while Causation measures the intervention effect P(Y | do(X)) of changing X directly. Correlation does not imply causation due to Spurious Correlations, Reverse Causality, and Unobserved Confounders.

Read the deep dive →
Classical MLbeginner4 min

Supervised, Unsupervised & Self-Supervised

The fundamental taxonomy of learning paradigms: from explicit labels to hidden patterns and self-supervised pretraining.

Supervised Learning trains models on labeled input-output pairs (X, Y) for classification and regression. Unsupervised Learning finds inherent structural patterns, clusters, or lower-dimensional representations in unlabeled data (X). Self-Supervised Learning bridges the gap by automatically generating pseudo-labels from raw data structure (e.g. Next-Token Prediction, Masked Autoencoders), serving as the foundational engine for modern Foundation Models and LLMs.

Read the deep dive →
Classical MLbeginner5 min

Decision Trees

Building interpretable hierarchical decision boundaries by recursively splitting feature spaces.

Decision Trees are non parametric supervised learning algorithms that partition data into hierarchical axis aligned decision regions. Starting from a root node, the tree greedily splits features at thresholds that maximize impurity reduction (Gini Impurity or Information Gain Entropy). Decision Trees handle non linear patterns and mixed feature types without feature scaling, but overfit easily if unpruned.

Read the deep dive →
Classical MLbeginner4 min

k-Nearest Neighbours

Making non parametric predictions based on distance metrics to the k closest training samples.

k-Nearest Neighbors (k-NN) is a non parametric instance based supervised learning algorithm. Instead of learning explicit model parameter weights during training, k-NN stores all training data points and makes real time predictions by locating the k closest neighbors using distance metrics like Euclidean or Manhattan distance. Predictions are computed via majority voting for classification or mean averaging for regression, but inference speed scales poorly on large high dimensional datasets.

Read the deep dive →
Classical MLbeginner4 min

Naive Bayes

The ultra-fast probabilistic classifier that assumes feature independence and handles text baselines effortlessly.

Naive Bayes applies Bayes' Theorem to classification under the 'naive' assumption that all features x_i are conditionally independent given class label y. This simplifies class posterior calculation to P(y | x) ∝ P(y) ∏ P(x_i | y). Variants include Gaussian Naive Bayes (continuous features), Multinomial Naive Bayes (word counts in text), and Bernoulli Naive Bayes (binary features). Laplace smoothing (additive α-smoothing) prevents zero-frequency zero probability traps.

Read the deep dive →
Classical MLbeginner5 min

k-Means Clustering

Partitioning unlabelled data points into k compact clusters via iterative centroid updates.

k-Means Clustering (MacQueen, 1967) is an unsupervised learning algorithm that partitions N data points into k distinct clusters. It alternates between two steps: Assigning points to the nearest centroid using Euclidean distance, and Updating centroids to be the mean center of all assigned points. k-Means minimizes Within-Cluster Sum of Squares (Inertia), but is sensitive to initial random centroid placement (fixed by k-means++) and assumes spherical clusters.

Read the deep dive →
Classical MLbeginner4 min

Missing Data & Imputation

Understanding missing data mechanisms (MCAR, MAR, MNAR) and selecting robust imputation strategies.

Missing data degrades model quality and causes pipeline failures if unhandled. Missingness falls into three mechanisms: Missing Completely at Random (MCAR), Missing at Random (MAR), and Missing Not at Random (MNAR). Imputation techniques range from simple Mean/Median/Mode insertion and indicator flags to Iterative MICE (Multivariate Imputation by Chained Equations) and KNN imputation. Modern GBDTs (XGBoost, LightGBM) handle missing values natively during split finding.

Read the deep dive →
Deep Learningbeginner4 min

Perceptron & the MLP

How simple artificial neurons combine to build deep neural networks.

A Perceptron is the simplest artificial neuron. It takes multiple input numbers, multiplies each input by a weight number, adds a bias number, and passes the result through an activation step. Single perceptrons can only learn straight line decision boundaries. A Multi Layer Perceptron combines layers of connected neurons with non linear activation steps, allowing the network to learn complex curved patterns in data.

Read the deep dive →
Deep Learningbeginner4 min

Choosing a Loss Function

Selecting the right loss function to guide neural network updates for regression, classification, and ranking.

A Loss Function measures the numerical error between model predictions and true ground truth targets. For continuous regression, Mean Squared Error penalizes large outliers heavily while Mean Absolute Error provides robust median predictions. For classification, Binary Cross Entropy and Categorical Cross Entropy measure divergence between predicted probability distributions and target one hot vectors.

Read the deep dive →
Deep Learningbeginner5 min

Data Augmentation

Expanding training dataset size and invariance by applying transformations across vision, audio, and text domains.

Data Augmentation artificially expands training datasets by applying domain specific transformations to existing data samples. In computer vision, techniques range from geometric spatial transforms (crops, flips, rotations) to color jitter and AutoAugment. In natural language processing, techniques include Back Translation, Synonym Replacement, and Contextual Word Insertion.

Read the deep dive →
NLP & Transformersbeginner5 min

Word2Vec, GloVe & Embeddings

Mapping text words into dense continuous vector spaces where geometric distance reflects semantic meaning.

Word Embeddings represent discrete text words as dense continuous vector spaces (typically 100 to 300 dimensions). Instead of sparse high dimensional one hot vectors, word embeddings position semantically similar words close together in vector space. Word2Vec (Mikolov et al., 2013) learned embeddings using self supervised local context prediction (CBOW and Skip Gram). GloVe (Pennington et al., 2014) combined local context with global matrix co occurrence statistics.

Read the deep dive →
NLP & Transformersbeginner4 min

Text Classification Pipelines

Building production pipelines to categorize unstructured text into predefined labels.

Text Classification assigns categorical labels to raw text documents (sentiment analysis, spam detection, intent routing). Pipelines evolved from classical TF-IDF with Logistic Regression or Naive Bayes to fine tuned BERT models and zero shot LLM prompts. Production pipelines require robust text cleaning, handling class imbalance, threshold calibration, and monitoring for domain drift.

Read the deep dive →
NLP & Transformersbeginner5 min

TF-IDF & BM25

Scoring keyword relevance in lexical search engines from TF-IDF to Okapi BM25.

TF-IDF and BM25 are foundational lexical keyword search algorithms. TF-IDF weights words by Term Frequency (how often a word appears in a document) multiplied by Inverse Document Frequency (how rare the word is across the corpus). Okapi BM25 improves TF-IDF by adding Term Frequency Saturation and Document Length Normalization, serving as the default retrieval algorithm in Elasticsearch and Lucene.

Read the deep dive →
NLP & Transformersbeginner4 min

Stemming, Lemmatization & Stopwords

Cleaning raw text data for traditional NLP models from stopword filtering to lemmatization.

Text Preprocessing prepares raw natural language text for machine learning algorithms. Traditional NLP pipelines remove noise using Lowercasing, Stopword Removal (filtering out common filler words like 'the' or 'is'), Stemming (chopping word suffixes using heuristic rules), and Lemmatization (mapping words to valid dictionary roots). Modern Transformer language models use raw subword tokenization (BPE), rendering manual text preprocessing obsolete.

Read the deep dive →
LLMs & GenAIbeginner5 min

Why Next-Token Prediction Works

How a simple self supervised next token prediction objective unlocks reasoning, world knowledge, and zero shot capabilities.

Next Token Prediction is the foundational self supervised training objective for Large Language Models. By predicting the probability distribution of the single next token given all preceding context tokens P(x_t | x_1...x_t-1), language models are forced to compress vast internet world knowledge, grammar, logic, and reasoning into model parameters. Scaling next token prediction across billions of parameters unlocks emergent zero shot capabilities, in context learning, and instruction following.

Read the deep dive →
LLMs & GenAIbeginner5 min

Prompt Engineering That Works

Systematic techniques for structuring LLM prompts to maximize accuracy, formatting reliability, and reasoning.

Prompt Engineering is the practice of designing input prompt structures to guide Large Language Model behavior effectively. Key techniques include assigning System Personas, providing explicit Delimiters, setting structural Output Constraints (JSON / Markdown), using Negative Constraints, and employing Few-Shot Exemplars. Systematic prompt engineering turns unpredictable LLM responses into reliable, production-ready outputs.

Read the deep dive →
LLMs & GenAIbeginner5 min

Zero-shot, Few-shot & In-Context Learning

Contrasting zero shot task execution against few shot exemplar prompting and in context learning.

Zero-Shot, Few-Shot, and In-Context Learning (ICL) describe methods for directing LLM task performance using context prompts without modifying model weights. Zero-Shot prompting asks a model to execute a task using instructions alone. Few-Shot prompting provides K input-output exemplars in the prompt context. In-Context Learning is an emergent property where self attention mechanisms process exemplars in forward passes to infer task patterns dynamically.

Read the deep dive →
LLMs & GenAIbeginner5 min

Temperature, Top-p & Sampling

Controlling randomness, creativity, and determinism in LLM text generation via decoding hyperparameters.

Decoding hyperparameters govern how raw model logits z are transformed and sampled during autoregressive text generation. Temperature T rescales logit differences z/T before Softmax, controlling distribution entropy (T → 0 is greedy deterministic; T > 1 is creative/diverse). Top-k sampling restricts sampling to the k highest-probability tokens. Top-p (Nucleus) sampling dynamically samples from the smallest set of tokens whose cumulative probability exceeds p.

Read the deep dive →
Computer Visionbeginner5 min

Image Augmentation Strategies

Preventing overfitting and regularizing vision models using advanced interpolation and automated data augmentation pipelines.

Image Augmentation expands training dataset diversity by applying synthetic transformations to input images. Traditional augmentations include random cropping, flipping, color jittering, and rotation. Advanced regularizers like Mixup blend two images and their labels linearly: x = λ x_A + (1-λ) x_B. CutMix patches a rectangular region of image B into image A, setting target label proportions equal to patch area. RandAugment automates hyperparameter search by applying a small sequence of randomly sampled operations with uniform magnitude.

Read the deep dive →
Computer Visionbeginner4 min

Resizing, Normalization & Colour Spaces

Standardizing raw pixel data via resizing, normalization, and color space transformations for computer vision models.

Image Preprocessing converts raw camera pixels into clean, standardized input tensors for computer vision models. Key operations include Aspect Ratio Preserving Resizing (padding vs letterboxing), Channel Normalization using ImageNet mean and standard deviation, and Color Space Conversions (RGB, BGR, HSV, Lab). Correct preprocessing prevents aspect ratio distortion and matches pretraining feature statistics.

Read the deep dive →
RecSys & Searchbeginner4 min

Content-Based Filtering

Recommending items based on attribute similarity and historical user feature profiles.

Content-Based Filtering recommends items to a user by matching item feature attributes (genres, text tags, author, brand, TF-IDF vectors) against a user feature profile built from past interactions. Unlike Collaborative Filtering, Content-Based Filtering operates independently across users, enabling instant recommendations for new items with zero interaction history (solving Item Cold-Start). Disadvantages include lack of serendipity (filter bubble) and inability to leverage collective user wisdom.

Read the deep dive →
ML System Designbeginner5 min

Why You Propose a Baseline First

Establishing simple, fast baseline models before deploying complex deep neural networks.

Proposing a Baseline First is a fundamental best practice in machine learning engineering and system design interviews. Before building complex 100 layer Transformer or GNN architectures, start with a simple, interpretable baseline (e.g. Heuristic Rules, Logistic Regression, BM25, or Most Popular items). Baselines validate data pipelines, set lower bound performance benchmarks, provide fast fallback options, and quantify ROI improvements of complex models.

Read the deep dive →
MLOps & Productionbeginner5 min

The End-to-End ML Lifecycle

Understanding the continuous iterative stages of building, deploying, and maintaining production machine learning systems.

The End to End Machine Learning Lifecycle spans the complete iterative lifecycle of AI products. The cycle moves continuously through Problem Formulation, Data Ingestion and Validation, Feature Engineering, Model Training and Evaluation, Deployment and Serving, and Real-Time Production Monitoring. Deployed models require ongoing retraining loops to adapt to changing real world environments.

Read the deep dive →
MLOps & Productionbeginner5 min

Experiment Tracking & Reproducibility

Systematically logging parameters, loss metrics, code commits, and artifacts across hundreds of model training runs.

Experiment Tracking logs parameters, evaluation metrics, data versions, and output artifacts during machine learning development. Without systematic tracking, teams lose track of which hyperparameters or dataset splits produced the best model checkpoint. Tools like MLflow, Weights and Biases, and Neptune record loss curves and metrics automatically to enable fast model comparison and reproducibility.

Read the deep dive →
MLOps & Productionbeginner5 min

Model Registries & Promotion

Centralizing model artifact management, stage promotion, and lineage tracking for enterprise production deployments.

A Model Registry is a centralized repository for storing, versioning, and managing machine learning model artifacts. It tracks complete model lineage from training code and datasets down to compiled binaries. Model registries govern stage promotion workflows, transitioning candidate models through Experimental, Staging, Production, and Archived lifecycle stages with audit trails.

Read the deep dive →
MLOps & Productionbeginner5 min

Model Cards & Documentation

Standardizing model transparency, intended use cases, performance benchmarks, and ethical limitations using structured Model Cards.

Model Cards provide standardized documentation for machine learning models. First proposed by Mitchell et al. at Google, Model Cards detail intended use cases, architecture specifications, training data sources, performance evaluation across demographic sub-groups, ethical considerations, and known operational limitations. Structured documentation builds stakeholder trust, simplifies audits, and prevents model misuse.

Read the deep dive →
Metrics & Evaluationbeginner5 min

Reading a Confusion Matrix

Interpreting True Positives, False Positives, True Negatives, and False Negatives in classification evaluation grids.

Reading a Confusion Matrix is a fundamental skill for evaluating classification models. A Confusion Matrix is a grid comparing predicted class labels against true ground truth labels across True Positives, False Positives, True Negatives, and False Negatives. It reveals specific error types, forming the foundation for calculating Precision, Recall, Specificity, and F1 score.

Read the deep dive →
Metrics & Evaluationbeginner5 min

MSE, MAE, RMSE, R²

Evaluating continuous numeric predictions using Mean Squared Error, Mean Absolute Error, Root Mean Squared Error, and R-squared.

Regression Metrics evaluate continuous numeric prediction models. Mean Absolute Error (MAE) measures average error magnitude robustly against outliers. Mean Squared Error (MSE) and Root Mean Squared Error (RMSE) penalize large prediction errors heavily due to squaring. R-squared (Coefficient of Determination) measures the proportion of target variance explained by the model compared to a simple mean baseline.

Read the deep dive →
Metrics & Evaluationbeginner4 min

Splitting Data Without Cheating

Building leak-free data splits that accurately reflect real-world model deployment conditions.

Partitioning data into Training, Validation, and Test sets is the first defense against overfitting and data leakage. Standard Random Splits work for independent i.i.d. samples. Stratified Splits preserve class distribution ratios for imbalanced data. Group Splits (GroupKFold) prevent data leakage when multiple rows originate from the same user/patient. Temporal Splits (TimeSeriesSplit) enforce chronological ordering for time-dependent data.

Read the deep dive →
SCROLL · SAVE · TAP TO GO DEEPER