Why is the model so confident about a wrong answer?

Scores aren't probabilities

The last layer of a classifier outputs three numbers — one per class. They are not constrained to be positive. They are not constrained to sum to anything. They are just logits : raw scores. $z = [2.0, 1.0, 0.5]$ says only that the model “leaned” toward class 0 the most. It does not say “65% chance of class 0.” That number doesn’t exist yet.

We need a function that maps three real numbers to three positive numbers summing to 1. Many such functions exist. The one we use is softmax — and the reason it’s that one, not another, is the point of the next step.

Softmax — exponentiate, then normalize

Softmax is two steps. First, raise everything to $e$: $[e^2.0, e^1.0, e^0.5] ≈ [7.39, 2.72, 1.65]$. Now they’re all positive. Second, divide by the sum so they sum to 1: $≈ [0.629, 0.231, 0.140]$. Done. Three numbers, all positive, sum to 1 — looks exactly like a probability distribution.

The exp step is not arbitrary. It guarantees positivity (any real exponent of $e$ is positive) and it makes softmax depend only on differences of logits — adding the same constant to every logit changes nothing. The downstream effect is profound: softmax doesn’t know the absolute scale of your scores. It only sees who’s ahead, by how much.

import numpy as np

# Three logits — raw scores. No truth check anywhere.
z = np.array([2.0, 1.0, 0.5])

# Numerically stable softmax: subtract max before exp.
def softmax(z, T=1.0):
    s = z / T
    s = s - s.max()
    e = np.exp(s)
    return e / e.sum()

p = softmax(z)
# p ≈ [0.659, 0.242, 0.099]   (sums to 1)
# Same logits + 100 give the same p — softmax depends only on differences.
softmax(z + 100)
# → [0.659, 0.242, 0.099]

Cross-entropy — punish the probability you gave the correct answer

Now there’s a probability vector. Suppose the truth is class 0. The number we care about is $p_0$ — what the model gave to the right answer. The training signal we want should be 0 when $p_0 = 1$ (perfect) and large when $p_0$ is small (confidently wrong). The simplest function that does this: $−\log p_0$. That’s cross-entropy . For one correct label, cross-entropy is the negative log-likelihood of that label — same number, two names from two framings (CE: truth as a distribution, one-hot here; NLL : truth as an observation).

Why log ? Because independent observations multiply their likelihoods, and log turns multiplication into addition. The total loss across a dataset becomes a clean sum: $L = Σ −\log p(y_i | x_i)$. That’s the same identity the logarithm module is built on.

# In PyTorch, log_softmax + nll_loss is the numerically stable cross-entropy.
import torch
import torch.nn.functional as F

z = torch.tensor([[2.0, 1.0, 0.5]])      # logits, batch of 1
y = torch.tensor([0])                     # true class — 'cat' at index 0

log_p = F.log_softmax(z, dim=1)           # avoids log(softmax) overflow
loss  = F.nll_loss(log_p, y)
# loss ≈ 0.417  =  −log p_true  =  −log(0.659)
#
# Why log_softmax not log(softmax)?
# log(softmax) computes exp() first → overflow when logits are large.
# log_softmax keeps things in log-space the whole way through.

Temperature — the confidence dial

Replace $softmax(z)$ with $softmax(z/T)$. Temperature T < 1 divides logits by something small, magnifying their differences — the winner pulls away. T > 1 shrinks differences, flattening the distribution. The widget shows it: drag T toward 0.1 and watch one bar reach for the ceiling. The winner doesn’t change. The wrongness doesn’t change. Only the reported confidence changes — and so the cross-entropy loss, which depends on that confidence, changes with it.

Confidence ≠ truth — the trap, made explicit

Set logits to $[5.0, 1.0, 0.5]$ — the model has decided hard for class 0. Softmax says $p ≈ [0.978, 0.018, 0.011]$: 97.8% confidence. But truth is independent of this calculation. If the real label is class 1, then $p_true = 0.018$ and the loss is $−\log 0.018 ≈ 4.0$. The model is confident _and* wrong. Lowering temperature makes it more confident, and the loss rises faster.

This is why “the model said 97% so it must be right” is a category error. Looks like a probability and matches reality are two unrelated claims. Aligning them is its own field — calibration — and it requires data the model never sees during training.

# The trap: a wrong score can produce a confident probability.
import numpy as np

z = np.array([5.0, 1.0, 0.5])        # model is sure of class 0
true_idx = 1                          # but truth is class 1
p = softmax(z)
# p ≈ [0.978, 0.018, 0.011]
# 97.8% confidence — and wrong.
loss = -np.log(p[true_idx])
# loss ≈ 4.0   (huge — log explodes as p_true → 0)
#
# Lower the temperature, and confidence rises further while truth is unchanged.
softmax(z, T=0.5)[0]                 # ≈ 0.99964   (even more sure)