Introduction to Machine Learning

Data is measurements that have already happened. Every dot is one measurement, and nothing about it is in doubt. Data is the past, written down.

A model is a rule short enough to write down that answers questions the data never asked. The line is a model: two numbers long, and it will give you an answer for any warmth at all, including warmths nobody has ever seen. That is the trade. Data is trustworthy and silent about anything it does not cover. A model always answers, and can be wrong.

A slope of 2 climbs 2 for every 1 you move to the right. A slope of 0.5 climbs half a step for every whole step across, so it looks gentle. A slope of 0 is flat, and the line answers the same number for every warmth. A negative slope goes downhill, which for this data would mean fewer drinks on warmer days.

The height is easier to spot: it is where the line crosses the left-hand edge, at zero across. Drag one handle and both numbers change, because tilting the line about one end moves the other end too. Drag both handles the same distance in the same direction and the height moves while the slope stays put. To store this model you do not keep the dots, you keep the two numbers.

Because misses come in two directions. A dot above the line is missed by a positive amount and a dot below it by a negative amount, so adding the raw misses lets them cancel out. A terrible line with half the dots far above and half far below would score zero, which is nonsense. Multiplying a number by itself always gives something positive, so nothing can cancel.

It also decides what counts as bad. Multiplied by itself, a miss of 10 costs 100 while a miss of 1 costs 1. So one big miss costs more than ten small ones, and a line that fits everything roughly will beat a line that nails most dots and abandons one. Whether that is what you want is a real choice, and Step 11 is about the trouble it can cause.

A slope answers how steeply one thing changes when another changes. On a hill it is metres climbed per metre walked. Here it is loss gained per unit of weight added. To measure it you need two readings and a subtraction: change the weight by a small amount, see how much the loss moved, and divide the change in loss by the change in weight.

So a slope of minus 4 means: for every 1 you add to this weight, the loss drops by about 4. Negative says the loss falls when the weight rises, so raise it. Positive says the opposite. Zero says you are at the bottom and nothing local will help. Textbooks work slopes out with calculus instead of measuring them, which is faster and gives the same answer. Measuring is doing the same thing with arithmetic.

Knowing which way to move does not tell you how far. The slope says "downhill is that way", and it says nothing reliable about how long the hill stays that way. So a size has to be chosen. That size is the learning rate. Each round, every weight moves by the slope multiplied by the learning rate, in the downhill direction.

Small rate, small careful steps, slow but safe. Large rate, big strides, fast until it is not. Too large and each step flies past the bottom and lands further up the far side, so the next step is bigger still and the whole thing runs away. That is not a bug in the method. It is the method being handed a number that does not suit the problem, and it is the single most common thing to go wrong in real work.

For a straight line, yes. There is a formula that takes the dots and hands back the best possible slope and height in one go, with no stepping and no rate to choose. Fitting a line is a solved problem and has been since the early 1800s. If your task really is a line, use the formula.

The reason to learn the slow way is that the formula stops existing almost immediately. The tiny network in Step 9 has no such shortcut, and neither does anything larger. Rolling downhill is the method that keeps working when the model gets complicated, which is why it is the one worth understanding on something simple enough to watch. Safe to skip: nothing later depends on this note.

Near enough, yes. If you wrote your data as a table with one row per flat, then each column is a feature: area, age, floor number, distance to the station. The thing you are trying to predict gets its own column and is not a feature. It is called the target, or when it is a yes-or-no answer, the label.

Choosing which features to measure is the part of this work that machines are worst at and people are best at. A weak model on well-chosen features usually beats a strong model on careless ones, and Step 5 is a whole step built on that fact.

Because there is nowhere to draw it. One input and one answer make a flat picture with dots and a line. Two inputs and one answer would need a solid picture with a tilted sheet floating in it, which is already awkward on a screen. Three inputs needs a direction that does not exist.

So past two features, pictures stop being the tool and numbers take over. That is why this lab shows you bars for the weights and one loss number instead of a scatter. Getting comfortable reading a model you cannot see is not a loss of understanding. It is most of the job, since real models have hundreds of features.

