Learn how machines learn from data: implement regression, trees, metrics, k-means, PCA and anomaly detection from scratch in NumPy, and practise honest evaluation.

Machine Learning Foundations

## Why this matters

"Machine learning" gets attached to everything from spam filters to self-driving cars, so it helps to have a precise definition. A machine learning (ML) system is a program whose behaviour is **learned from examples** instead of written as rules by hand. You do not write `if subject contains "free money" then spam`. You collect thousands of emails already marked spam or not spam, and an algorithm finds the patterns that separate them.

Before you write any code, the most valuable skill is **framing**: turning a vague business or science question into a learning problem with clear inputs, a clear output, and a way to tell whether the model is any good. A well-framed problem with a simple model beats a badly framed one with a fancy model every time.

## The vocabulary

Every tabular ML problem has the same parts:

- **Rows** (examples, samples, observations): one customer, one email, one lab sample.
- **Features** (inputs, `X`): the columns the model may look at, such as age, number of visits, or word counts.
- **Label** (target, `y`): the answer you want to predict, such as "churned or not" or "house price".
- **Model**: a function with adjustable **parameters** that maps features to a prediction.
- **Training**: choosing parameter values that make predictions match the labels on known examples.
- **Inference**: using the trained model on new rows where the label is unknown.

```text
features X                         label y
visits  spend  tenure_months  ->  churned
   3     120        14              0
   0      15         2              1
  11     480        30              0
```

## Supervised learning

In **supervised** learning every training row has a label, and the model learns to predict it. There are two main flavours:

- **Regression**: the label is a number. Predict a house price, tomorrow's energy demand, or a patient's length of stay.
- **Classification**: the label is a category. Spam or not, which of 10 digits, fraud or legitimate. Most classifiers output a **probability** for each class, and you pick a threshold to turn it into a decision.

Module 2 covers the core supervised models: linear and logistic regression, decision trees and random forests.

## Unsupervised learning

In **unsupervised** learning there are no labels. The goal is to find structure in the features themselves:

- **Clustering**: group similar rows, for example customer segments (k-means, Module 3).
- **Dimensionality reduction**: compress many correlated columns into a few, for plotting or as model input (PCA).
- **Anomaly detection**: flag rows that look unlike the rest, such as a strange transaction or a faulty sensor reading (isolation forest).

Unsupervised results are harder to evaluate because there is no right answer to compare against. You judge them by whether they are stable and useful to a human.

You will also hear of **reinforcement learning**, where an agent learns by trial and reward (games, robotics). It is outside this course.

## Framing worked examples

| Question | Label? | Problem type |
|---|---|---|
| Will this customer cancel in the next 30 days? | yes/no from history | supervised classification |
| How many kWh will this building use tomorrow? | past usage | supervised regression |
| What natural groups exist among our 50,000 customers? | none | clustering |
| Which of today's 1 million card payments look unusual? | rarely any | anomaly detection |
| Which of these 300 gene-expression columns carry most of the variation? | none | dimensionality reduction |

Notice that the same data can support different framings. Payment data with confirmed fraud labels supports supervised classification; without labels, you fall back to anomaly detection.

When you frame a problem, write down four things:

1. **The prediction** and when it is made ("at the start of each month, predict churn in the next 30 days").
2. **The features available at that moment**, and only those. Anything recorded later is off limits.
3. **The success metric** (accuracy, recall, mean absolute error) and the baseline to beat, such as "always predict the most common class".
4. **The cost of mistakes**. Missing a fraud case and blocking a good customer usually cost different amounts.

## The standard workflow

```text
frame the problem -> collect and clean data -> split train/validation/test
  -> engineer features -> train a model -> evaluate on validation
  -> tune -> final check on test -> deploy and monitor
```

This course walks through that loop. You will implement each algorithm from scratch with NumPy so you see what happens inside, and each lesson shows the matching scikit-learn call (`LinearRegression`, `KMeans`, `train_test_split`...), which is what you will use at work.

## When not to use ML

ML is the wrong tool when a simple rule works, when you have very little data, when you cannot get labels and cannot judge unsupervised results, or when a mistake is unacceptable and the model cannot be explained. "Flag every invoice over $10,000 for review" does not need a model.

## Common mistakes

- **Using features from the future.** A "cancellation reason" column only exists after the customer leaves; including it makes the model look perfect and useless.
- **No baseline.** 95% accuracy sounds great until you notice 95% of customers never churn.
- **Confusing correlation with cause.** A model that predicts well does not tell you what would happen if you changed a feature.
- **Skipping the framing.** Starting with "let's try a neural network" before agreeing what is being predicted, when, and why.

## Careers note

Data scientists and machine learning engineers use these ideas daily. Employers usually look for a bachelor's degree in a quantitative field or computer science (a master's is common for data science roles), plus a portfolio of real projects. Machine learning engineers also need solid production software skills. This course gives you the foundations; projects and practice on real data are what turn them into a job.

