How machine learning learns: supervised vs unsupervised

Machine learning (ML) is a way to get a computer to find a pattern in examples instead of writing the rules by hand. You show it many examples and it adjusts itself until it predicts well. This lesson explains what "learning" actually means, the two main families (supervised and unsupervised), and the vocabulary you will see in every ML course.

Suppose you want to predict how many cups Brew & Bean will sell tomorrow. With traditional programming you write the rules: "if the temperature is above 30, add 40 cups". You must discover the numbers yourself and update them when things change.

With machine learning you give the computer past days (temperature, weekend, promotion) and the cups actually sold. It finds the numbers. When new data arrives you retrain, instead of rewriting rules.

By convention, features are written X (a table, capital letter) and the label y (a single column, lower case).

Learning means reducing error. The model starts with a guess, measures how wrong it is on the training examples with a loss (a single number for the total error), changes its parameters to reduce the loss, and repeats. Here is the idea in its most basic form: try many candidate formulas cups = w * temperature + b and keep the one with the smallest error.

import numpy as np

temps = np.array([18, 22, 25, 28, 31, 34])        # feature
cups  = np.array([55, 80, 95, 115, 135, 150])     # label

best = None
for w in np.arange(0, 6.01, 0.5):        # candidate slopes
    for b in range(-60, 61, 10):         # candidate starting levels
        pred = w * temps + b
        error = np.mean((cups - pred) ** 2)    # mean squared error
        if best is None or error < best[0]:
            best = (error, w, b)

print("smallest error, w, b =", best)

On this tiny grid the best pair is w = 5.5 and b = -40 with a mean squared error of about 8.9. Real models do not try every combination; they use smarter methods such as calculus-based gradient descent, which you will meet in the neural networks lesson.

from sklearn.linear_model import LinearRegression

model = LinearRegression()
model.fit(temps.reshape(-1, 1), cups)      # training: scikit-learn wants a 2D table for X
print("slope:", model.coef_, "intercept:", model.intercept_)
print("prediction for 30 C:", model.predict([[30]]))

scikit-learn finds slope 6.0 and intercept -53.0 (a lower error than our coarse grid) and predicts about 127 cups at 30 degrees. Every scikit-learn model follows this same pattern: create it, fit, then predict.

In supervised learning every training example comes with the right answer (the label). The model learns to map features to labels, like a student practising with an answer key. There are two kinds.

from sklearn.neighbors import KNeighborsClassifier

# features: [orders last month, average bill in Rs]
X = np.array([[1, 150], [2, 180], [1, 160], [12, 200], [15, 220], [10, 190]])
y = np.array(["occasional"] * 3 + ["regular"] * 3)

clf = KNeighborsClassifier(n_neighbors=3).fit(X, y)
print(clf.predict([[2, 170], [11, 210]]))

k-nearest neighbours labels a new customer by looking at the 3 most similar customers. The output is ['occasional' 'regular'].

In unsupervised learning there are no labels. The model looks for structure by itself, for example groups of similar customers (clustering) or a simpler description of many columns (dimensionality reduction). Nobody tells it what the groups mean: you inspect them afterwards and name them.

from sklearn.cluster import KMeans

# points described by two features; no labels given
points = np.array([[1, 1], [1.5, 2], [1, 0.5],
                   [8, 8], [9, 9], [8.5, 7.5],
                   [1, 9], [2, 8.5], [1.5, 9.5]])

km = KMeans(n_clusters=3, n_init=10, random_state=0).fit(points)
print(km.labels_)

The output has three groups of three points each, such as [1 1 1 0 0 0 2 2 2]. The numbers themselves (0, 1, 2) are arbitrary names. Choosing the number of clusters is your decision. See *Clustering and dimensionality reduction* later in this track.

A model can score perfectly on its training data and fail on new data because it memorised noise. This is overfitting. A student who memorises last year's answers will fail a new paper. That is why we always keep some data aside to test, which is the subject of *Train, validation, test and overfitting*.

I want to solve this problem: [describe it in 2 to 3 sentences].

Data I have: [list columns, number of rows, whether I have the correct answers].

Tell me: (1) is this supervised, unsupervised or neither, (2) regression, classification or clustering, (3) what the features and the label would be, (4) a simple baseline to beat, and (5) one risk in my data. Use plain English and no more than 150 words.

What to expect: Good answers name the label explicitly and warn about a risk such as too few rows or data leakage. If the answer does not mention a baseline, ask for one.

Expect "What is the difference between supervised and unsupervised learning?", "Give an example of each", "What is overfitting?" and "What are features and labels?". Use a concrete example (predict price versus group customers) and mention that supervised learning needs labelled data, which is often the expensive part.