It works out the average of a feature and how spread out it is, then rewrites every value as how many spreads it sits away from that average. Floor areas that ran from about 30 to about 120 come out running from roughly minus one and a half to plus one and a half. Ages do the same. Both features now live on the same scale, so one step size suits both.

Nothing about the flats changed. A flat that was the third largest is still the third largest, and the ordering and the spacing are untouched. What changed is the size of the numbers the model is handed and the weights come out correspondingly bigger or smaller to compensate. If you want the weights back in pounds per square metre afterwards, you undo the same arithmetic.

A class is one of the answers allowed. In this lab there are two, and they are drawn as circles and squares. A label is the true answer attached to one particular dot, which somebody had to find out and write down. Labelled data is expensive: somebody read the email and said junk or not junk. A model that predicts labels is called a classifier.

This step uses two classes, so one boundary is enough. A multiclass classifier can produce one score per class and select the largest, or combine several binary decisions. Later courses cover those designs.

The same arithmetic as Step 3, one step further. Multiply each feature by its weight, add them up, add the height. Call the result the score. Dots on one side of the line give a positive score, dots on the other give a negative one, and dots exactly on the line score zero. So the line is not really the model; the model is the score, and the line is where the score happens to be zero.

A raw score is awkward to talk about, because it can be 0.3 or 400 and neither means much on its own. So the score gets squashed into a number between 0 and 1 by a fixed rule. Large positive scores come out near 1 and large negative ones near 0, and a score of zero comes out at exactly one half. That squashed number is read as a probability and the next lab shows it.

It means the model is on the circle side of the fence but not far from it. If the score is well calibrated, then among many dots scored near 0.7, about seven in ten are circles. Test calibration by grouping held-out dots with similar scores and comparing each group's mean score with its observed rate.

It does not mean the model has thought about it, and it does not mean there is a seven in ten chance for this particular dot, which either is or is not a circle. Nor does the number know whether the dot is anything like the data the model was trained on. That last gap is where Step 11 lives.

It means working out a new number from the ones you already have, and handing that to the model as well. Say each dot has an across value and an up value. You can work out how far it sits from the middle of the grid, and hand the model that distance as a third thing to look at. No new measurement was taken. The distance was always implied by the two numbers; the model simply could not see it, because a model that multiplies and adds cannot work out a distance.

This is called feature engineering, and for most of the history of this subject it was where the skill lived. Somebody who understood the problem invented the right thing to measure, and then a simple model was enough.

Neither, strictly. Every dot has the same two measurements it started with. The second grid is a picture of a third number computed from them, so the same dot appears in a different place because it is being plotted against something different. Think of photographing a crowd from the side rather than from above: nobody moved, and now you can see who is tall.

That is why the circle appears when you map the answer back. The model's rule, in the new picture, is "distance from the middle is less than about four". Written back in the original two numbers, that sentence describes a circle. Same rule, two languages.

Several. Computing new features and handing them over is a feature map. There is a family of methods called kernel methods that get the effect of an enormous pile of extra features without ever computing them. That was the state of the art for years and is still worth knowing about.

And there is the other answer, which is Step 9. Instead of inventing the useful features yourself, you build a model with a layer whose job is to invent features, and let it discover the distance idea on its own. That is what the word deep in deep learning refers to. Safe to skip: later steps do not depend on the names.

Noise is the part of a measurement that has nothing to do with what you are trying to predict. The shop sold three extra drinks on Tuesday because a coach party stopped. Warmth did not cause that, and nothing about warmth will ever predict it. Real measurements always carry some, from rounding, from mistakes, from a hundred causes nobody recorded.

You cannot see which part of a single dot is noise, which is precisely the difficulty. What you can see is that it does not repeat: a pattern caused by noise in these dots will not appear in the next batch, while a real pattern will. That is the whole basis of every honest test in this course, and Step 7 turns it into a procedure.

A straight line is built from one multiply: the input times its weight, plus a height. Allow the input multiplied by itself as a second feature and the model can bend once, into an arch or a bowl. Allow it multiplied by itself again and it can bend twice, and so on. The slider is choosing how many of those extra features to hand over. That count is the curve's degree.

