Machine Learning Fundamentals

What machine learning is (and is not)

Traditional programming takes rules + data and produces answers. Machine learning flips this: it takes data + answers (examples) and produces the rules (a model). Once learned, the model is applied to new data to produce new answers. A classic formal definition says a program learns from experience E with respect to a task T and a performance measure P if its performance on T, measured by P, improves with E. For a spam filter: T is labelling emails, P is the fraction labelled correctly (or better, recall on spam at a fixed false-alarm rate), and E is a pile of emails that humans already marked as spam or not.

AI vs ML vs deep learning vs generative AI

+--------------------------------------------------------------+
|  Artificial Intelligence: any technique that makes machines  |
|  act intelligently (search, logic rules, planning, ML ...)   |
|   +------------------------------------------------------+   |
|   |  Machine Learning: systems that learn rules from data |   |
|   |   +----------------------------------------------+   |   |
|   |   |  Deep Learning: ML with many-layer neural     |   |   |
|   |   |  networks that learn their own features       |   |   |
|   |   |   +--------------------------------------+   |   |   |
|   |   |   |  Generative AI: models that create    |   |   |   |
|   |   |   |  new text, images, audio, code (LLMs, |   |   |   |
|   |   |   |  diffusion models)                    |   |   |   |
|   |   |   +--------------------------------------+   |   |   |
|   |   +----------------------------------------------+   |   |
|   +------------------------------------------------------+   |
+--------------------------------------------------------------+

When ML is the right tool

The vocabulary you must be fluent in

Types of learning

Learning paradigms differ in what feedback the learner gets. That single question decides the whole setup: the loss, the data you must collect and how you evaluate.

Supervised learning: classification vs regression

Other useful distinctions

The ML project lifecycle

Algorithms are maybe 10–20% of a real ML project. The rest is framing the problem, getting data right, evaluating honestly and operating the model. Interviewers love candidates who think in this full loop.

1. Frame the problem What decision will the prediction drive? What is the cost of each kind of error? Is ML even needed? Define a baseline (current rule, or “predict the majority class”).
2. Choose the metric Translate the business goal into an offline metric (for example recall at precision ≥ 0.60) and an online metric (fraud losses, click-through).
3. Collect and label data Ensure it represents production conditions. Check label quality and how labels are generated.
4. Explore (EDA) Distributions, missing values, class balance, scale differences, correlations, outliers, leakage suspects.
5. Split Train / validation / test before any fitting, stratified or by time or group as appropriate.
6. Preprocess and engineer features Impute, encode, scale, create features, all fitted on the training split only (use a Pipeline).
7. Train baselines, then stronger models Start simple (logistic regression, a shallow tree), then try ensembles.
8. Tune and validate Cross-validation, hyperparameter search, threshold selection on validation data.
9. Evaluate once on the test set Report the final number, error analysis by segment, calibration, fairness checks.
10. Deploy Batch or real-time serving, shadow or canary rollout, A/B test against the current system.
11. Monitor and retrain Watch data drift, prediction drift, performance, latency; retrain on a schedule or on triggers.

  Business goal --> Metric --> Data --> EDA --> Split --> Features
       ^                                                   |
       |                                                   v
   Monitor <-- Deploy <-- Test once <-- Tune/CV <-- Train baselines
       |
       +--> drift or decay detected --> retrain / re-frame

Data preparation: splits, leakage, cleaning and features

“Garbage in, garbage out” is the most reliable law in ML. This section covers the practical decisions that decide whether a model's reported score is honest and whether it will hold up in production.

Train / validation / test splits

• Stratified split keeps class proportions identical across splits. Use it for classification, especially with imbalance: train_test_split(..., stratify=y).
• Time-based split for temporal data: train on the past, validate and test on the future. Random shuffling leaks the future into training.
• Group split when several rows belong to the same entity (patient, user, device): all rows of one group must fall in one split (GroupKFold), or the model memorises the entity.
• With huge datasets, a 98/1/1 split can be fine: one percent of ten million rows is still a very precise estimate.

Data leakage

Leakage means information that would not be available at prediction time sneaks into training, making offline scores unrealistically good. Interviewers expect you to name concrete patterns, not just the word.

Missing values

Encoding categorical features

Feature scaling

Worked example: a tumour dataset has a “mean area” feature around 654 and a “mean fractal dimension” around 0.06. In a Euclidean distance, a difference of 100 in area swamps any difference in fractal dimension, so kNN would effectively ignore the second feature. If the training mean area is 654 with standard deviation 350, a tumour with area 1004 becomes z = (1004 − 654)/350 = 1.0, now on the same footing as every other standardized feature.

Feature engineering

Feature selection

Why select features at all: fewer features means less overfitting, faster training and inference, cheaper data pipelines and easier explanations. It also fights the curse of dimensionality: as dimensions grow, data becomes sparse and distances between points become nearly equal, which hurts distance-based methods.

Putting preprocessing in a pipeline

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

num_cols = ["age", "income", "balance"]
cat_cols = ["city", "plan"]

preprocess = ColumnTransformer([
    ("num", Pipeline([("impute", SimpleImputer(strategy="median")),
                      ("scale", StandardScaler())]), num_cols),
    ("cat", Pipeline([("impute", SimpleImputer(strategy="most_frequent")),
                      ("onehot", OneHotEncoder(handle_unknown="ignore"))]), cat_cols),
])

model = Pipeline([("prep", preprocess),
                  ("clf", LogisticRegression(max_iter=1000, class_weight="balanced"))])

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=42)
model.fit(X_train, y_train)          # imputer/scaler/encoder fitted on train only
print(model.score(X_test, y_test))

How models learn: loss functions and gradient descent

Almost every supervised model is trained the same way: define a loss that measures how wrong a prediction is, then adjust the parameters to make the average loss (the cost or objective) as small as possible. Gradient descent is the workhorse for that adjustment.

Loss vs cost

Strictly, the loss is the error on one example and the cost is the average (or sum) over the dataset, often plus a regularization penalty. In practice, libraries and papers use “loss” for both; the formula with 1/n and a summation is the cost.

Common loss functions

Worked example, cross-entropy. The true label is spam (y = 1). If the model says p = 0.9, the loss is −ln 0.9 ≈ 0.105. If it says p = 0.05 (confidently wrong), the loss is −ln 0.05 ≈ 3.0, almost thirty times larger. The negative sign exists because logs of probabilities are negative; negating turns “maximise the log-probability of the right answer” into a positive quantity to minimise. Minimising cross-entropy is exactly maximum-likelihood estimation.

Gradient descent

Worked example. Fit y = w·x to the points (1, 2), (2, 4), (3, 6) with MSE, starting from w = 0 and η = 0.1. The gradient is dJ/dw = −(2/n) Σ x_i(y_i − w x_i).

1. Step 1 Residuals are 2, 4, 6; Σ x·residual = 2 + 8 + 18 = 28; gradient = −(2/3)(28) ≈ −18.67; w = 0 + 0.1 × 18.67 = 1.867.
2. Step 2 Residuals are 0.133, 0.267, 0.400; Σ x·residual ≈ 1.867; gradient ≈ −1.244; w ≈ 1.991.
3. Step 3 onwards The gradient keeps shrinking and w converges to the true value 2. The loss surface here is convex, so there is a single global minimum.

• Learning rate too small: painfully slow convergence. Too large: overshoots and diverges (loss oscillates or explodes). It does not adapt automatically in plain GD; the gradient gives direction, the learning rate gives step size.
• Epoch: one full pass over the training data. Batch size: examples per update; one epoch = n / batch_size updates.
• Convex vs non-convex: linear and logistic regression have convex costs (one global minimum). Neural networks are non-convex with many local minima and saddle points, but many of those minima generalise similarly well.
• When to stop: when validation loss stops improving (early stopping), not when training loss hits zero. Real data has noise, so driving training error to zero means memorising that noise.

Linear regression and regularization

Linear regression predicts a number as a weighted sum of the features plus an intercept. It is the simplest useful model, the best-understood statistically, and the building block of logistic regression and neural networks.

Interpreting coefficients

Each weight w_j is the expected change in ŷ for a one-unit increase in x_j, holding all other features fixed. Coefficients are only comparable across features if the features are on the same scale, and they become unstable when features are highly correlated (multicollinearity).

