What machine learning is

Rules in, or rules out

Think about how a child learns what a dog is. Nobody hands them a rulebook: "four legs, fur, a tail." That rulebook would fail anyway, because cats have all of those too. Instead, people point and say "dog" or "not a dog," over and over. The child works out the pattern alone.

Computers can work either way.

In ordinary programming, you write the rules. Say you run an online shop. You might write: "if a customer hasn't ordered in 90 days, flag them as at risk of leaving." Customer data goes in, and answers come out. A customer who stops buying has churned, and the loss of customers is called churn.

In machine learning, you don't write the rule. You give the computer past examples together with the answers. Here that means past customers, and whether each one churned. The computer finds the rule itself:

Traditional programming:   rules + data      →  answers
Machine learning:          data + answers    →  rules (a model)

The rule it finds is called a model. A model is a function with some adjustable numbers inside it. Those numbers are its parameters. Think of them as dials, like the dial on an oven. Training means turning the dials until the model's answers match the known answers as closely as possible. Then you use the model on new customers, whose answers you don't know yet.

In plain words: ordinary programming turns rules into answers. Machine learning turns examples with answers into rules.

Learning is searching

Here is learning in its simplest form. Why 90 days? Someone guessed. Instead of guessing, you can try lots of cutoffs. Check each one against past customers and count how often it's right. Then keep the cutoff that scores best.

To score a cutoff you need its accuracy: the share of predictions that turned out right.

accuracy = correct predictions ÷ all predictions

Say a cutoff gets 5 of 6 customers right. Its accuracy is 5 ÷ 6, about 0.83, or 83%.

In plain words: accuracy is your hit rate. Count the right answers and divide by the number of guesses.

The code below loads 600 past customers from the course's practice API. It scores the 90-day rule. Then it tries 78 cutoffs, from 10 days up to 395 days in steps of 5, and keeps the best one:

import numpy as np
import requests

customers = requests.get("https://api.gradient.test/v1/customers").json()["data"]
days = np.array([c["days_since_last_order"] for c in customers])
churned = np.array([c["churned"] for c in customers])

def accuracy(cutoff):
    predicted = days > cutoff              # predict churn if the gap is longer than the cutoff
    return np.mean(predicted == churned)

print("hand-picked rule (90 days):", round(accuracy(90), 3))
cutoffs = np.arange(10, 400, 5)
scores = [accuracy(c) for c in cutoffs]
best = cutoffs[int(np.argmax(scores))]
print("learned cutoff:", best, "accuracy:", round(max(scores), 3))
print("always predict 'stays':", round(np.mean(churned == 0), 3))

Here is what the main lines do:

• days > cutoff gives True or False for each customer. True means "we predict this one churns."
• predicted == churned checks each prediction against what really happened. Python counts True as 1 and False as 0, so they compare cleanly.
• np.mean of a list of True and False values gives the share that are True. That's the accuracy.
• np.argmax(scores) gives the position of the highest score. So best is the winning cutoff.

The hand-picked 90-day rule is right 73.2% of the time. The search finds a cutoff of 295 days, which is right 82.5% of the time. That's a model with one parameter, trained by trying candidates. Real models have many parameters. They use gradient descent (Phase 2) instead of trying everything. But the idea is the same: adjust the parameters to make fewer mistakes on known examples.

Now look at the last line. Predict "stays" for every customer, with no model at all, and you're right 80.7% of the time. That's because most customers stay. This do-nothing score is a baseline. The 90-day rule actually does worse than doing nothing. The learned cutoff beats the baseline by less than 2 points. That's far less impressive than "82.5% accurate" sounds. You'll learn better ways to measure this in the evaluation lessons.

Watch out: before you praise a model's accuracy, ask what the baseline scores.

days    = [10, 25, 40, 70, 105, 130]
churned = [0,  0,  0,  1,  0,   1]

for cutoff in [30, 60, 100]:
    right = 0
    for d, c in zip(days, churned):
        guess = 1 if d > cutoff else 0
        if guess == c:
            right += 1
    print(cutoff, right, "of", len(days))

print("always 'stays':", churned.count(0), "of", len(days))

import numpy as np
days = np.array([10, 60, 90, 30])
churned = np.array([0, 1, 0, 0])
print(np.mean((days > 50) == churned))

Kinds of learning

Machine learning comes in four main kinds. They differ in what the computer gets to learn from.

• Supervised learning is like studying with flashcards that have the answer on the back. Each example comes with the right answer, called a label. "This customer churned" is a label.
• Unsupervised learning is like sorting a big box of mixed buttons with no instructions. There are no labels. The computer looks for groups and patterns on its own.
• Self-supervised learning is like covering the next word of a sentence and guessing it. The answer is hidden in the data itself, so nobody has to write labels.
• Reinforcement learning is like training a dog with treats. The learner tries actions and gets rewards for good ones. It learns by trial and error.

Large language models use several kinds. During pretraining they're self-supervised. In any web text, the next token is a free label. After that, they're fine-tuned with supervised examples and with reinforcement learning from feedback. This phase covers supervised and unsupervised learning, the base that all the rest builds on.

When machine learning is worth it

Machine learning isn't always the right tool. Use it when:

• the pattern is too complex or fuzzy to write down (what makes a lead likely to buy?),
• you have plenty of examples with known outcomes,
• some mistakes are acceptable, and
• the pattern changes over time, so you'll want to relearn it from new data.

Use a plain rule when a simple rule works well, or when you have little data. Also use a rule when you need a decision you can fully explain and guarantee. "Never email unsubscribed customers" is a rule, not a prediction. A model that's right 99% of the time would still be wrong 1% of the time. Here, even one wrong email breaks a promise.

The workflow

Real machine learning projects follow roughly the same six steps:

1. Frame the question and the metric    which customers will churn next quarter? judged how?
2. Gather data with known outcomes      past customers and what happened to them
3. Prepare features                      clean, encode, scale (the next lessons)
4. Train on part of the data             fit the model's parameters
5. Evaluate on data it hasn't seen       the honest number
6. Deploy and monitor                    predictions drift as customers change

A few words here may be new. Features are the inputs a model learns from, such as days since the last order. A metric is the score you'll judge the model by, such as accuracy. To deploy a model is to put it to work on real customers. To monitor it is to keep checking it, because customers change and old patterns fade.

Steps 4 and 5 use different customers on purpose. Testing a model on examples it trained on is like grading students on the exact questions they practiced. They'll look better than they are.

Most of the effort in practice goes into steps 1 to 3 and step 5, not the model itself.