So a wiggly curve is not a new kind of model. It is the linear model from Step 3, given features that were computed from the one input by multiplying it by itself repeatedly. All the machinery is the same, which is why the slider can go up without anything else changing. Weights are what buy the bending: a curve of degree 9 has ten of them, and ten weights aimed at ten dots can be made to pass exactly through every one. The lab gives it twelve dots and stops the slider at nine, so it never quite gets to thread them all. It gets close enough to make the point, and the point is that being able to is not a virtue.

Because nothing was holding it down out there. The fitting only cares about the loss on the dots it was given, so beyond the last dot the curve is free to do whatever the weights happen to imply, and at nine wiggles those weights are large and fighting each other. One step past the data the fight stops cancelling out.

Answering a question inside the range of your data is called interpolating; answering one outside it is extrapolating, and it is far less safe. A straight line at least goes somewhere sensible out there. A high-wiggle curve can predict a shop selling minus four hundred drinks. Safe to skip: nothing later depends on the words.

A test tells you something only if the answers were not available while you were preparing. That is why exams are not handed out in advance. The same reasoning applies here, and the thing being tested is the weights and every decision that went into the model, including which wiggle setting you chose and how many things you tried.

So the question to ask about any reported score is simple. Was any of this data used, in any way, to make any decision about this model? If yes, the score is optimistic, and usually by more than people expect.

Three jobs, three piles. The training set sets the weights. The validation set is what you look at while making choices: how many wiggles, which features, which learning rate. You may look at it as often as you like, and its score will slowly become flattering for exactly the reason Lab 13 shows. The test set is opened once, at the end, to report a number.

That is the whole rule. Choose on validation, report on test, and if you go back and change the model after seeing the test number, then you have used it for choosing and it is now a validation set. Real teams cheat at this constantly and mostly by accident.

Then you reuse it carefully. Cut the training data into five equal parts, fit five times, each time holding out a different part and scoring on it, and average the five scores. Every dot gets used for fitting four times and for scoring once, and you get a steadier estimate than any single small pile would give. This is cross-validation. It is what most careful small-data work does.

The test pile stays out of it either way. Cross-validation replaces the validation pile, not the test pile. Safe to skip: nothing later needs it.

Because of its shape when you draw it. One question sits at the top. Its two answers lead to two more questions, each of those to two more, and the thing spreads out downwards like a family tree. Each question is a node. A place where the questions stop and an answer is given is a leaf.

To use the tree on a new dot you start at the top, answer each question with the dot's own numbers, and follow that branch until you reach a leaf. The leaf's answer is the prediction. That is the whole of it, and it is why a tree can be explained to somebody who does not want to hear about weights.

Pick two dots at random from a group and ask whether their labels differ. If the group is all circles, they never differ, so the chance is 0. If it is half circles and half squares, the chance is one half. If it is nine circles to one square, they differ rarely, so the chance is low again. That single number captures how mixed a group is, and a tree tries to make it small on both sides of every cut.

The same idea is used with a different bit of arithmetic under the name entropy, and the two mostly agree about which cut is best. Whichever you use, the point is that "this cut looks tidier" has been turned into a number a machine can compare, which is the same move that made Step 1 possible.

Because every question the tree is allowed to ask is about one measurement on its own: is across less than 3.4, is up less than 7.1. A question like that draws one straight line parallel to an edge of the grid, so every region it can produce is a box with corners at right angles.

That is a real limit. A boundary running diagonally has to be approximated by a staircase of boxes, and the tree needs many questions to build one. The straight boundary from Step 4 draws that diagonal with three weights. Neither shape of model is better; they are bad at different things, which is the reason for having more than one.

Barely. The name comes from a 1940s guess about brain cells: something adds up its incoming signals and fires if the total is large enough. That much is a fair sketch of a real neuron and it inspired the arithmetic. The resemblance stops there. A real brain cell is a living thing with chemistry and timing and structure, and nothing in this widget has any of it.

Take the word as a label for a small piece of arithmetic, the way a computer's memory is not the kind you have. Reading more into the name is where most of the overclaiming about these systems starts.

