Loss functions

The regression losses#

Written for a batch of n examples, with prediction p_i and target y_i, and e_i = p_i - y_i.

MSE   =  (1/n) Σ e_i²                       gradient wrt p_i:  2 e_i / n
MAE   =  (1/n) Σ |e_i|                      gradient wrt p_i:  sign(e_i) / n
Huber =  (1/n) Σ  0.5 e_i²                  if |e_i| ≤ δ
                  δ(|e_i| − 0.5 δ)          otherwise

n is the batch size. δ is the crossover threshold, in the same units as the target. sign(e) is +1, -1 or 0.

The estimator each loss implies is the useful way to remember them. Minimising MSE over a constant predictor returns the mean of the targets. Minimising MAE returns the median. Minimising the pinball loss at quantile τ returns the τ-quantile, which is what quantile regression uses to produce prediction intervals.

Huber's gradient is bounded by δ/n, which is what makes it robust: a single corrupted target can move the parameters by a bounded amount, whereas under MSE its influence is unbounded. Huber (1964), Robust estimation of a location parameter, is the original.

Losses are negative log-likelihoods#

Almost every standard loss is −log p(y | x, θ) under some assumed noise model. This is not a coincidence and it is the fastest way to derive a loss for a new problem.

Gaussian noise, fixed variance     →  −log p ∝ (p − y)²          →  MSE
Laplace noise                      →  −log p ∝ |p − y|           →  MAE
Bernoulli outcome                  →  −log p = BCE
Categorical outcome                →  −log p = cross-entropy
Poisson counts                     →  −log p = p − y log p       →  Poisson NLL

The practical payoff: if your targets are counts, MSE assumes Gaussian noise on counts, which is wrong at low rates. Use the Poisson loss and the model becomes better calibrated at the small values that dominate count data.

Cross-entropy and the softmax gradient#

For K classes with logits z ∈ R^K and a one-hot target y:

softmax:  q_k = exp(z_k) / Σ_j exp(z_j)
loss:     L   = − Σ_k y_k log q_k
gradient: ∂L/∂z_k = q_k − y_k

z_k is the raw score for class k, q_k the predicted probability, y_k the one-hot target. The gradient is the entire reason this pairing is standard: it is prediction − truth, one subtraction, with no derivative of the squashing function left in it.

Contrast with MSE on a sigmoid output. There the gradient carries a factor σ'(z) = σ(z)(1 − σ(z)), which approaches zero as |z| grows. A confidently wrong prediction therefore produces a vanishing gradient and the model stalls exactly where correction is most needed.

Numerically, never compute log(softmax(z)) directly. Use the log-sum-exp identity with the max subtracted:

log q_k = z_k − m − log Σ_j exp(z_j − m),     m = max_j z_j

m cancels algebraically and bounds every exponent at zero, so nothing overflows. F.cross_entropy and BCEWithLogitsLoss implement this fused form; a hand-written softmax followed by a log does not.

Cross-entropy, entropy and KL#

H(y, q) = H(y) + D_KL(y ‖ q)

H(y) is the entropy of the target distribution and D_KL the Kullback–Leibler divergence. With hard one-hot targets H(y) = 0, so minimising cross-entropy is exactly minimising KL divergence to the label. With soft targets — label smoothing, or a teacher model in knowledge distillation — H(y) is a non-zero constant with respect to θ, so the two objectives still share a gradient but no longer share a value.

Imbalance and hard-example weighting#

Class weighting multiplies each class's term by w_c, typically w_c ∝ 1/n_c or its square root. This changes the implied prior; the model's output probabilities are no longer calibrated to the training distribution, and thresholds must be re-tuned on a validation set.

Focal loss (Lin et al., 2017) down-weights examples the model already gets right:

FL = − α_t (1 − q_t)^γ log q_t

q_t is the predicted probability of the true class, γ ≥ 0 the focusing parameter (2.0 is the paper's default), α_t an optional per-class weight. At γ = 0 it reduces to weighted cross-entropy. Designed for dense object detection where background boxes outnumber objects by roughly 1000:1.

Label smoothing (Szegedy et al., 2016) replaces the one-hot target with (1 − ε) y + ε/K. It reliably improves top-1 accuracy and reduces overconfidence. Müller et al. (2019), When does label smoothing help?, show it also collapses within-class logit spread, which measurably degrades knowledge distillation from a smoothed teacher.

Proper scoring rules and calibration#

A scoring rule is proper when the expected score is optimised by reporting the true probability. Log loss and Brier score are proper; accuracy and F1 are not, which is why optimising them directly encourages degenerate thresholding rather than honest probability estimates.

Minimising a proper scoring rule does not by itself deliver calibration in practice. Guo et al. (2017), On calibration of modern neural networks, document that deep networks trained to convergence on cross-entropy are systematically overconfident, and that temperature scaling — a single scalar divisor on the logits, fit on a validation set — removes most of the miscalibration at no cost to accuracy.

The surrogate gap#

Training minimises a differentiable surrogate; deployment cares about a non-differentiable objective. The gap is a modelling assumption, not an implementation detail, and it is where most production disappointment originates.

Three concrete mismatches worth naming:

• Metric mismatch. Cross-entropy optimises average log-likelihood; the product cares about recall at a fixed false-positive rate. These have different optima.
• Distribution mismatch. The loss is averaged over the training distribution, and deployment draws from another one.
• Cost mismatch. Errors have asymmetric real-world costs that a symmetric loss never encodes. Encoding them explicitly, through class weights or a cost matrix, is nearly always better than discovering them in production.

Papers#

• Huber, Robust Estimation of a Location Parameter, Annals of Mathematical Statistics, 1964.
• Szegedy et al., Rethinking the Inception Architecture for Computer Vision, 2015 — label smoothing — arxiv.org/abs/1512.00567
• Guo et al., On Calibration of Modern Neural Networks, 2017 — arxiv.org/abs/1706.04599
• Lin et al., Focal Loss for Dense Object Detection, 2017 — arxiv.org/abs/1708.02002
• Müller, Kornblith and Hinton, When Does Label Smoothing Help?, 2019 — arxiv.org/abs/1906.02629
• Gneiting and Raftery, Strictly Proper Scoring Rules, Prediction, and Estimation, JASA, 2007.

What to learn next#

• Gradient descent — what the model does with the number the loss gives it.
• PyTorch basics — the built-in loss classes, in a real training loop.
• Model evaluation — the metrics you report, as opposed to the loss you train on.