## Quick recap

- ML learns behaviour from examples instead of hand-written rules.
- Supervised learning predicts a known label (regression for numbers, classification for categories).
- Unsupervised learning finds structure without labels (clustering, dimensionality reduction, anomaly detection).
- Frame first: the prediction, the features available at prediction time, the metric and baseline, and the cost of mistakes.

## Try it

Take the quiz on the Do tab to check you can frame problems correctly.


Frame a real problem as supervised regression, supervised classification or an unsupervised task, with the right features and baseline.

What ML is

Supervised vs. Unsupervised Learning

Machine Learning & Artificial Intelligence: Crash Course Computer Science #34

## Why this matters

A model that has memorised its training data can look perfect and still fail on the next customer. The only honest way to know how a model will do on new data is to test it on data it has **never seen**, not during training, not during tuning, not while you chose features. That is what splitting is for, and getting it wrong is the most common reason ML results do not hold up.

## Three sets, three jobs

- **Training set** (often 60–80%): the model's parameters are fitted on it.
- **Validation set** (10–20%): you compare models and choose settings (hyperparameters) with it.
- **Test set** (10–20%): you look at it **once**, at the end, to report expected performance.

Why three and not two? Every time you check a score and change something, a little information about that set flows into your choices. After you have tried 50 settings against the validation set, its score is optimistic. The test set, untouched until the end, gives the unbiased estimate. In Lesson 12 you will replace the fixed validation set with cross-validation.

## Shuffle before you split (usually)

Data files are often sorted: by date, by region, by label. If you take the first 80% of a file sorted by label as training data, the test set may contain only one class. So you shuffle the row order with a **fixed random seed** (so the split is reproducible) and then cut.

```python
import numpy as np

rng = np.random.default_rng(42)
idx = rng.permutation(10)      # a shuffled 0..9, the same every run with seed 42
test_idx, train_idx = idx[:2], idx[2:]
```

Index arrays are the cleanest way to split: apply the same indices to `X` and `y` so rows and labels stay aligned.

Two important exceptions:

- **Time series**: never shuffle. Train on the past, test on the future (for example train on January–September, test on October). Shuffling would let the model peek at the future.
- **Groups**: if one patient has 20 rows, all 20 must land in the same set. Otherwise the model recognises the patient, not the pattern. scikit-learn has `GroupShuffleSplit` for this.

For classification with rare classes, use a **stratified** split so each set keeps the same class proportions (`train_test_split(..., stratify=y)`).

## Data leakage

**Leakage** is any way information from the validation or test data, or from the future, sneaks into training. It inflates scores and the model then disappoints in production. Typical leaks:

1. **Preprocessing fitted on all the data.** Computing the mean and standard deviation for scaling over the full dataset before splitting lets test statistics shape training. Fit preprocessing on the training set only, then apply those same numbers to validation and test.
2. **Target leakage.** A feature that is a consequence of the label: "account closed date" when predicting churn, or "treatment given" when predicting diagnosis.
3. **Duplicate or near-duplicate rows** across sets.
4. **Feature selection on the full dataset**, for example keeping the 20 columns most correlated with the label before splitting.

### Worked example: scaling without leakage

```python
X_train, X_test = X[train_idx], X[test_idx]

mean = X_train.mean(axis=0)      # statistics from TRAIN only
std = X_train.std(axis=0)

X_train_s = (X_train - mean) / std
X_test_s = (X_test - mean) / std   # same numbers, applied to test
```

The scaled training columns have mean 0 and standard deviation 1. The scaled test columns will be close to that but not exactly, and that is correct: it is how new data will look in production.

## The scikit-learn way

```python
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y)

scaler = StandardScaler().fit(X_train)     # fit on train only
X_train_s = scaler.transform(X_train)
X_test_s = scaler.transform(X_test)
```

A `Pipeline` (Lesson 10) bundles the scaler and the model so the "fit on train only" rule is applied automatically, even inside cross-validation.

## Common mistakes

- **Tuning on the test set.** If you look at test scores while choosing settings, the test set has become a second validation set.
- **Splitting after preprocessing**, which leaks statistics.
- **Random splits of time-ordered data**, which lets the model use the future.
- **No seed**, so nobody (including you next week) can reproduce the numbers.
- **Splitting rows when the real unit is a person, device or store.**

## Quick recap

- Train fits parameters, validation chooses settings, test is touched once.
- Shuffle with a fixed seed, except for time series (split by time) and grouped data (split by group).
- Fit every preprocessing step on the training set only.
- If a score looks too good to be true, look for leakage first.

## Try it

On the Do tab, write a reproducible shuffled split and a scaler that is fitted on the training rows only.


Split data into training, validation and test sets reproducibly, and keep test information from leaking into training.

Train, validation, and test

Train, Test, & Validation Sets explained

## Why this matters