Assumptions (for valid inference, not just prediction)

1. Linearity The expected target is a linear function of the features (after any transformations).
2. Independence Errors are independent (violated in time series with autocorrelation).
3. Homoscedasticity Errors have constant variance across predictions (no funnel shape in residual plots).
4. Normality of errors Needed for exact confidence intervals and p-values, not for the point predictions.
5. No perfect multicollinearity No feature is an exact linear combination of others; high correlation inflates coefficient variance (check the variance inflation factor, VIF).

Polynomial regression

Adding x², x³, … as extra features keeps the model linear in its parameters while fitting curves. Degree 1 on curved data underfits; degree 9 on 80 noisy points fits the noise and overfits. Regularization makes high-degree fits usable.

Regularization: L2 (Ridge), L1 (Lasso), Elastic Net

Why it works: a penalty on weight size limits how wildly the function can bend to chase individual points, trading a little bias for a large reduction in variance. Large λ underfits (all weights near zero); λ = 0 recovers plain OLS. Tune λ by cross-validation (RidgeCV, LassoCV, GridSearchCV).

import numpy as np
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import PolynomialFeatures, StandardScaler
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.model_selection import train_test_split, cross_val_score

rng = np.random.default_rng(42)
X = np.sort(rng.random((80, 1)), axis=0)
y = np.sin(2 * np.pi * X).ravel() + rng.normal(0, 0.15, 80)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

for name, reg in [("OLS", LinearRegression()), ("Ridge", Ridge(alpha=1.0)), ("Lasso", Lasso(alpha=0.01))]:
    pipe = Pipeline([("poly", PolynomialFeatures(degree=9)),
                     ("scale", StandardScaler()),
                     ("model", reg)])
    pipe.fit(X_tr, y_tr)
    cv = cross_val_score(pipe, X, y, cv=5, scoring="r2")
    print(f"{name}: train R2={pipe.score(X_tr, y_tr):.3f} "
          f"test R2={pipe.score(X_te, y_te):.3f} CV={cv.mean():.3f}+/-{cv.std():.3f}")
# A large train-test gap for OLS that shrinks with Ridge/Lasso is regularization at work.

Logistic regression

Despite the name, logistic regression is a classifier. It computes a linear score, squashes it through the sigmoid into a probability between 0 and 1, and thresholds that probability to pick a class.

Worked example. A model has b = −1.0 and a single weight w = 0.8 on “number of suspicious links”. An email with 2.75 links gives z = −1.0 + 0.8 × 2.75 = 1.2, so p = 1/(1 + e^−1.2) = 1/(1 + 0.301) ≈ 0.77. With the default threshold 0.5 it is flagged as spam. Each extra link multiplies the odds of spam by e^0.8 ≈ 2.23.

• Decision boundary is where z = 0 (p = 0.5): a straight line or hyperplane. Non-linear boundaries need engineered features or kernels.
• Multiclass: softmax (multinomial) regression generalises the sigmoid, softmax(z)k = ezk / Σj ezj. Scores [2, 1, 0] become probabilities of about [0.67, 0.24, 0.09]. One-vs-rest is the alternative.
• Regularization: scikit-learn applies L2 by default with C = 1.0; smaller C means stronger regularization. On a 50,000-word sentiment vocabulary, a very small C (0.01) worked best because it stopped the model trusting rare words.
• Perfect separation: without regularization, weights grow without bound when the classes are perfectly separable; regularization keeps them finite.
• Probabilities: logistic regression is usually reasonably well calibrated out of the box, which is one reason it is popular in credit scoring and medicine.

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, confusion_matrix

data = load_breast_cancer()
X, y = data.data, 1 - data.target        # raw data: 0 = malignant; flip so malignant = 1 (positive class)

X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)
pipe = make_pipeline(StandardScaler(),
                     LogisticRegression(class_weight="balanced", max_iter=10000, random_state=42))
grid = GridSearchCV(pipe, {"logisticregression__C": [0.01, 0.1, 1, 10, 100]},
                    scoring="recall", cv=5, n_jobs=-1)
grid.fit(X_tr, y_tr)
y_pred = grid.predict(X_te)
print(grid.best_params_)
print(confusion_matrix(y_te, y_pred))
print(classification_report(y_te, y_pred, target_names=["benign", "malignant"]))

k-nearest neighbours (kNN)

kNN has no training phase worth the name: it stores the training set, and to classify a new point it finds the k closest stored points and takes a majority vote (or averages their values for regression). It is the purest “similar inputs have similar outputs” model.

Worked example. Training points (feature1, feature2, label): A (1, 1, red), B (2, 1, red), C (4, 4, blue), D (5, 4, blue), E (2, 3, blue). Query Q = (2, 2). Distances: A √2 ≈ 1.41, B 1.0, E 1.0, C √8 ≈ 2.83, D √13 ≈ 3.61. With k = 3 the neighbours are B (red), E (blue), A (red), so the vote is 2–1 for red. With weights="distance", votes are weighted by 1/d: red = 1/1 + 1/1.41 = 1.71, blue = 1/1 = 1.0, still red.

• Choosing k: small k gives a jagged, noisy boundary (overfits); large k gives a smooth boundary (underfits). Use an odd k for binary problems to avoid ties, and tune it with cross-validation.
• Scaling is mandatory: otherwise the feature with the largest range dominates the distance.
• Distance weighting helps when the minority class is sparse locally: a very close minority neighbour outvotes several distant majority ones.
• Cost: there is no parameter fitting; training just stores the data (O(n) space). Naive prediction is O(n·d) per query. KD-trees and ball trees speed up low dimensions; approximate nearest-neighbour indexes (HNSW, IVF, product quantization) are what vector databases use at scale.
• Curse of dimensionality: in hundreds of dimensions, all points are roughly equidistant and “nearest” loses meaning. Reduce dimensions first.

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV

knn = make_pipeline(StandardScaler(), KNeighborsClassifier())
grid = GridSearchCV(knn, {"kneighborsclassifier__n_neighbors": [3, 5, 7, 9, 11, 15],
                          "kneighborsclassifier__weights": ["uniform", "distance"]},
                    scoring="f1_macro", cv=5)
grid.fit(X_train, y_train)
print(grid.best_params_, grid.best_score_)

Naive Bayes

Naive Bayes is a probabilistic classifier built on Bayes' theorem with one bold simplification: given the class, every feature is assumed independent of every other feature. The assumption is almost always false, yet the classifier is fast, needs little data, and works surprisingly well for text.

Worked example. Priors: P(spam) = 0.4, P(ham) = 0.6. Likelihoods: P(“free” | spam) = 0.5, P(“free” | ham) = 0.05, P(“meeting” | spam) = 0.1, P(“meeting” | ham) = 0.3. An email contains both words. Spam score = 0.4 × 0.5 × 0.1 = 0.020. Ham score = 0.6 × 0.05 × 0.3 = 0.009. Normalising: P(spam | email) = 0.020 / 0.029 ≈ 0.69, so it is classified as spam.

• Zero-frequency problem: a word never seen with a class would give probability 0 and wipe out the whole product. Smoothing (α > 0) fixes it.
• Probabilities are poorly calibrated: because correlated features are double-counted, Naive Bayes outputs are pushed toward 0 and 1. The ranking is often fine; the numbers are overconfident.
• In a binary bag-of-words sentiment benchmark, BernoulliNB reached F1 ≈ 0.81 but recall of only about 0.76, lower than logistic regression, largely because negation (“not bad”) breaks the independence assumption.

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import make_pipeline

nb = make_pipeline(CountVectorizer(ngram_range=(1, 2), min_df=2), MultinomialNB(alpha=1.0))
nb.fit(train_texts, train_labels)
print(nb.predict(["free prize, claim now", "agenda for tomorrow's meeting"]))

Decision trees

A decision tree asks a sequence of yes/no questions about the features (“is income > 50k?”), each answer leading down a branch until a leaf gives the prediction. Trees are the foundation of the most successful tabular models: random forests and gradient boosting.

Impurity measures

Worked example. A parent node has 10 samples: 6 positive, 4 negative.

