What Artificial Intelligence Actually Is

Artificial intelligence is a label attached to a very wide range of things, and the first useful thing this course can do is take it apart. A thermostat is not intelligent. A chess program that beats you is doing something you would call thinking if a person did it. A system that writes an essay is doing something different again. All three have been called AI at some point.

Three systems, three completely different mechanisms

Rather than argue about definitions, it is more useful to see the three families of approach side by side, because they fail in different ways and suit different problems.

One: rules a person wrote down

Somebody works out the logic and encodes it. The system is exactly as good as the person who wrote it, it can explain every decision, and it knows nothing that was not written into it.

Every decision there is traceable to a line you can point at. That is a real advantage and it is why rules still run anything with a regulator attached. The limit is equally real: nobody can write down the rules for recognising a cat in a photograph.

Two: searching through possibilities

The computer is not told the answer, it is told the rules of the game and how to recognise a solution, and then it looks. This is how route planners and puzzle solvers work, and it is how chess programs beat people long before machine learning was involved.

Nobody gave that program any examples. It was given the map and a way to tell when it had arrived, and it worked the rest out. When a problem genuinely has that shape, search is often better than learning: it is exact, it needs no training data, and it can prove there is no shorter route.

Three: learning the rules from examples

Nobody writes the logic. You supply examples of the answer and the system works out for itself what distinguishes them. This is machine learning, it is what almost everyone means by AI today, and days 2 to 7 are about it.

The clearest way to feel the difference between writing rules and learning them is to do both on the same problem and compare. The problem is a support inbox of short messages, half of them unwanted.

The rules a sensible person would write

Ten sensible keywords, and on mail phrased in ways they were not written for they catch a fifth of the spam and score 0.492 overall, which is worse than tossing a coin. Read the messages they let through: every one is obviously unwanted to a human and contains none of the ten words.

This is not a contrived defeat. It is the actual dynamic of the problem, because whoever is sending the spam can read the filter too, and the phrasings that survive are exactly the ones that avoid the list. Each miss is an argument for adding another keyword, and that argument never ends. The rules also block ordinary mail: one of the held out messages is somebody saying they won an argument about a deadline.

The same problem, learned

0.883 against 0.492, on wording neither system has seen. Nobody told the model that claim or congratulations matter. It was shown the training messages and worked out for itself which words carry signal and how much, which is a far more forgiving thing to carry into unfamiliar phrasing than a list of ten words that either appear or do not.

Note also what the model did not do. It scored 0.883, not 1.000. Unfamiliar wording costs it too, and a system that is honest about this is worth more than one that is only ever tested on mail like the mail it learned from.

And look at the last column, which is the one people skip. Both systems wrongly flag ordinary mail at exactly the same rate, 0.217. The model's entire advantage is in the middle column: it catches almost all of the spam where the rules catch a fifth, at no extra cost in blocked invoices. That is a much more precise claim than the model is better, and it is the kind of claim worth learning to make.

What the model decided was important

That table is worth pausing on, because it shows the mechanism is not magic. The model learned a weight per word and adds them up. Some of those words you would have guessed. Others are there because of how this particular inbox is written, which is exactly the knowledge a person writing rules would have had to acquire by reading all two hundred messages.

Yesterday's model was four lines. Underneath those four lines is a structure that every supervised learning system shares, and naming its parts makes the rest of the course much easier to follow.

The five parts

1. Examples. Things you have seen before. Here, messages.
2. Labels. The answer for each example. Here, spam or not. Somebody had to provide these, and that cost is usually the real constraint on a project.
3. Features. The numbers the model actually sees. A message is text; the model needs numbers, so something has to turn one into the other.
4. A model. A function with adjustable settings, mapping features to a prediction.
5. A loss and a way to reduce it. A number saying how wrong the predictions are, and a procedure that adjusts the settings to make it smaller.

Features, made visible

The step that surprises people most is the third one, so here it is explicitly. This is what the model receives instead of a sentence.

The sentence has become a row of counts, one column per word in the vocabulary. Word order is gone entirely, which is why this representation is called a bag of words. It is crude, and it is enough to have beaten the rules yesterday.