Almost every model in machine learning is trained the same way: define a **loss** that measures how wrong the predictions are, then adjust the parameters step by step to make the loss smaller. The step-by-step method is **gradient descent**. Linear and logistic regression, neural networks and gradient-boosted trees all rely on it or on a close relative. If you understand it for a straight line, you understand the core of training.

## The setup: fitting a line

Model: `y_hat = w * x + b`, with two parameters, the slope `w` and the intercept `b`.

Loss: **mean squared error** over the `n` training points.

```text
MSE(w, b) = (1/n) * sum( (w*x_i + b - y_i)^2 )
```

The MSE is a bowl-shaped surface over the `(w, b)` plane. We want the bottom of the bowl.

## The gradient

The **gradient** is the vector of partial derivatives. It points uphill, in the direction where the loss grows fastest. With the error `e_i = w*x_i + b - y_i`, the chain rule gives

```text
dMSE/dw = (2/n) * sum( e_i * x_i )
dMSE/db = (2/n) * sum( e_i )
```

If the predictions are too high on average, `dMSE/db` is positive, so we should decrease `b`. Gradient descent does exactly that: step **against** the gradient.

## The algorithm

```text
start with w = 0, b = 0
repeat for a number of steps:
    compute the gradient (dw, db)
    w = w - learning_rate * dw
    b = b - learning_rate * db
```

In NumPy, the whole dataset is processed at once (vectorised), so each step is a few lines:

```python
import numpy as np

def gradients(w, b, x, y):
    err = w * x + b - y
    return 2 * np.mean(err * x), 2 * np.mean(err)

w, b, lr = 0.0, 0.0, 0.01
for step in range(5000):
    dw, db = gradients(w, b, x, y)
    w -= lr * dw
    b -= lr * db
```

### Worked example: one step by hand

Data: `x = [1, 2, 3]`, `y = [2, 4, 6]` (the true line is `y = 2x`). Start at `w = 0, b = 0`, learning rate 0.1.

```text
errors e = [0-2, 0-4, 0-6] = [-2, -4, -6]
dw = (2/3) * (-2*1 + -4*2 + -6*3) = (2/3) * (-28) = -18.67
db = (2/3) * (-2 - 4 - 6)        = -8
w = 0 - 0.1 * (-18.67) = 1.867
b = 0 - 0.1 * (-8)     = 0.8
```

One step moved the slope from 0 most of the way to 2. Further steps shrink the remaining error.

## The learning rate

The **learning rate** sets the step size and is the setting that matters most:

- **Too small**: progress is very slow; you need many steps.
- **Too large**: each step overshoots the bottom of the bowl, the loss grows, and the parameters blow up to `inf` or `nan`.
- **About right**: the loss falls quickly and then levels off.

Always record the loss at every step (the **loss curve**). A healthy curve goes down and flattens. A curve that rises or zigzags means the learning rate is too big.

Features on very different scales make the bowl long and narrow, which forces a small learning rate. Standardising features (Lesson 2) makes gradient descent converge much faster.

## Checking your answer

For linear regression there is an exact solution (least squares), so you can check gradient descent against it:

```python
w_exact, b_exact = np.polyfit(x, y, 1)    # degree-1 least-squares fit
```

After enough steps with a sensible learning rate, gradient descent agrees to several decimal places. In scikit-learn, `LinearRegression` uses the exact solution, while `SGDRegressor` uses **stochastic** gradient descent: it updates on small random batches of rows instead of the whole dataset, which is how models scale to millions of rows.

## Variants you will meet

- **Batch gradient descent**: the full dataset per step (what you write today).
- **Stochastic / mini-batch**: a random subset per step; noisier but much cheaper per step.
- **Momentum and Adam**: keep a running average of past gradients to move faster along shallow directions. Adam is the default optimiser for neural networks.

## Common mistakes

- **Adding the gradient instead of subtracting it**, which climbs the bowl.
- **Forgetting the `2/n`** or using a sum instead of a mean, which silently changes the effective learning rate as the dataset grows.
- **Updating `w` before computing the gradient for `b`**, so the two gradients come from different points. Compute both, then update both.
- **Not plotting or printing the loss**, so divergence goes unnoticed.

## Quick recap

- Training = minimising a loss. Gradient descent repeatedly steps against the gradient.
- For a line with MSE: `dw = 2*mean(e*x)`, `db = 2*mean(e)`.
- The learning rate controls stability and speed; watch the loss curve.
- Scaled features and mini-batches make gradient descent practical at scale.

## Try it

On the Do tab, implement the gradient and the training loop, then check your line against the exact least-squares fit.


Train a straight-line model by repeatedly stepping against the gradient of the mean squared error.

Gradient descent

Gradient Descent, Step-by-Step

Gradient descent, how neural networks learn | Deep Learning Chapter 2

Frame problems as supervised or unsupervised learning, split data without leakage, and train a model with gradient descent.