1. Parent Gini = 1 − (0.6² + 0.4²) = 1 − 0.52 = 0.48. Entropy = −(0.6 log₂0.6 + 0.4 log₂0.4) ≈ 0.971 bits.
2. Candidate split Left child: 5 positive, 1 negative (6 samples). Right child: 1 positive, 3 negative (4 samples).
3. Gini of children Left = 1 − (25 + 1)/36 ≈ 0.278. Right = 1 − (1 + 9)/16 = 0.375. Weighted = 0.6 × 0.278 + 0.4 × 0.375 ≈ 0.317. Gini decrease = 0.48 − 0.317 ≈ 0.163.
4. Entropy of children Left ≈ 0.650, right ≈ 0.811. Weighted = 0.6 × 0.650 + 0.4 × 0.811 ≈ 0.715. Information gain = 0.971 − 0.715 ≈ 0.256 bits.
5. Choose The tree evaluates every feature and threshold this way and keeps the split with the largest impurity decrease, then recurses on each child.

Algorithms and stopping

• CART (scikit-learn): binary splits, Gini or entropy for classification, MSE for regression. ID3 / C4.5: entropy and gain ratio, multiway splits. The split search is greedy: locally best at each node, not globally optimal.
• Pre-pruning (early stopping): max_depth, min_samples_split, min_samples_leaf, max_leaf_nodes, min_impurity_decrease.
• Post-pruning: grow the full tree, then remove branches that do not pay for their complexity. Cost-complexity pruning minimises R(T) + α·|leaves| (ccp_alpha).
• Feature importance (mean decrease in impurity) sums the impurity reduction each feature produced, weighted by samples reaching the node. It is biased toward high-cardinality continuous features; permutation importance is more reliable.

An overfitting study on a small wine dataset shows the pattern: a depth-1 stump has low train and test accuracy (underfits), an unlimited-depth tree has 100% train accuracy with a clear drop on test (overfits), and a tuned depth sits between with the smallest gap.

from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.model_selection import GridSearchCV

params = {"max_depth": [3, 5, 7, 10, None],
          "min_samples_split": [2, 5, 10],
          "min_samples_leaf": [1, 2, 4]}
grid = GridSearchCV(DecisionTreeClassifier(class_weight="balanced", random_state=42),
                    params, scoring="recall", cv=5, n_jobs=-1)
grid.fit(X_train, y_train)                      # no scaling needed for trees
tree = grid.best_estimator_
print(export_text(tree, feature_names=list(feature_names)))

for depth in [1, None, tree.max_depth]:
    t = DecisionTreeClassifier(max_depth=depth, random_state=42).fit(X_train, y_train)
    print(depth, t.score(X_train, y_train), t.score(X_test, y_test))  # watch the gap

Ensembles: bagging, random forests, boosting and stacking

An ensemble combines many models so that their individual errors cancel out. Bagging trains strong, high-variance models independently and averages them to reduce variance. Boosting trains weak, high-bias models in sequence, each fixing the previous ones' mistakes, to reduce bias. Stacking learns how to combine different model types.

Why averaging works

Bagging (bootstrap aggregating)

1. Bootstrap Draw B samples of size n from the training data with replacement.
2. Train Fit one high-variance model (usually a deep tree) on each sample, in parallel.
3. Aggregate Majority vote (classification) or average (regression).

Each bootstrap sample leaves out about (1 − 1/n)ⁿ ≈ 1/e ≈ 36.8% of rows. Those out-of-bag (OOB) rows act as a free validation set for that tree (oob_score=True).

Random forest

A random forest is bagged decision trees plus one extra trick: at every split, only a random subset of features is considered (max_features, typically √d for classification, d/3 or all for regression). This decorrelates the trees so that one dominant feature does not appear at the top of every tree.

Extra Trees (extremely randomized trees) go further and pick split thresholds at random, trading a little bias for more variance reduction and faster training.

Boosting

AdaBoost (adaptive boosting) trains weak learners, usually depth-1 stumps, sequentially and reweights the data so misclassified points get more attention.

Gradient boosting generalises the idea to any differentiable loss. Each new tree is fitted to the negative gradient of the loss with respect to the current predictions (for MSE, simply the residuals), and added with a small learning rate. It is gradient descent in function space.

Worked example. House prices 200, 300, 400 (thousands). F₀ = 300 for everyone; residuals are −100, 0, +100. The first tree learns to predict those residuals (say −90, 0, +90). With η = 0.1, predictions become 291, 300, 309. The residuals shrink to −91, 0, 91, the next tree fits those, and so on; after hundreds of small steps the predictions approach the targets, with early stopping deciding when to quit.

XGBoost, LightGBM and CatBoost

Key boosting hyperparameters: n_estimators with early stopping, learning_rate, tree size (max_depth or num_leaves), subsample and colsample_bytree (row and column sampling, which add bagging-style randomness), min_child_weight, and regularization (reg_lambda, reg_alpha).

Stacking and blending

Stacking trains several diverse base models (say logistic regression, random forest, gradient boosting, kNN), then trains a meta-model on their out-of-fold predictions. Using out-of-fold predictions is essential: if the meta-model saw base-model predictions on data those models were trained on, it would learn to trust overfit outputs. Blending is the simpler version that uses a single hold-out set. Voting just averages (soft voting) or majority-votes (hard voting) without learning weights.

from sklearn.ensemble import (RandomForestClassifier, GradientBoostingClassifier,
                              HistGradientBoostingClassifier, AdaBoostClassifier,
                              StackingClassifier)
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score

rf = RandomForestClassifier(n_estimators=500, max_features="sqrt", oob_score=True,
                            n_jobs=-1, random_state=42).fit(X_train, y_train)
print("OOB accuracy:", rf.oob_score_)

hgb = HistGradientBoostingClassifier(learning_rate=0.05, max_iter=1000,
                                     early_stopping=True, validation_fraction=0.1,
                                     random_state=42)
ada = AdaBoostClassifier(n_estimators=300, learning_rate=0.5, algorithm="SAMME",
                         random_state=42)

stack = StackingClassifier(
    estimators=[("lr", make_pipeline(StandardScaler(), LogisticRegression(max_iter=5000))),
                ("rf", rf), ("hgb", hgb)],
    final_estimator=LogisticRegression(), cv=5)          # meta-model trained on out-of-fold predictions
for name, m in [("rf", rf), ("hgb", hgb), ("ada", ada), ("stack", stack)]:
    print(name, cross_val_score(m, X_train, y_train, cv=5, scoring="roc_auc").mean())

# XGBoost equivalent (separate package). In XGBoost 2+, early_stopping_rounds
# belongs on fit(), not the constructor:
# from xgboost import XGBClassifier
# xgb = XGBClassifier(n_estimators=2000, learning_rate=0.05, max_depth=6,
#                     subsample=0.8, colsample_bytree=0.8, eval_metric="aucpr")
# xgb.fit(X_tr, y_tr, eval_set=[(X_va, y_va)], early_stopping_rounds=50, verbose=False)

Support vector machines (SVM)

An SVM finds the separating hyperplane with the widest margin, the largest gap between the boundary and the nearest points of each class. Only those nearest points, the support vectors, determine the boundary. With kernels, SVMs draw non-linear boundaries without ever computing high-dimensional features explicitly.

• C is the price of a margin violation. Large C: few violations, narrow margin, risk of overfitting. Small C: wider margin, more violations tolerated, more regularization.
• Worked example: if the learned w = (3, 4), then ‖w‖ = 5 and the margin width is 2/5 = 0.4 units. A solution with w = (0.6, 0.8) would have margin 2.0, five times wider.

The kernel trick

Data that is not linearly separable in its original space often becomes separable after mapping to a higher-dimensional space φ(x). The SVM's dual formulation only ever uses dot products between points, so we can replace x_i·x_j with a kernel K(x_i, x_j) = φ(x_i)·φ(x_j) and never compute φ at all.

Example: points on a line at x = −2, −1, 1, 2 labelled (+, −, −, +) cannot be split by one threshold. Map each point to (x, x²): the + points go to height 4, the − points to height 1, and the horizontal line x² = 2.5 separates them. A polynomial kernel does this implicitly.

