Machine Learning

It flipped the direction rules get written in

Old-style programs had a person write the rule first, and the machine just followed it: if the input looks like this, the output should look like that. That approach is still the best one, even today, for jobs where the rule is clear. There's no reason to bring machine learning into a calculator.

The trouble is there are far more jobs where the rule can't be written down at all. Try to write out a rule for recognizing a handwritten digit and you get stuck on the first line. Everyone writes a 3 a little differently, and there's no way to put that difference into words.

Machine learning flips the arrow. What a person hands over isn't a rule — it's examples. Give it tens of thousands of handwritten 3s along with a mark saying "this is a 3," and the machine finds what they have in common and builds the rule itself. A person only says what they want; the machine fills in how.

Training passes through, and a model is what's left

Machine learning splits into two broad stretches of time. The first is training. Looking at examples one by one, it nudges the countless dials inside itself a little each time — turning the dial by exactly however much the answer missed, over and over, millions of times. In the coffee analogy, that's the time spent brewing it a little differently each day.

Once that stretch ends, the dials settle into some final state. That settled state, saved whole, is the model. Training takes a long time and costs a lot, but it only has to happen once; using the finished model afterward is fast and can be done as many times as you like. It's like how figuring out the coffee rule took twenty cups, but once it's found, brewing it the same way every morning is all there is to it.

That's why training and model always show up together in machine learning talk. Training points to the process; model points to what that process leaves behind.

The quality of the examples decides the result

Machine learning only finds a rule inside the examples it was shown. So if the examples lean one way, the rule comes out leaning the exact same way. A model taught only on daytime photos wobbles in front of nighttime ones — the same way a coffee rule dialed in for one household's beans doesn't carry over to a different shop's beans.

It's the same if the answer attached to an example is wrong. The machine doesn't question that mark — it learns it exactly as given. That's why, in practice, far more time goes into gathering and cleaning up examples than into fixing the model itself.

What's memorized and what's learned are different things

Memorize the examples outright and a test goes well, since it's just being asked about things it's already seen. But run into something new and it falls apart. In machine learning, this state is called overfitting.

That's why the examples used for training get set apart from the examples used for checking. Testing on examples it was never shown even once during training is the only way to know whether it actually found a rule. This ability to hold up on something new is called generalization, and it's always what machine learning is really chasing.

There are several ways to learn, too

Giving it the answer alongside the example is the most common approach. Pair a photo with what it is, and the machine learns the relationship. This is called supervised learning.

There's also a way that gives only examples, with no answer attached. Let similar things clump together on their own and things like customer groups or clusters of writing surface naturally. This is unsupervised learning. And there's reinforcement learning too, where it gets a higher score for doing well and a lower one for doing poorly, and works out its own approach from that — something close to dialing in coffee flavor by score alone.