Question 1

What is machine learning and how does it differ from traditional programming?

Accepted Answer

Machine learning is a paradigm shift from explicit programming to learning from data. In traditional programming, you define rules explicitly: if temperature > 30, then "hot". In ML, the system learns these rules from examples.

The core idea is function approximation: given input X and output Y, ML finds a function f such that f(X) ≈ Y. This function is parameterized (e.g., weights in neural networks), and learning means finding optimal parameters that minimize prediction error.

Three key components define any ML system:
1. **Representation**: How the model is structured (decision tree, neural net, SVM)
2. **Evaluation**: How we measure performance (accuracy, loss function)
3. **Optimization**: How we find the best parameters (gradient descent, genetic algorithms)

Real-world example: Spam detection. Traditional: manually define rules like "contains 'free money' → spam". ML approach: train on 10,000 labeled emails, model learns patterns automatically including ones humans might miss.

Question 2

Explain supervised vs unsupervised learning with concrete examples

Accepted Answer

**Supervised Learning**: You have labeled data (input-output pairs). The model learns a mapping from inputs to outputs. Think of it as learning with a teacher who provides correct answers.

Types:
- **Classification**: Predict discrete categories (spam/not-spam, cat/dog/bird)
- **Regression**: Predict continuous values (house price, temperature)

**Unsupervised Learning**: No labels provided. The model finds hidden structure in data. Like exploring a new city without a guide.

Types:
- **Clustering**: Group similar items (customer segmentation, document clustering)
- **Dimensionality Reduction**: Compress data while preserving structure (PCA, t-SNE)
- **Anomaly Detection**: Find outliers (fraud detection)
- **Association**: Find co-occurring items (market basket analysis)

**Semi-supervised Learning**: Small labeled dataset + large unlabeled dataset. Combines both approaches. Example: You have 100 labeled images and 10,000 unlabeled images.

**Self-supervised Learning**: Create labels from the data itself. Example: BERT masks words and predicts them, GPT predicts next word. This is how modern LLMs are trained.

Question 3

Explain the bias-variance tradeoff mathematically and how it affects model selection

Accepted Answer

The bias-variance tradeoff is fundamental to understanding model generalization. For any model, the expected prediction error can be decomposed:

**Expected Error = Bias² + Variance + Irreducible Noise**

**Bias**: Error from wrong assumptions in the model. High bias = model too simple, misses patterns (underfitting). Example: fitting a linear model to quadratic data.

**Variance**: Error from sensitivity to training data fluctuations. High variance = model too complex, captures noise (overfitting). Example: high-degree polynomial that fits training perfectly but fails on new data.

**Irreducible Noise**: Inherent randomness in data that no model can capture.

Mathematical formulation for regression:
- Let f(x) be the true function, f̂(x) be our estimate
- Bias[f̂(x)] = E[f̂(x)] - f(x)
- Var[f̂(x)] = E[(f̂(x) - E[f̂(x)])²]
- MSE = E[(y - f̂(x))²] = Bias² + Variance + σ²

**Practical Implications**:
- Simple models (linear regression, shallow trees): High bias, low variance
- Complex models (deep networks, random forests): Low bias, high variance
- Goal: Find the sweet spot that minimizes total error

**How to diagnose**:
- High bias: Training AND test error are both high → need more complex model
- High variance: Training error low, test error high → need regularization or more data

Question 4

What is regularization? Explain L1, L2, and Elastic Net mathematically

Accepted Answer

Regularization adds a penalty term to the loss function to prevent overfitting by constraining model complexity. It embodies Occam's Razor: prefer simpler models.

**L2 Regularization (Ridge)**:
Adds squared magnitude of coefficients to loss.
Loss = Original Loss + λ∑wᵢ²

- Shrinks all coefficients toward zero but never exactly zero
- Geometrically: constrains weights to a hypersphere
- Good when all features contribute somewhat
- Closed-form solution exists: w = (X^T X + λI)^(-1) X^T y

**L1 Regularization (Lasso)**:
Adds absolute value of coefficients.
Loss = Original Loss + λ∑|wᵢ|

- Produces sparse solutions (some weights exactly zero)
- Geometrically: constrains weights to a hypercube (corners = zeros)
- Performs automatic feature selection
- No closed-form solution, requires iterative optimization

**Elastic Net**: Combines L1 + L2
Loss = Original Loss + λ₁∑|wᵢ| + λ₂∑wᵢ²

- Gets benefits of both: sparsity AND grouped selection
- Better when features are correlated
- Two hyperparameters to tune

**Why L1 produces zeros but L2 doesn't**:
Geometrically, the optimal solution is where the loss contours meet the constraint region. L1's diamond shape has corners on axes (sparse), L2's sphere touches curves (non-sparse).

Question 5

Explain gradient descent, its variants, and convergence properties

Accepted Answer