• RBF γ: large γ means each point influences only a tiny neighbourhood, so the boundary wraps around individual points and overfits; small γ gives a smooth, nearly linear boundary. Tune C and γ together on a log grid.
• Scaling is essential because both the margin and the RBF distance depend on feature magnitudes.
• Probabilities: SVMs output distances, not probabilities. SVC(probability=True) adds Platt scaling via internal cross-validation (slower); otherwise use decision_function scores for ranking and threshold tuning.
• Scale limits: kernel SVM training is roughly O(n²) to O(n³), fine for tens of thousands of rows, painful beyond. LinearSVC or SGDClassifier(loss="hinge") scale to millions and excel on sparse text: a linear SVM tied for best (F1 ≈ 0.875) on bag-of-words movie-review sentiment.
• SVR (support vector regression) fits a tube of width ε around the data and only penalises points outside it.

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.model_selection import GridSearchCV

svm = make_pipeline(StandardScaler(),
                    SVC(class_weight="balanced", probability=True, random_state=42))
grid = GridSearchCV(svm, {"svc__C": [0.1, 1, 10, 100],
                          "svc__kernel": ["linear", "rbf"],
                          "svc__gamma": ["scale", 0.01, 0.1, 1]},
                    scoring="recall", cv=5, n_jobs=-1)
grid.fit(X_train, y_train)
print(grid.best_params_)
print("support vectors per class:", grid.best_estimator_[-1].n_support_)

Clustering: k-means, hierarchical, DBSCAN and GMM

Clustering groups similar items together without any labels. It is used for customer segmentation, grouping documents or support tickets, compressing colours in images, finding structure before labelling, and as a feature for downstream models. There is no single “right” clustering; each algorithm encodes a different idea of what a cluster is.

k-means

1. Initialise Pick k centroids (k-means++ spreads initial centroids apart, which is the scikit-learn default).
2. Assign Put each point in the cluster of its nearest centroid.
3. Update Move each centroid to the mean of its assigned points.
4. Repeat until assignments stop changing. Run several random starts (n_init) and keep the best.

Worked example. One-dimensional points {1, 2, 3, 10, 11, 12}, k = 2, initial centroids 1 and 2.

1. Assign 1 goes to centroid 1; 2, 3, 10, 11, 12 go to centroid 2.
2. Update Centroids become 1 and (2 + 3 + 10 + 11 + 12)/5 = 7.6.
3. Assign 1, 2, 3 are closer to 1; 10, 11, 12 are closer to 7.6.
4. Update Centroids become 2 and 11. Assignments no longer change: converged, with inertia 1 + 0 + 1 + 1 + 0 + 1 = 4.

Choosing k and judging clusters

• Elbow method: plot inertia against k; pick the point where adding clusters stops helping much.
• Silhouette score: s = (b − a) / max(a, b), where a is the mean distance to points in your own cluster and b the mean distance to the nearest other cluster. Ranges from −1 to 1; higher is better.
• Davies–Bouldin (lower is better) and Calinski–Harabasz (higher is better) are other internal indices. If some true labels exist, use Adjusted Rand Index or normalised mutual information.
• Ultimately, business usefulness decides: can the marketing team act on these segments?

k-means limitations: assumes roughly spherical, similar-sized clusters; needs k in advance; sensitive to scale, outliers and initialisation; only works with means (Euclidean). k-medoids uses actual points as centres and any distance; mini-batch k-means scales to huge data.

Hierarchical (agglomerative) clustering

Start with every point as its own cluster and repeatedly merge the two closest clusters, producing a tree called a dendrogram. Cutting the dendrogram at a chosen height gives any number of clusters without rerunning. The linkage defines “closest”: single (nearest pair; finds chains, sensitive to noise), complete (farthest pair; compact clusters), average, and Ward (merge that least increases variance; the usual default). Cost is at least O(n²) memory, so it suits thousands of points, not millions.

DBSCAN

Density-based clustering: a point with at least min_samples neighbours within radius eps is a core point; clusters grow by connecting core points that are within eps of each other; points reachable from a core point but not core themselves are border points; everything else is noise. DBSCAN finds arbitrarily shaped clusters, does not need k, and labels outliers explicitly (label −1). It struggles when clusters have very different densities (HDBSCAN addresses this) and in high dimensions. Choose eps from the “knee” of a sorted k-distance plot.

Gaussian mixture models (GMM)

A GMM assumes the data comes from a mixture of k Gaussian distributions, each with its own mean, covariance and weight, and fits them with the Expectation–Maximization (EM) algorithm: the E-step computes each point's probability of belonging to each component (soft assignment), the M-step re-estimates means, covariances and weights from those probabilities. GMM gives soft memberships and elliptical clusters; k-means is the special case with hard assignments and equal spherical covariances. Choose k with BIC or AIC.

from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.mixture import GaussianMixture
from sklearn.metrics import silhouette_score

Xs = StandardScaler().fit_transform(X)
for k in range(2, 9):
    km = KMeans(n_clusters=k, n_init=10, random_state=42).fit(Xs)
    print(k, round(km.inertia_, 1), round(silhouette_score(Xs, km.labels_), 3))

db_labels = DBSCAN(eps=0.5, min_samples=5).fit_predict(Xs)          # -1 = noise
agg_labels = AgglomerativeClustering(n_clusters=4, linkage="ward").fit_predict(Xs)
gmm = GaussianMixture(n_components=4, covariance_type="full", random_state=42).fit(Xs)
soft = gmm.predict_proba(Xs)        # probability of each point belonging to each component
print("BIC:", gmm.bic(Xs))

Dimensionality reduction: PCA, t-SNE and UMAP

Real data often has hundreds or thousands of features (a 224×224 colour image has about 150,000 pixel values), but most of the meaningful variation lives in far fewer directions. Dimensionality reduction compresses data to fight the curse of dimensionality, speed up models, remove noise and redundancy, and make data visible in 2D.

Principal component analysis (PCA)

1. Standardize each feature (PCA chases variance, so unscaled large-range features dominate).
2. Covariance Compute the d×d covariance matrix Σ = (1/(n−1)) X^TX of the centred data.
3. Eigen-decompose Eigenvectors of Σ are the principal directions; eigenvalues are the variance along each. In practice libraries use the SVD of X, which is more stable.
4. Keep top k Sort by eigenvalue and keep the first k components.
5. Project Z = X W_k, where W_k holds the k eigenvectors as columns.

Worked example. Four standardized features give eigenvalues 4.2, 1.1, 0.5 and 0.2 (total 6.0). PC1 explains 4.2/6.0 = 70%; PC1 + PC2 explain 5.3/6.0 ≈ 88%. Keeping two components retains 88% of the variance with half the dimensions. A common rule is to keep enough components for 90–95% of the variance, or pick k by downstream cross-validated performance.

• PCA is linear and unsupervised: the directions of greatest variance are not necessarily the most predictive of the label. LDA (linear discriminant analysis) is the supervised alternative that maximises class separation.
• Components are combinations of all original features, so they are harder to interpret.
• Variants: Incremental PCA (streaming), Kernel PCA (non-linear), Truncated SVD (works directly on sparse TF-IDF matrices; called LSA in text).

t-SNE and UMAP

Both are non-linear methods built mainly for visualization. t-SNE converts high-dimensional distances into neighbour probabilities (Gaussian) and finds a 2D layout whose neighbour probabilities (heavy-tailed Student-t) match, minimising KL divergence. It preserves local neighbourhoods beautifully, but cluster sizes and between-cluster distances in the plot are not meaningful, results depend on perplexity and the random seed, and it is slow. UMAP rests on manifold and graph ideas, is much faster, scales to millions of points, preserves more global structure, and can transform new points.

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.manifold import TSNE
from sklearn.linear_model import LogisticRegression

pca = make_pipeline(StandardScaler(), PCA(n_components=0.95))   # keep 95% of variance
Z = pca.fit_transform(X_train)
print(Z.shape, pca[-1].explained_variance_ratio_.cumsum())

clf = make_pipeline(StandardScaler(), PCA(n_components=10), LogisticRegression(max_iter=1000))
clf.fit(X_train, y_train)                                       # PCA fitted inside the pipeline

emb_2d = TSNE(n_components=2, perplexity=30, random_state=42).fit_transform(X_sample)

Anomaly detection

Anomaly (outlier, novelty) detection finds rare observations that differ from the bulk of the data: fraudulent transactions, failing machines, network intrusions, sensor glitches, defective products. The defining difficulty is that anomalies are rare, varied, and often unlabelled, so the problem is usually framed as learning what “normal” looks like.