Watching the loss come down

The last part is the training loop. Most libraries hide it, so here it is running in the open on the same data, with the error printed every few passes.

That is the whole of learning, in eight lines. Make a prediction, measure how wrong it is, nudge every setting in the direction that makes it less wrong, repeat. Every model in this course and every model in the news does a version of this, differing in the shape of the function and the size of the numbers rather than in the idea.

A model that scores well on the data it learned from has demonstrated nothing. It could have memorised. The entire question is whether it works on examples it has never seen, and that question has a name.

Memorising, demonstrated

Here is a model deliberately given enough freedom to memorise, scored both ways.

Both models score a perfect 1.000 on the messages they were built from, and that column tells you nothing whatsoever. The right hand column is where they separate: 0.733 for the tree against 0.883 for logistic regression.

Same data, same features, same perfect training score, and one of them carries fifteen points more of it across to unfamiliar wording. The tree memorised harder, in the sense that more of what it learned was specific to the exact messages in front of it. The gap between those two columns is the thing to watch for the rest of your career, and it is invisible if you only ever look at the left one.

The baseline nobody runs

Before celebrating any accuracy, you need to know what a system that does nothing clever would score. Otherwise the number has no meaning at all.

Almost every applied AI problem is one of a small number of shapes. Recognising which shape you have tells you what kind of data you need, what model to reach for, and how to measure success, so it is worth learning the list properly.

The shapes

The same library, three different shapes

Three problems, three shapes, one library, and in each case a do-nothing comparison next to the result. Notice that the clustering line has no accuracy at all, because no labels were used, and that is the honest situation rather than an omission.

Day 1 said that reaching for machine learning where rules would do is a common and expensive mistake. This day is the practical version of that claim.

When rules are the better answer

• The logic is known and stable. Tax rates, opening hours, eligibility thresholds. Learning them from examples is slower, less accurate and impossible to audit.
• You have no labelled examples, and getting them would cost more than writing the logic.
• Every decision must be explainable to a regulator in terms of the rule that produced it.
• The cost of a wrong answer is severe and the volume is low enough for a person to review.

When learning is the better answer

• The pattern is real but nobody can articulate it. Recognising speech, reading handwriting, judging whether a photograph contains a pedestrian.
• The rules would be enormous. Ten thousand keyword rules for spam is not a system anybody can maintain.
• The pattern changes and you can keep collecting examples, so the system can be retrained rather than rewritten.
• You have, or can get, labelled examples in reasonable numbers.

The questions worth asking before anything is built

1. What decision changes as a result? If nothing is done differently, the model has no value however accurate it is.
2. What does a wrong answer cost, and which kind of wrong? Missing spam and blocking an invoice are not equally bad, and no single accuracy number distinguishes them.
3. What would a simple rule achieve? Build it. It is a day's work and it is the number your model has to beat.
4. Do the labels exist? If not, who makes them, how long does it take, and do they agree with each other?
5. Will the data still look like this in a year? A model is a snapshot of the past, and week 13 covers what happens when the world moves.

Everything from the week, applied once, in the order it should be done in.

The four counts at the bottom matter more than the accuracy above them. Blocking somebody's invoice and letting a junk message through are both errors and they are not equally bad, and no single percentage can tell you which the system is doing. Week 2 develops this properly.

What the week established

• AI covers rules, search and learning, and they are suited to different problems rather than being stages of sophistication.
• A learned model is examples, labels, features, a function and a loss being reduced. Nothing more mysterious than that.
• Every number must be measured on data the system has not seen.
• Every number needs a do-nothing baseline beside it before it means anything.
• The shape of the problem, and whether it needs learning at all, are decisions made before any code is written.

Where the course goes next

Week 2 goes deeper into how machines learn and how to measure them honestly. Week 3 covers the search and knowledge methods that predate learning and still run a great deal of production software. Weeks 4 to 7 are language, weeks 8 to 10 are images, and weeks 11 to 13 are about the consequences of deploying any of it, which is the part that turns a working model into something you can defend.