Labels and Targets: What the Model Learns To Predict

A student can practice all day.

But if nobody ever tells her which answers were wrong, she just repeats her mistakes.

A supervised ML model is that student. It needs answer keys — known right answers — so it can compare its own output and correct itself.

So the question becomes

That answer is called the label or target.

The target is

Words people use, often interchangeably, but a common convention separates them:

• Label — the actual category value attached to one training example (e.g. "spam").
• Target — the quantity the model is trained to predict, whether a class label or a number.
• Prediction / y-hat (ŷ) — what the model outputs for a given input.

Everything else in the table (the inputs) is the features X; the target is the output column y.

The analogy to carry through: your dataset is a stack of graded exams.

• Features X = the questions.
• Target y = the official answer written on each paper.
• The model = the student answering.
• The loss = the marks deducted when ŷ ≠ y.

In scikit-learn the fit method signature is literally fit(X, y), making this input/output split explicit.

Look at two small targets from topic 28's world.

code
Copy
y_churn = [0, 1, 1, 0, 1]        <- classes: stay or churn?
y_price = [250.0, 340.0, 410.0]  <- numbers: house price in $k

• y_churn holds only two discrete values, 0 or 1. "Which class?" → a classification target.
• y_price holds any real number. "How much?" → a regression target.

That single difference — category vs number — decides everything downstream:

• which estimators are valid (a classifier vs a regressor),
• which metrics you may compute (accuracy/F1 vs MAE/RMSE),
• even what "a good prediction" means.

The data type of the target determines the task family and the metrics you may use:

• A target of discrete classes (spam / not-spam, digit 0-9) means classification.
• A continuous numeric target (price, temperature) means regression.
• Multi-class targets extend binary classification to several categories.
• Multi-output tasks predict several targets at once (e.g. price AND rent for a property).

The target type literally selects the estimator you import, as the code below shows.

# Classification target: discrete class labels
y_cls = np.array([0, 1, 1, 0, 1])       # 1 = churn, 0 = stay

# Regression target: continuous numbers
y_reg = np.array([250.0, 340.0, 410.0])  # price in $k

from sklearn.linear_model import LogisticRegression, LinearRegression
LogisticRegression().fit(X, y_cls)   # classifier
LinearRegression().fit(X, y_reg)     # regressor

One picture of how y is used during training:

code
Copy
   features X                target y (answer key)
        |                        |
        v                        |
   +---------+                   |
   |  Model  | --> prediction y-hat
   +---------+        |          |
        ^             v          v
        |          +---------------+
        |          |  loss: y-hat  |
        |          |   compared    |
        |          |   to y        |
        |          +-------+-------+
        ^                  |
        +---- correct the weights

The model sees X, guesses ŷ, and the loss compares ŷ to the true y.

• y is used only to grade, never given as an input at prediction time.
• That is why y is called the "answer key": the student trains against it, then takes the real exam without it.

Many failed ML projects predict the wrong thing.

A good target must be three things at once:

1. A faithful proxy for the business goal — not a number that looks easy but means nothing.
2. Observable in production at decision time — you must know the true value when grading new data.
3. Stable over time — the definition should not drift month to month.

Turning a fuzzy objective ("is this user valuable?") into a concrete, measurable target ("placed an order within 7 days of signup") is one of the most consequential design decisions in a project.

Real targets are rarely tidy.

• Imbalance — fraud, disease and churn datasets have very few positive labels. If only 1% of transactions are fraudulent, a model that always says "not fraud" gets 99% accuracy and catches nothing. The majority class distorts simple metrics; that problem has its own topic (Class Imbalance).
• Noise — labels can be wrong, missing or ambiguous (two human annotators disagree). That motivates techniques such as confidence weighting and careful train/test construction so metrics reflect reality.

Why AI cares:

• The loss function measures the gap between ŷ and y — so a wrong y means the model is trained against a wrong teacher.
• The task family (classification vs regression) is chosen by the target, before any algorithm.
• In LLMs and modern deep learning, targets are generated automatically: the "answer key" for a language model is literally the next token in a text stream.

Rule to remember: define the target before you choose any model.