Worked example (z-score). Daily transaction amounts for a customer have mean 50 and standard deviation 12. A 110 transaction has z = (110 − 50)/12 = 5.0, far beyond the usual cutoff of 3, so it is flagged. Note that z-scores assume a roughly normal distribution; for skewed money data, a log transform or the IQR rule is safer.

from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor

iso = IsolationForest(n_estimators=300, contamination=0.01, random_state=42).fit(X_train)
scores = -iso.score_samples(X_new)          # higher = more anomalous
flags = iso.predict(X_new)                  # -1 = anomaly, 1 = normal

lof = LocalOutlierFactor(n_neighbors=20, novelty=True).fit(X_train)
lof_flags = lof.predict(X_new)

Recommender systems basics

Recommenders predict which items (movies, products, songs, posts) a user will value. They mix ideas from supervised learning, matrix factorization, nearest-neighbour search and ranking, and they are a favourite ML system-design interview topic.

Worked example. With two latent factors (action, romance), a user vector p = (0.9, 0.1) and a movie vector q = (4.5, 0.5) give a predicted score of 0.9 × 4.5 + 0.1 × 0.5 = 4.1; the same user with a romance film q = (0.5, 4.8) scores 0.45 + 0.48 = 0.93. The action film is recommended.

Production architecture and pitfalls

1. Candidate generation Retrieve hundreds of items from millions quickly (item-item similarity, two-tower embeddings with approximate nearest-neighbour search, popularity).
2. Ranking Score candidates with a richer model (gradient boosting or a deep network using user, item and context features) predicting click, watch time or purchase.
3. Re-ranking Apply business rules, diversity, freshness, fairness, and deduplication.

• Cold start: new users or items have no history. Use content features, popularity, onboarding questions, or exploration.
• Implicit vs explicit feedback: clicks and watch time are plentiful but noisy; star ratings are clean but rare. A missing interaction is not a negative.
• Metrics: offline precision@k, recall@k, NDCG, MAP, hit rate, coverage and diversity; online click-through rate, conversion, retention through A/B tests.
• Feedback loops and popularity bias: the model only learns from what it showed; add exploration (bandits) and debiasing.

Bias–variance trade-off, overfitting and underfitting

Every model's expected error on new data can be split into three parts: bias (error from wrong or too-simple assumptions), variance (error from being too sensitive to the particular training sample) and irreducible noise (randomness no model can remove). Making a model more flexible lowers bias but raises variance, so the goal is the complexity that minimises their sum.

Model complexity:   very simple ---------- moderate ---------- very complex
Bias^2:             HIGH        falling      low         lower       lowest
Variance:           lowest      low          low-mid     rising      HIGH
Total error:        high        falling      MINIMUM     rising      high
Diagnosis:          underfit                 sweet spot              overfit
Examples:           linear fit on curves,    tuned depth /           1-NN, unpruned tree,
                    k-NN with huge k         tuned C or k            degree-15 polynomial

There are no universal numeric thresholds for “overfit”: judge by the gap between training and validation error and by comparison with a baseline and with the achievable error (human performance, or the noise level of the labels).

Learning curves and validation curves

import numpy as np
from sklearn.model_selection import learning_curve, validation_curve
from sklearn.tree import DecisionTreeClassifier

sizes, train_sc, val_sc = learning_curve(DecisionTreeClassifier(max_depth=5, random_state=42),
                                         X, y, cv=5, train_sizes=np.linspace(0.1, 1.0, 8),
                                         scoring="accuracy")
print(train_sc.mean(axis=1), val_sc.mean(axis=1))

depths = [1, 2, 3, 5, 8, 12, None]
tr, va = validation_curve(DecisionTreeClassifier(random_state=42), X, y,
                          param_name="max_depth", param_range=depths, cv=5)
for d, a, b in zip(depths, tr.mean(1), va.mean(1)):
    print(d, round(a, 3), round(b, 3))

Cross-validation and hyperparameter tuning

A single train/validation split gives a noisy estimate that depends on which rows happened to land where. Cross-validation (CV) reuses the data so that every row is validated once, giving both a more reliable mean score and a measure of its spread. Hyperparameter tuning then searches for the settings with the best cross-validated score.

k-fold cross-validation

Fold 1:  [VAL ][train][train][train][train]  -> score 1
Fold 2:  [train][VAL ][train][train][train]  -> score 2
Fold 3:  [train][train][VAL ][train][train]  -> score 3
Fold 4:  [train][train][train][VAL ][train]  -> score 4
Fold 5:  [train][train][train][train][VAL ]  -> score 5
Report: mean +/- std of the 5 scores   (test set stays sealed outside all of this)

A high mean with a large standard deviation (recall 0.95 ± 0.08) is less trustworthy than a slightly lower but stable score (0.93 ± 0.02). Stability across folds is part of model selection.

Bootstrap versus cross-validation

Cross-validation retrains the model on each fold and estimates how well the training procedure generalises. The bootstrap resamples a fixed set of predictions (or the raw data) with replacement to put an error bar on a statistic. Use CV to choose models and hyperparameters; use a paired bootstrap (or McNemar) on a sealed test set to say whether model A is really better than model B. The two are not interchangeable: a bootstrap of training accuracy is optimistic because every resample still overlaps the original training rows. Out-of-bag scores from bagged trees are the useful exception, because each tree is scored only on rows it never saw.

Hyperparameter search strategies

Search learning rates and regularization strengths on a log scale (0.001, 0.01, 0.1, 1, 10), because their effect is multiplicative.

from scipy.stats import loguniform, randint
from sklearn.model_selection import (StratifiedKFold, GridSearchCV, RandomizedSearchCV,
                                     cross_val_score)
from sklearn.ensemble import RandomForestClassifier

cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
search = RandomizedSearchCV(
    RandomForestClassifier(random_state=42, n_jobs=-1),
    {"n_estimators": randint(200, 1000), "max_depth": [None, 5, 10, 20],
     "max_features": ["sqrt", "log2", 0.3], "min_samples_leaf": randint(1, 10)},
    n_iter=40, scoring="average_precision", cv=cv, random_state=42, n_jobs=-1)
search.fit(X_train, y_train)
print(search.best_params_, search.best_score_)

# Nested CV: honest estimate of "tune + train" as a whole
inner = GridSearchCV(RandomForestClassifier(random_state=42),
                     {"max_depth": [5, 10, None]}, cv=3, scoring="roc_auc")
outer_scores = cross_val_score(inner, X_train, y_train, cv=5, scoring="roc_auc")
print(outer_scores.mean(), outer_scores.std())

final_score = search.best_estimator_.score(X_test, y_test)     # touch the test set once, at the end

Classification metrics with worked examples

The metric is the definition of success, so choosing it is a product decision disguised as a technical one. Start from the confusion matrix, then pick the metric that reflects the real cost of each kind of mistake.

The confusion matrix

                      PREDICTED
                   Positive      Negative
ACTUAL  Positive     TP            FN      <- missed cases (Type II error)
        Negative     FP            TN
                     ^
                     false alarms (Type I error)

scikit-learn's confusion_matrix puts actual classes in rows and predicted classes in columns, ordered by label value. With labels {0, 1}, it prints [[TN, FP], [FN, TP]], so the false negatives sit at position [1][0].

Worked example: a cancer screening model

On 1,000 test patients the model gives TP = 80, FP = 20, FN = 10, TN = 890.

The accuracy paradox

A hospital dataset has 9,900 healthy and 100 diseased patients. A model that always predicts “healthy” scores 9,900 / 10,000 = 99% accuracy while catching zero diseased patients: recall = 0, and precision is undefined (no positive predictions). Accuracy is dominated by the huge true-negative count. For a life-threatening disease, a missed case (false negative) is far costlier than a false alarm (an extra test), so the team should prioritise recall, subject to a precision floor so clinics are not flooded, and not the balanced F1, which assumes both errors cost the same.

Which metric when

Thresholds and the precision–recall trade-off

Most classifiers output a score or probability; the label comes from comparing it with a threshold (0.5 by default). Raising the threshold makes the model more cautious: precision rises, recall falls. Lowering it catches more positives at the cost of more false alarms. The threshold is a business decision and should be tuned on validation data.