Gradient descent is the workhorse optimization algorithm for ML. The core idea: iteratively move in the direction of steepest descent to minimize a loss function.

**Update Rule**: θ ← θ - η∇L(θ)
Where η is learning rate, ∇L is gradient of loss w.r.t. parameters.

**Variants**:

1. **Batch Gradient Descent**: Compute gradient over entire dataset
   - Pros: Stable, converges to minimum
   - Cons: Slow for large datasets, can't escape local minima

2. **Stochastic Gradient Descent (SGD)**: Gradient from single sample
   - Pros: Fast updates, can escape local minima (noise helps)
   - Cons: High variance, noisy convergence

3. **Mini-batch GD**: Gradient from small batch (32-512 samples)
   - Best of both worlds, most commonly used
   - Allows GPU parallelization

**Momentum**: Accumulates velocity to accelerate through ravines
   v ← γv - η∇L(θ)
   θ ← θ + v

**Adam** (Adaptive Moment Estimation): Adaptive learning rates per parameter
   - Maintains running averages of gradient (m) and squared gradient (v)
   - Bias-corrected estimates: m̂ = m/(1-β₁ᵗ), v̂ = v/(1-β₂ᵗ)
   - Update: θ ← θ - η·m̂/(√v̂ + ε)
   - Most popular optimizer for deep learning

**Convergence Conditions**:
- Convex + Lipschitz gradients: GD converges at O(1/t) rate
- Learning rate schedule matters: too high = diverge, too low = slow
- For non-convex (neural nets): converge to local minimum

Question 6

Explain the curse of dimensionality and techniques to address it

Accepted Answer

The curse of dimensionality refers to phenomena that arise when working in high-dimensional spaces, making data increasingly sparse and algorithms ineffective.

**Key Problems**:

1. **Data Sparsity**: In d dimensions, data becomes exponentially sparse. To maintain the same density, you need N^d samples for N samples per dimension. With 10 features and 10 samples per feature, you need 10 billion samples!

2. **Distance Concentration**: In high dimensions, distances between points become nearly equal. The ratio of min to max distance approaches 1:
   lim(d→∞) [max_dist - min_dist] / min_dist → 0

This breaks distance-based algorithms (KNN, K-means, DBSCAN).

3. **Empty Space**: Most of the volume is near the boundary, not the center. A hypersphere's volume shrinks relative to the enclosing hypercube.

**Solutions**:

1. **Feature Selection**: Keep only relevant features
   - Filter methods: mutual information, correlation
   - Wrapper methods: RFE, forward/backward selection
   - Embedded methods: Lasso, tree-based importance

2. **Dimensionality Reduction**:
   - Linear: PCA, SVD, LDA
   - Non-linear: t-SNE, UMAP, autoencoders

3. **Regularization**: Constrain model complexity

4. **Domain Knowledge**: Engineer fewer, more meaningful features

5. **Sampling Strategies**: SMOTE, stratified sampling

Question 7

What is a neural network and how does forward propagation work?

Accepted Answer

A neural network is a function approximator composed of layers of interconnected nodes (neurons). Each neuron computes a weighted sum of inputs, adds a bias, and applies a non-linear activation function.

**Architecture**:
- **Input layer**: Receives raw features (no computation)
- **Hidden layers**: Transform representations (learnable)
- **Output layer**: Produces final prediction

**Forward Propagation**:
For each layer l:
1. Linear transformation: z^[l] = W^[l] · a^[l-1] + b^[l]
2. Activation: a^[l] = g(z^[l])

Where:
- W^[l] = weight matrix of layer l (shape: neurons_l × neurons_{l-1})
- b^[l] = bias vector
- a^[l] = activations (output of layer l)
- g = activation function (ReLU, sigmoid, etc.)

**Why non-linearity matters**:
Without activation functions, stacking layers gives: W₂(W₁x) = (W₂W₁)x = Wx
This collapses to a single linear transformation! Activation functions enable learning complex, non-linear decision boundaries.

**Universal Approximation Theorem**:
A feedforward network with a single hidden layer containing a finite number of neurons can approximate any continuous function (given enough neurons). But deeper networks are more parameter-efficient.

Question 8

Explain backpropagation with the chain rule. How are gradients computed?

Accepted Answer

Backpropagation computes gradients of the loss with respect to every parameter in the network, enabling gradient descent optimization. It's an efficient algorithm based on the chain rule of calculus.

**The Chain Rule**:
If y = f(g(x)), then dy/dx = (dy/dg) · (dg/dx)

For neural networks, we chain through multiple layers:
∂L/∂W^[l] = ∂L/∂a^[L] · ∂a^[L]/∂z^[L] · ... · ∂z^[l]/∂W^[l]

**Backprop Algorithm**:
1. **Forward pass**: Compute all activations, store them
2. **Compute output error**: δ^[L] = ∂L/∂a^[L] · g'(z^[L])
3. **Backpropagate**: δ^[l] = (W^[l+1])^T · δ^[l+1] �� g'(z^[l])
4. **Compute gradients**: ∂L/∂W^[l] = δ^[l] · (a^[l-1])^T