Because without it a stack of neurons collapses. Feed the output of one weighted sum into another weighted sum and the result is still a weighted sum of the original inputs, so a hundred layers would have exactly the power of one. Something that is not a straight multiply has to happen in between, and squashing is the cheapest thing that qualifies.

Squashing also makes each neuron behave like a soft decision rather than a dial. Well away from its line the output sits near 0 or near 1 and stops responding, which is what lets one neuron in a layer specialise in one region and ignore everything else. That specialising is what you can watch happen in the next lab.

It is the same machinery, at a size you can watch. One layer of four neurons is shallow. Stack ten or a hundred layers and each one gets to build features out of the features the layer below invented, which is where the word deep comes from. The arithmetic in each neuron does not change at all.

Two things do change with size. The slopes are worked out by a bookkeeping trick rather than by nudging every weight one at a time, because a network with a billion weights would need two billion measurements per round. And the inputs stop being two numbers on a grid and become the brightness of every point in a picture, or one number per word. Safe to skip: nothing later needs it.

In Step 9, bias was the plain number a neuron adds before squashing. It carries no opinion about anything. That is the technical sense, and it is unfortunate.

In this step, bias means systematic unfairness towards a group of people. Same word, unrelated meaning, and both are standard. When you read about a model's bias you have to work out from context which one is meant, and people sometimes get that wrong in public.

A feature that stands in for something you did not measure, or did not want to use. If applicants from one area mostly belong to one group, then the area column carries group information whether you wanted it to or not. Postcode, school, name, the hour someone submits a form: all of these have served as proxies in real systems.

This is why deleting the sensitive column is weaker than it sounds. The model is searching for anything that predicts the label, and a proxy predicts the label for exactly the reason you were worried about. The next lab does the deletion and then measures what is left.

Several things, none of them a cure. Measure outcomes for each group and publish them, which at least makes the gap visible. Rebalance or reweight the training data so the model is not rewarded for copying the gap. Predict something less tainted where you can: whether somebody did the job well, rather than whether somebody was hired. Keep a person in the loop for decisions that matter, with the model's reasoning shown.

And several definitions of fairness exist that cannot all hold at once, which is a proved result and not a shortage of effort. So part of the work is choosing which one you mean, in public, before you build. Safe to skip: no later step depends on this.

Accuracy is the number it got right divided by the number it was asked. That treats every mistake as equally bad, which is almost never true. Telling a healthy person they are ill costs them a worrying week. Telling an ill person they are healthy can cost them far more than that.

Accuracy also gets easier as the thing you are looking for gets rarer, which is backwards. When only one in a hundred cases is the interesting one, ignoring the problem entirely scores 99 percent. Any time you see a high accuracy on a rare event, the first question is what the always-say-no model would have scored.

Imagine fishing with a net. Precision asks: of everything you pulled up, how much was fish and not old boots. Recall asks: of all the fish in the lake, how many did you get. A tiny net in one perfect spot has high precision and terrible recall. Dragging the whole lake has perfect recall and dreadful precision.

You cannot have both at once, and the threshold slider is where you choose. Screening for a treatable illness wants recall, because a missed case is the expensive one. A system that deletes suspected junk mail wants precision, because deleting a real letter is the expensive one. The arithmetic will not choose for you.

The model hands back a number between 0 and 1. Turning that into an action needs a line in the sand: flag anybody above this number. One half looks natural because it is the middle, and that is the only thing recommending it. Nothing about the arithmetic makes it the right place to stand.

The right place depends on the two costs. If missing an ill person is a hundred times worse than alarming a healthy one, the line belongs far below one half, and the slider shows exactly what that trade buys and what it costs. Choosing it deliberately, and writing down why, is a decision people often forget they are making.

Start with data you generate, because you will understand it. Your own step count or sleep hours by day. Match results for a team you follow. How long your walk to school takes against the weather. Twenty rows recorded by hand in a spreadsheet is enough to fit a line and to hold six rows back.

After that, public collections. Governments publish weather, transport and census figures. Sports and chess sites publish results. Several sites host thousands of small tables specifically for practice. The first honest question about any of them is who measured this and what did they leave out, and it is worth more than any model choice.