ROC curve and ROC-AUC

The ROC curve plots true positive rate (recall) against false positive rate as the threshold sweeps from 1 down to 0. AUC (area under the curve) summarises it: 1.0 is perfect, 0.5 is random guessing, below 0.5 means the scores are inverted. AUC has a clean interpretation: the probability that a randomly chosen positive gets a higher score than a randomly chosen negative.

Worked example. Positives score 0.9, 0.8, 0.4; negatives score 0.7, 0.3. Of the 3 × 2 = 6 positive–negative pairs, the positive wins in 5 (only 0.4 vs 0.7 loses), so AUC = 5/6 ≈ 0.83.

Precision–recall curve and PR-AUC

The PR curve plots precision against recall across thresholds; its area is summarised by average precision (AP). A random classifier's PR-AUC equals the positive rate (for example 0.01 for 1% fraud), not 0.5. With heavy imbalance, ROC-AUC can look excellent because the FPR denominator (all negatives) is enormous, while PR-AUC exposes how many false alarms accompany each catch.

Log loss and the Brier score

Example: three predictions p = 0.9 (y = 1), 0.2 (y = 0), 0.6 (y = 0). Log loss = −(ln 0.9 + ln 0.8 + ln 0.4)/3 = (0.105 + 0.223 + 0.916)/3 ≈ 0.415. Brier = (0.01 + 0.04 + 0.36)/3 ≈ 0.137. The confident-ish wrong prediction (0.6 for a negative) contributes most of both.

Calibration

A model is calibrated if, among all cases it scores 0.8, about 80% are actually positive. Calibration is about trustworthy confidence; accuracy is about correctness; AUC is about ranking. A model can rank perfectly (AUC 1.0) and still be badly calibrated.

• Typical behaviour: logistic regression is usually well calibrated; Naive Bayes is overconfident; SVM scores are not probabilities; random forests are under-confident near 0 and 1; boosted trees and deep networks are often overconfident; class reweighting and resampling distort probabilities.
• Diagnose with a reliability diagram (calibration_curve) and expected calibration error (ECE).
• Fix with Platt scaling (a sigmoid fitted on validation scores), isotonic regression (non-parametric, needs more data), or temperature scaling for neural nets. Calibration rarely changes ranking or accuracy, but it makes probabilities usable for thresholds, expected-value decisions and pricing.

Multiclass averaging

Example: three classes with per-class F1 of 0.95 (500 samples), 0.90 (400) and 0.40 (100). Macro-F1 = (0.95 + 0.90 + 0.40)/3 = 0.75; weighted-F1 = (0.95 × 500 + 0.90 × 400 + 0.40 × 100)/1000 = 0.875. The weighted number hides the failing rare class. Other multiclass metrics: Cohen's kappa (agreement beyond chance), Matthews correlation coefficient (MCC, robust on imbalance), top-k accuracy.

import numpy as np
from sklearn.metrics import (confusion_matrix, classification_report, precision_score,
                             recall_score, f1_score, roc_auc_score, average_precision_score,
                             log_loss, brier_score_loss, precision_recall_curve,
                             matthews_corrcoef)
from sklearn.calibration import calibration_curve, CalibratedClassifierCV

proba = model.predict_proba(X_val)[:, 1]
y_hat = (proba >= 0.5).astype(int)

tn, fp, fn, tp = confusion_matrix(y_val, y_hat).ravel()
print(classification_report(y_val, y_hat, digits=3))
print("ROC-AUC", roc_auc_score(y_val, proba), "PR-AUC", average_precision_score(y_val, proba))
print("log loss", log_loss(y_val, proba), "Brier", brier_score_loss(y_val, proba))
print("MCC", matthews_corrcoef(y_val, y_hat))

# pick the highest threshold that still gives recall >= 0.95 (on VALIDATION data)
prec, rec, thr = precision_recall_curve(y_val, proba)
ok = np.where(rec[:-1] >= 0.95)[0]
t_star = thr[ok[-1]]
print("threshold", t_star, "precision", prec[ok[-1]], "recall", rec[ok[-1]])

frac_pos, mean_pred = calibration_curve(y_val, proba, n_bins=10)   # reliability diagram data
calibrated = CalibratedClassifierCV(base_model, method="isotonic", cv=5).fit(X_train, y_train)

Regression metrics with a worked example

Regression metrics measure how far predictions are from actual numbers. The choice again depends on the cost of errors: are big misses disproportionately bad? Are relative errors what matters? Do you need a scale-free number to compare across problems?

Worked example. Actual values 3, 5, 2, 8; predictions 2.5, 5, 4, 7.

MAE = 3.5/4 = 0.875. MSE = 5.25/4 = 1.3125. RMSE = √1.3125 ≈ 1.146. R² = 1 − 5.25/21 = 0.75, so the model explains 75% of the variance around the mean. Notice RMSE > MAE because the single error of 2 is amplified by squaring; RMSE is always ≥ MAE, and a big gap between them signals a few large errors.

from sklearn.metrics import (mean_absolute_error, mean_squared_error, r2_score,
                             mean_absolute_percentage_error)
import numpy as np
y_true = np.array([3, 5, 2, 8]); y_pred = np.array([2.5, 5, 4, 7])
print(mean_absolute_error(y_true, y_pred))            # 0.875
print(mean_squared_error(y_true, y_pred))             # 1.3125
print(np.sqrt(mean_squared_error(y_true, y_pred)))    # 1.146
print(r2_score(y_true, y_pred))                       # 0.75
print(mean_absolute_percentage_error(y_true, y_pred))

Handling class imbalance

Imbalance is the norm for the most valuable problems: fraud (0.1%), rare disease (1%), churn (5%), click-through (2%), defects. The model sees so few positives that simply predicting “negative” minimises most losses. Imbalance is handled at four levels: the metric, the data, the algorithm, and the decision threshold.

Worked example. With 9,900 negatives and 100 positives, balanced weights are 10,000 / (2 × 9,900) ≈ 0.505 for negatives and 10,000 / (2 × 100) = 50 for positives, so each positive counts about 99 times as much as each negative in the loss. For SMOTE, a minority point (2, 3) with neighbour (4, 7) and λ = 0.25 creates (2 + 0.5, 3 + 1) = (2.5, 4.0).

from imblearn.pipeline import Pipeline as ImbPipeline      # imbalanced-learn package
from imblearn.over_sampling import SMOTE
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import StratifiedKFold, cross_val_score

pipe = ImbPipeline([("scale", StandardScaler()),
                    ("smote", SMOTE(k_neighbors=5, random_state=42)),   # applied to training folds only
                    ("clf", LogisticRegression(max_iter=5000))])
cv = StratifiedKFold(5, shuffle=True, random_state=42)
print(cross_val_score(pipe, X_train, y_train, cv=cv, scoring="average_precision").mean())

# Often simpler and as good: class weights + threshold tuning
weighted = LogisticRegression(class_weight="balanced", max_iter=5000)

Interpretability and explainability

Stakeholders, regulators and debugging all need to know why a model predicts what it does. Global explanations describe the model overall (which features matter most); local explanations justify a single prediction (why was this loan rejected). Models are either intrinsically interpretable (linear models, small trees) or explained post hoc with model-agnostic tools.

from sklearn.inspection import permutation_importance, PartialDependenceDisplay

r = permutation_importance(model, X_val, y_val, n_repeats=10, scoring="roc_auc", random_state=42)
for i in r.importances_mean.argsort()[::-1][:10]:
    print(feature_names[i], round(r.importances_mean[i], 4), "+/-", round(r.importances_std[i], 4))

PartialDependenceDisplay.from_estimator(model, X_val, features=["age", "income"])

import shap                                   # separate package
explainer = shap.TreeExplainer(tree_model)
shap_values = explainer.shap_values(X_val)
shap.summary_plot(shap_values, X_val)        # global view built from local explanations

MLOps basics: deployment, monitoring and drift

A model in a notebook creates no value. MLOps is the set of practices that makes models reproducible, deployable, observable and maintainable: essentially DevOps plus data and model versioning, plus the fact that ML systems silently decay as the world changes.

Deployment patterns

Safe rollout