**Why it's efficient**:
- Naive approach: O(n²) per parameter
- Backprop: O(n) - computes ALL gradients in one backward pass
- Key insight: reuse intermediate results (dynamic programming)

**Computational Graph View**:
Modern frameworks (PyTorch, TensorFlow) build a directed acyclic graph (DAG) of operations. Backward pass traverses this graph in reverse, applying chain rule at each node.

Question 9

Compare activation functions: ReLU, Sigmoid, Tanh, GELU, Swish. When to use each?

Accepted Answer

Activation functions introduce non-linearity. The choice significantly impacts training dynamics and model performance.

**Sigmoid**: σ(x) = 1/(1+e^(-x))
- Output: (0, 1) - good for probabilities
- Problems: Vanishing gradients (σ'(x) ≤ 0.25), not zero-centered, expensive exp()
- Use: Output layer for binary classification

**Tanh**: tanh(x) = (e^x - e^(-x))/(e^x + e^(-x))
- Output: (-1, 1) - zero-centered (better than sigmoid)
- Problems: Still vanishing gradients
- Use: RNNs (historically), rarely used now

**ReLU**: f(x) = max(0, x)
- Output: [0, ∞)
- Pros: No vanishing gradient for x>0, very fast, sparse activation
- Problems: "Dying ReLU" (neurons stuck at 0), not zero-centered
- Use: Default for hidden layers in most networks

**Leaky ReLU**: f(x) = max(αx, x), typically α=0.01
- Solves dying ReLU problem
- Use: When ReLU causes dead neurons

**GELU**: x · Φ(x) where Φ is Gaussian CDF
- Smooth approximation of ReLU
- Probabilistic interpretation: "how much to keep"
- Use: Transformers (BERT, GPT) - works better than ReLU

**Swish/SiLU**: x · σ(x)
- Self-gated, smooth, non-monotonic
- Outperforms ReLU in deep networks
- Use: EfficientNet, modern vision models

Question 10

Explain batch normalization: how it works, why it helps, and when to use it

Accepted Answer

Batch Normalization normalizes layer inputs to stabilize and accelerate training. It's one of the most important techniques in deep learning.

**How it works**:
For each mini-batch:
1. Compute mean: μ_B = (1/m) Σ xᵢ
2. Compute variance: σ²_B = (1/m) Σ (xᵢ - μ_B)²
3. Normalize: x̂ᵢ = (xᵢ - μ_B) / √(σ²_B + ε)
4. Scale and shift: yᵢ = γx̂ᵢ + β (learnable parameters)

**Why it helps**:
1. **Reduces Internal Covariate Shift**: Each layer sees more stable input distributions
2. **Higher Learning Rates**: Normalized inputs allow larger steps
3. **Regularization Effect**: Batch statistics add noise, like dropout
4. **Reduces Sensitivity to Initialization**: Less dependent on careful weight init

**At Inference**:
Use running averages of mean/variance computed during training (not batch statistics).

**When to use**:
- Standard for CNNs (typically after conv, before activation)
- Vision transformers use LayerNorm instead
- RNNs: use LayerNorm (batch stats vary with sequence length)
- Small batches: use GroupNorm or LayerNorm

**BatchNorm vs LayerNorm**:
- BatchNorm: normalize across batch dimension
- LayerNorm: normalize across feature dimension
- Transformers prefer LayerNorm (sequence length varies)

AI & ML Interview Questions

Filter Questions

What is machine learning and how does it differ from traditional programming?

Explain supervised vs unsupervised learning with concrete examples

Explain the bias-variance tradeoff mathematically and how it affects model selection

What is regularization? Explain L1, L2, and Elastic Net mathematically

Explain gradient descent, its variants, and convergence properties

Explain the curse of dimensionality and techniques to address it

What is a neural network and how does forward propagation work?

Explain backpropagation with the chain rule. How are gradients computed?

Compare activation functions: ReLU, Sigmoid, Tanh, GELU, Swish. When to use each?

Explain batch normalization: how it works, why it helps, and when to use it

Explain the vanishing and exploding gradient problems. How do modern architectures solve them?

Explain the Transformer architecture in detail. Why did it replace RNNs?

Compare BERT, GPT, and T5 architectures. When would you use each?

Explain how RAG (Retrieval-Augmented Generation) works and when to use it vs fine-tuning

Explain CNNs in detail: convolution operation, pooling, and why they work for images

Explain Vision Transformers (ViT). How do they compare to CNNs?

Design a real-time ML serving system for 10,000 QPS with <100ms latency

How do you detect and handle model drift in production?

Explain the difference between MLE and MAP estimation. When would you use each?

Describe a time you had to make a tradeoff between model performance and production constraints

Why Practice Interview Questions?

Question Categories