Rolling downhill is gradient descent, and one full pass over the training data is an epoch. A setting you choose rather than fit, like the learning rate or the number of wiggles, is a hyperparameter. The do-nothing model is a baseline. Doing well on data you have never seen is generalisation, and failing at it because you memorised is overfitting.

Predicting a quantity is regression; predicting a label is classification. The squashing rule from Step 4 is called the logistic, or sigmoid, curve, and that whole model is logistic regression. None of these are new ideas. They are the names for what you have already made work, and knowing them is what lets you read anything else on the subject.

Not by the loss, which has no natural scale, and not by comparison with the best model in the world. By comparison with two things: what the do-nothing answer scores, and what the decision actually needs. A weather model that beats "same as yesterday" is doing something. One that does not is a waste of electricity however impressive its inner workings.

Then ask what a mistake costs, and whether the model's mistakes are the affordable kind. A model with lower accuracy that fails safely often beats a sharper one that fails in the expensive direction.

A foundation model begins with a large model trained on broad data, then adapts it to a narrower task by prompting it, retrieving relevant examples, training a small adapter, or changing more of its weights. This saves work when a useful representation has already been learned, but it does not remove the rules in this course.

You still need a baseline, separate training and evaluation data, a metric tied to the decision, and tests for important groups and conditions. The later courses on Making Training Work, Language Models, and Computer Vision apply those rules to current pretrained models.

“Estimate tomorrow’s bus delay in minutes at 07:00, using only information available by 06:55; beat the same-as-yesterday baseline on held-out school days; report larger errors during snow separately.” This states the target, time boundary, baseline, test data and important condition.

A blank value may mean a sensor failed, a question was skipped, or the value was below a detection limit. Replacing every blank with zero merges different events. Add a missingness indicator when the reason matters, and test whether missingness differs across groups or time.

Split and resample at the independent unit: by person, patient, machine, location or time block. Treating 1,000 frames from one video as 1,000 independent cases makes the interval falsely narrow. The Training and Evaluation course develops grouped splits and uncertainty further.

Spatial indexes can prune exact searches in low dimensions. In high-dimensional embedding spaces, approximate-nearest-neighbour indexes trade a little recall for speed and memory. Measure index recall, latency and downstream task quality separately.

Density-based methods can find irregular shapes and mark sparse points as noise. Hierarchical clustering builds nested groups. Each method encodes a different meaning of “together,” so select it from the data geometry and use, not from a colourful plot.

The covariance matrix records which centred features vary together. Its eigenvectors give principal directions; singular value decomposition obtains the same geometry more robustly from the data matrix. Linear Algebra builds both ideas.

Lasso can set some weights to zero. Trees can limit depth or leaf size. Neural networks use weight decay, data augmentation, dropout and early stopping. Each changes the training process differently; validation measures whether the change improves the target population.

Platt scaling and isotonic regression fit a calibration map on held-out predictions. Temperature scaling is common for neural classifiers. Fit the map without using the final test set, and recheck it after population or model changes.

Choosing features after looking at test performance, fitting normalization on all rows, or retrieving documents that contain the reference answer all spend test information. Put the entire learned pipeline inside the training fold and audit data lineage.

A model changes which cases receive attention, so later labels are observed under its own policy. Credit, policing, recommendations and predictive maintenance all have this problem. Record the action policy and preserve suitable exploration or comparison groups where safe.

A shadow model receives live inputs but does not control outcomes, which reveals latency and prediction differences. A canary serves a small representative cohort with rollback ready. Neither replaces a controlled comparison when the new policy changes which labels become visible.

Multimodal models can accept several media, smaller models can run on devices, and inference-time search can spend more computation on hard tasks. Parameter-efficient adapters and synthetic data reduce some collection costs. None removes held-out evaluation, provenance, privacy, latency, cost or failure containment.

Large pretrained models can represent observations, propose plans or supply a policy starting point. Preference feedback can shape behaviour. The same concerns remain: coverage of states, reward misspecification, off-policy evaluation, distribution shift and a deterministic boundary around dangerous actions.