• Shadow mode: the new model scores live traffic silently alongside the old one; compare without user impact.
• Canary release: send a small percentage of traffic to the new model, watch metrics, then ramp up.
• A/B test: randomised split with a pre-registered online metric and enough sample size for statistical significance.
• Rollback: keep the previous model version deployable in one step.

Kinds of drift

Worked example. A feature has training bin fractions (0.5, 0.3, 0.2) and live fractions (0.3, 0.3, 0.4). PSI = (0.3 − 0.5) ln(0.3/0.5) + 0 + (0.4 − 0.2) ln(0.4/0.2) = (−0.2)(−0.511) + (0.2)(0.693) ≈ 0.102 + 0.139 = 0.241, a moderate shift close to the alarm level.

What to monitor

1. System health Latency, throughput, error rates, memory, cost.
2. Data quality Schema changes, missing-value rates, out-of-range values, new categories.
3. Drift Feature and prediction distributions against the training reference.
4. Model performance Metrics on delayed ground-truth labels, broken down by segment.
5. Business KPIs The outcome the model is meant to move, plus fairness metrics across groups.

The supporting toolkit

import joblib
joblib.dump(pipeline, "churn_model_v3.joblib")       # preprocessing + model together
model = joblib.load("churn_model_v3.joblib")
proba = model.predict_proba(new_rows)[:, 1]

import numpy as np
def psi(expected, actual, bins=10):
    edges = np.quantile(expected, np.linspace(0, 1, bins + 1))
    edges[0], edges[-1] = -np.inf, np.inf
    e = np.histogram(expected, edges)[0] / len(expected) + 1e-6
    a = np.histogram(actual, edges)[0] / len(actual) + 1e-6
    return float(np.sum((a - e) * np.log(a / e)))

Reinforcement learning essentials

Reinforcement learning (RL) is learning by trial and error: an agent takes actions in an environment, receives rewards, and learns a policy that maximises total future reward. There are no labelled correct actions, only delayed feedback. RL powers game-playing agents, robotics, some recommendation and ad-bidding systems, and the RLHF stage that aligns large language models.

          action a_t
   +---------+  ----------->  +-------------+
   |  Agent  |                | Environment |
   | (policy)|  <-----------  |             |
   +---------+  state s_t+1,  +-------------+
                reward r_t+1

Worked example. Q(s, right) = 0, the agent moves right, receives r = 1, and the best Q-value in the next state is 2. With α = 0.5 and γ = 0.9: Q(s, right) ← 0 + 0.5 × (1 + 0.9 × 2 − 0) = 0.5 × 2.8 = 1.4. Repeating such updates over many episodes propagates reward information backwards through the states.

Why RL matters for LLMs: RLHF

1. Supervised fine-tuning A pretrained LLM is fine-tuned on human-written demonstrations.
2. Reward model Humans rank several model answers to the same prompt; a model is trained to predict those preferences, giving a scalar reward.
3. RL optimisation The LLM (the policy; its actions are tokens; the state is the prompt plus text so far) is optimised with PPO to maximise the reward model's score, with a KL penalty that keeps it close to the original model so it does not drift into reward hacking.
4. Alternatives Direct Preference Optimization (DPO) skips the explicit reward model and RL loop by optimising directly on preference pairs.

import numpy as np
n_states, n_actions = 16, 4
Q = np.zeros((n_states, n_actions))
alpha, gamma, eps = 0.1, 0.99, 1.0
for episode in range(5000):
    s = env.reset()
    done = False
    while not done:
        a = np.random.randint(n_actions) if np.random.rand() < eps else int(Q[s].argmax())
        s_next, r, done = env.step(a)
        target = r + (0 if done else gamma * Q[s_next].max())
        Q[s, a] += alpha * (target - Q[s, a])       # temporal-difference update
        s = s_next
    eps = max(0.05, eps * 0.999)                     # explore less over time

Choosing an algorithm: a practical cheat sheet

No algorithm wins everywhere (the “no free lunch” theorem). In practice the choice is driven by data type and size, the need for interpretability, latency and training budget, and whether you need probabilities.

1. Start with a dummy baseline and a simple model Logistic or linear regression gives a reference score and reveals data problems quickly.
2. Try a strong default Random forest or gradient boosting for tabular; fine-tuned pretrained networks for images and text.
3. Iterate on data and features before algorithms Better labels and features usually beat exotic models.
4. Tune with cross-validation, then compare on stability as well as mean score
5. Prefer the simpler model when scores are close Easier to explain, cheaper to serve, more robust to drift.

Quick revision

• ML learns rules from data plus answers; traditional programming applies hand-written rules to data.
• AI contains ML, which contains deep learning, which contains generative AI.
• Supervised learning uses labels (classification or regression); unsupervised finds structure; self-supervised makes labels from raw data; RL learns from rewards.
• Parameters are learned during training; hyperparameters are set before training and tuned on validation data.
• Train fits parameters, validation chooses hyperparameters and thresholds, test is used once for the final estimate.
• Use stratified splits for classification, time-based splits for temporal data and group splits for repeated entities.
• Leakage is information unavailable at prediction time reaching training; fit every preprocessing step on training data only, inside a Pipeline.
• Do not fill missing values with 0 unless zero is meaningful; use median, most-frequent, model-based imputation or a missing flag.
• One-hot for nominal low-cardinality features, ordinal for ordered ones, out-of-fold target encoding for high cardinality.
• kNN, k-means, SVM, PCA, regularized linear models and neural nets need scaling; tree models do not.
• Loss is per example, cost is the average (plus penalties); MSE for regression, cross-entropy for classification.
• Cross-entropy punishes confident wrong predictions hardest: −ln 0.05 ≈ 3.0 versus −ln 0.9 ≈ 0.1.
• Gradient descent updates θ ← θ − η∇J; too small a learning rate is slow, too large diverges.
• Linear and logistic regression have convex costs with one global minimum; neural networks do not.
• L2 (Ridge) shrinks all weights; L1 (Lasso) zeroes some (feature selection); Elastic Net mixes both.
• In scikit-learn, C = 1/λ: smaller C means stronger regularization.
• Logistic regression models log-odds linearly; e^w is the odds ratio per unit of a feature.
• kNN: small k overfits, large k underfits; suffers from the curse of dimensionality.
• Naive Bayes assumes conditional independence; use Laplace smoothing to avoid zero probabilities.
• Gini = 1 − Σp²; entropy = −Σp log₂p; trees choose the split with the largest impurity decrease.
• Unpruned trees overfit; control with max_depth, min_samples_leaf or cost-complexity pruning.
• Bagging reduces variance with parallel deep trees; boosting reduces bias with sequential shallow trees.
• Random forests decorrelate trees by sampling features at each split; about 36.8% of rows are out-of-bag per tree.
• Gradient boosting fits each new tree to the negative gradient (residuals for MSE) with a small learning rate.
• LightGBM grows leaf-wise with histograms; XGBoost uses second-order gains and regularized leaves; CatBoost handles categoricals with ordered statistics.
• Stacking trains a meta-model on out-of-fold predictions of diverse base models.
• SVM maximises the margin 2/‖w‖; C trades margin width for violations; the kernel trick replaces dot products.
• RBF γ large means wiggly, overfit boundaries; small means smooth ones.
• k-means minimises within-cluster squared distance, needs k, assumes spherical clusters and finds only a local optimum.
• DBSCAN finds arbitrary shapes and labels noise; GMM gives soft, elliptical clusters via EM.
• PCA projects onto orthogonal directions of maximum variance; standardize first; keep 90–95% variance or tune k.
• t-SNE and UMAP are for visualization; t-SNE distances between clusters are not meaningful.
• Expected error = bias² + variance + irreducible noise.
• Underfitting: both errors high. Overfitting: low train error, much higher validation error.
• k-fold CV gives a mean and a spread; use nested CV for an unbiased estimate of tuning plus training.
• CV estimates a training procedure's performance; the bootstrap puts error bars on a statistic of a frozen model. Do not substitute a training-set bootstrap for held-out CV.
• Leakage patterns: target proxies, future-looking windows, in-sample target encoding, IDs, fit-on-all preprocessing, duplicates, SMOTE-before-split, random splits of grouped or temporal data.
• Random search usually beats grid search for the same budget; search rates and penalties on a log scale.
• Precision = TP/(TP+FP); recall = TP/(TP+FN); F1 is their harmonic mean.
• With TP 80, FP 20, FN 10, TN 890: precision 0.80, recall 0.89, F1 0.84, accuracy 0.97.
• A 99%-accurate model on a 99:1 dataset can have zero recall; prefer recall, precision, F1 or PR-AUC.
• ROC-AUC is the probability a random positive outranks a random negative; PR-AUC is better when positives are rare.
• Cost-optimal threshold for calibrated probabilities is C_FP/(C_FP + C_FN); tune thresholds on validation data only.
• Calibration means predicted probabilities match observed frequencies; fix with Platt scaling or isotonic regression.
• Macro averaging treats classes equally; weighted averaging can hide a failing rare class.
• RMSE ≥ MAE; a large gap means a few big errors. R² can be negative on test data.
• Imbalance toolkit: right metric, stratification, class weights, resampling inside CV (SMOTE), threshold moving.
• SHAP values add up to prediction minus base value; importance is not causation.
• Drift types: data (P(X)), concept (P(y|X)), label (P(y)); PSI above 0.25 signals significant shift.
• A feature store is one definition of each feature, served offline (point-in-time training joins) and online (low-latency inference) to prevent training–serving skew.
• Ship the full preprocessing-plus-model pipeline as one artifact to avoid training–serving skew.
• Q-learning: Q ← Q + α[r + γ max Q′ − Q]; RLHF uses a reward model and PPO with a KL penalty.

Glossary

Accuracy

Fraction of all predictions that are correct; misleading on imbalanced data.

AdaBoost

Boosting method that reweights misclassified samples and combines weak learners with weights based on their error.

Anomaly detection

Finding rare observations that deviate from the normal pattern, often without labels.

AUC (ROC-AUC)

Area under the ROC curve; the probability a random positive is scored above a random negative.

Average precision (PR-AUC)

Summary of the precision–recall curve; its random baseline equals the positive rate.

Bagging

Training models on bootstrap samples and averaging them to reduce variance.

Bias (statistical)

Error from overly simple or wrong assumptions; systematic deviation from the truth.

Bias–variance trade-off

Increasing flexibility lowers bias but raises variance; the best model balances both.

Bootstrap

Resampling with replacement to estimate the sampling distribution of a statistic; not a substitute for cross-validation of a training procedure.

Brier score

Mean squared error of predicted probabilities versus 0/1 labels; a proper scoring rule, lower is better.

Calibration

Agreement between predicted probabilities and observed frequencies.

CatBoost

Gradient-boosting library with ordered target statistics for categorical features and symmetric trees.

Collaborative filtering

Recommending based on patterns of similar users or items in interaction data.

Concept drift

Change in the relationship between inputs and the target over time.

Confusion matrix

Table of actual versus predicted classes showing TP, FP, FN and TN counts.

Cost function

The aggregated loss over the dataset, often plus a regularization penalty, that training minimises.

Cross-entropy (log loss)

Loss for probabilistic classifiers that heavily penalises confident wrong predictions.

Cross-validation

Repeatedly splitting data into training and validation folds to estimate performance reliably.

Curse of dimensionality

As dimensions grow, data becomes sparse and distances lose meaning.

Data drift

Change in the input feature distribution between training and production.

Data leakage

Information unavailable at prediction time that contaminates training and inflates scores.

DBSCAN

Density-based clustering that finds arbitrary shapes and labels sparse points as noise.

Decision tree

Model that predicts by a sequence of threshold questions on features.

Early stopping

Halting training when validation performance stops improving.

Elastic Net

Regularization combining L1 and L2 penalties.

Entropy

Measure of impurity or uncertainty: −Σ p log₂ p.

Expectation–Maximization (EM)

Iterative algorithm alternating soft assignment and parameter re-estimation, used to fit GMMs.

F1 score

Harmonic mean of precision and recall.

Feature engineering

Creating or transforming input variables to expose signal to the model.

Feature store

Shared, versioned feature definitions with offline (training) and online (serving) paths, using point-in-time joins to avoid leakage and skew.

Gaussian mixture model (GMM)

Probabilistic model of data as a weighted mix of Gaussian components, giving soft cluster memberships.

Gini impurity

1 − Σ p²; the chance of mislabelling a random sample by labelling randomly from the node's class mix.

Gradient boosting

Sequentially adding trees fitted to the negative gradient of the loss.

Gradient descent

Optimisation that repeatedly steps parameters opposite the gradient of the cost.

Grid search

Exhaustive evaluation of every combination of listed hyperparameter values.

Hinge loss

max(0, 1 − y·f(x)); the SVM loss that ignores points beyond the margin.

Hyperparameter

Setting chosen before training, such as learning rate, depth, k or C.

Information gain

Reduction in entropy achieved by a split.

Isolation Forest

Anomaly detector that flags points isolated by few random splits.

k-means

Clustering that alternates assigning points to the nearest centroid and recomputing centroids.

Kernel trick

Computing dot products in a high-dimensional feature space via a kernel function without explicit mapping.

kNN

k-nearest neighbours: predicts from the labels of the k closest training points.

L1 regularization (Lasso)

Penalty on the sum of absolute weights; produces sparse models.

L2 regularization (Ridge)

Penalty on the sum of squared weights; shrinks all weights smoothly.

Learning rate

Step size of each gradient update, or shrinkage of each boosting tree.

LightGBM

Fast gradient-boosting library using histograms and leaf-wise tree growth.

LIME

Local explanation method fitting a simple surrogate model around one prediction.

Logistic regression

Linear classifier that maps a weighted sum through a sigmoid to a probability.

MAE

Mean absolute error; average absolute difference between prediction and truth.

Matrix factorization

Decomposing a user×item matrix into latent user and item vectors.

MSE / RMSE

Mean squared error and its square root; penalise large errors heavily.

Naive Bayes

Probabilistic classifier assuming features are independent given the class.

Nested cross-validation

Inner CV tunes hyperparameters, outer CV estimates performance of the whole procedure.

One-hot encoding

Representing a category as a binary vector with a single 1.

Out-of-bag (OOB)

Rows not drawn in a tree's bootstrap sample, usable as free validation data.

Overfitting

Learning noise in the training data, leading to poor performance on new data.

PCA

Principal component analysis: linear projection onto orthogonal directions of maximum variance.

Permutation importance

Drop in score when a feature's values are shuffled on held-out data.

Pipeline

Chained preprocessing and model steps fitted together to prevent leakage and skew.

Policy

In RL, the mapping from states to actions or action probabilities.

Precision

TP / (TP + FP): how often a positive prediction is correct.

PSI

Population Stability Index; measures distribution shift between a reference and live data.

Q-learning

Off-policy RL algorithm that learns action values via temporal-difference updates.

R-squared (R²)

Coefficient of determination: fraction of target variance explained relative to predicting the mean.

Random forest

Bagged decision trees with random feature subsets at each split.

Recall

TP / (TP + FN): fraction of actual positives that are caught; also sensitivity or TPR.

Reinforcement learning

Learning a policy by trial and error to maximise cumulative reward.

RLHF

Reinforcement learning from human feedback: optimising a model against a reward model trained on human preferences.

ROC curve

Plot of true positive rate against false positive rate across thresholds.

SHAP

Shapley-value explanations assigning each feature an additive contribution to a prediction.

Silhouette score

Cluster quality measure from −1 to 1 comparing own-cluster and nearest-other-cluster distances.

SMOTE

Synthetic Minority Over-sampling Technique; creates minority points by interpolating between neighbours.

Specificity

TN / (TN + FP): fraction of actual negatives correctly identified.

Stacking

Ensemble in which a meta-model learns to combine base models' out-of-fold predictions.

Support vectors

Training points on or inside the SVM margin that define the boundary.

SVM

Support vector machine: maximum-margin classifier, extendable with kernels.

t-SNE

Non-linear visualization method preserving local neighbourhoods in 2D or 3D.

Training–serving skew

Mismatch between features computed in training and in production.

UMAP

Fast non-linear dimensionality reduction preserving local and some global structure.

Underfitting

Model too simple to capture the pattern; high error on training and validation data.

Variance (model)

Sensitivity of the learned model to the particular training sample.

XGBoost

Regularized gradient-boosting library using second-order gradients and sparsity-aware splits.

Interview questions