Uncertainty

Problem

A model predicts that a house will sell for $612,000. Is that ±$5,000 or ±$200,000? A triage model says a scan is benign. Did it see thousands of scans like this one, or is this a scanner it has never met? A point prediction hides both questions, and the cost of an error usually depends on them: you can act on a confident prediction, but an uncertain one should go to a person, trigger more measurement, or be refused.

Calibration makes a classifier's probabilities honest on average. It does not say which inputs are unfamiliar, it does not give regression models an interval, and it is itself an estimate from a finite validation set. Uncertainty quantification fills those gaps.

Intuition

Imagine predicting tomorrow's temperature. Even a perfect forecaster cannot say it will be exactly 18.3 °C: the weather is noisy. That irreducible spread is aleatoric uncertainty (Latin alea, dice). Now imagine forecasting for a town you have no records for. The extra doubt comes from your own ignorance, and data from that town would remove it. That is epistemic uncertainty (Greek episteme, knowledge).

A practical test for epistemic uncertainty: train several reasonable models and see whether they agree. Where the training data were dense, they agree; where there were none, each fills the gap its own way and they disagree. The spread of their predictions measures what the data failed to pin down. Aleatoric uncertainty shows up instead as the noise each model expects around its own prediction.

Conformal prediction takes a different, almost accountant-like view. It does not ask why the model is wrong. It holds back some labelled data, looks at how wrong the model was on it, and widens every future prediction by the error size that covered, say, 90% of those held-back cases. If future data look like the held-back data, about 90% of future intervals will contain the truth, whatever the model is.

Mechanics

Two kinds of uncertainty

Write the model's parameters as θ and the training data as D. A Bayesian predictive distribution averages over every plausible θ (see Bayes' rule):

p(y | x, D) = ∫ p(y | x, θ) p(θ | D) dθ

If each θ gives a Gaussian with mean μ_θ(x) and variance σ²_θ(x), the law of total variance splits the predictive variance in two:

Var[y | x] = E_θ[σ²_θ(x)] + Var_θ[μ_θ(x)] = aleatoric + epistemic

The first term is the noise the models expect; the second is how much they disagree. For classification the same split uses entropy: the entropy of the averaged probabilities equals the average entropy of each model (aleatoric) plus the mutual information between the label and θ (epistemic). The exact posterior p(θ | D) is out of reach for neural networks, so the practical methods below each approximate it with a handful of samples.

Bootstrap confidence intervals

The bootstrap (Efron, 1979) estimates the sampling distribution of any statistic by resampling the data n times with replacement, recomputing the statistic on each resample, and reading off quantiles. The percentile interval takes the 2.5th and 97.5th percentiles of the resampled statistics. It answers "how precisely do I know this number?", for example a test-set metric, which matters whenever two models are compared on a few hundred examples. Each resample leaves out about 1/e ≈ 37% of the points, which is where the random forest's out-of-bag estimate comes from.

Ensembles and bagging

Deep ensembles (Lakshminarayanan, Pritzel and Blundell, 2017) train M networks (5 is common) from different random initializations, each with a mean and a variance head trained by Gaussian negative log likelihood, and combine them as a mixture with the decomposition above. They are simple, parallel, and in large comparisons are among the most reliable methods under dataset shift (Ovadia et al., 2019), at M times the training and serving cost. Bagging gets diversity from bootstrap resamples instead. scikit-learn's BaggingRegressor draws each member's rows with _generate_indices (randint(0, n, n) when bootstrap=True), and its predict returns only the mean (sum(all_y_hat) / n_estimators); to get the spread, loop over estimators_ yourself.

Monte Carlo dropout

Dropout zeroes each activation with probability p during training and scales the survivors by 1/(1 − p). nn.Dropout.forward passes self.training to F.dropout, so in eval() mode it is the identity. MC dropout (Gal and Ghahramani, 2016) leaves dropout on at test time, runs T stochastic forward passes, and treats their mean and spread as an approximate posterior predictive: each mask is one sample of a thinned network. It costs T forward passes but no retraining. The spread depends on p, which was chosen for regularization, not for calibrated uncertainty, so check it on held-out data.

Conformal prediction

Split conformal prediction (Vovk, Gammerman and Shafer, 2005; Angelopoulos and Bates, 2021) wraps any trained model:

1. Hold out n labelled calibration points the model did not train on.
2. Compute a nonconformity score on each, for regression s_i = |y_i − ŷ(x_i)|.
3. Let q̂ be the k-th smallest score with k = ⌈(n + 1)(1 − α)⌉.
4. For a new x, predict the interval [ŷ(x) − q̂, ŷ(x) + q̂].

If the calibration and test points are exchangeable (for example i.i.d.), the new score is equally likely to fall in any of the n + 1 rank positions, so

1 − α ≤ P(y_new ∈ C(x_new)) ≤ 1 − α + 1/(n + 1)

(the upper bound holds when scores have no ties). The "+1" in the rank is the finite-sample correction that makes this exact. The guarantee is marginal: averaged over all x, not for each x. A constant-width interval over-covers easy inputs and under-covers hard ones. Dividing the score by an estimated spread, s = |y − ŷ| / σ̂(x), gives intervals ±q̂·σ̂(x) that adapt to the input; conformalized quantile regression (Romano, Patterson and Candès, 2019) does the same with predicted quantiles. For classification, the set of classes whose score 1 − p̂(y | x) is at most q̂ covers the true label with the same guarantee.

Worked example

Data: x uniform on [-3.0, 1.0], y = sin(x) + Gaussian noise whose standard deviation grows linearly from 0.1 at the left edge to 0.5 at the right. There are 200 training, 200 calibration and 2000 test points, all from the same distribution. Every number comes from tested helpers in ml_models_docs.py with fixed seeds.

Implementation

Split conformal around any scikit-learn regressor, then MC dropout in PyTorch:

import numpy as np
from sklearn.ensemble import BaggingRegressor

model = BaggingRegressor(n_estimators=50, random_state=0).fit(X_train, y_train)

# ensemble spread: predict() only returns the mean
member_preds = np.stack([m.predict(X_test[:, f])
                         for m, f in zip(model.estimators_, model.estimators_features_)])
epistemic_sd = member_preds.std(axis=0)

# split conformal, alpha = 0.1
scores = np.abs(y_cal - model.predict(X_cal))
n = len(scores)
k = int(np.ceil((n + 1) * (1 - 0.1)))
q = np.sort(scores)[k - 1] if k <= n else np.inf
lower, upper = model.predict(X_test) - q, model.predict(X_test) + q

# MC dropout: dropout layers stay stochastic, everything else in eval mode
import torch
net.eval()
for m in net.modules():
    if isinstance(m, torch.nn.Dropout):
        m.train()
with torch.no_grad():
    samples = torch.stack([net(x) for _ in range(30)])   # [T, b, out]
mean, sd = samples.mean(0), samples.std(0)

Keep normalization layers in eval() while switching only the dropout modules back to training mode: putting the whole net in train() would also make BatchNorm use batch statistics. scikit-learn ships no conformal predictor; MAPIE is the usual library. For classification the analogous conformal step uses 1 - predict_proba[range(n), y_cal] as the score.

Tradeoffs

• Conformal is cheap, model-agnostic and the only method here with a finite-sample guarantee, but the guarantee is marginal and needs exchangeability: under distribution shift or in time series it breaks (weighted and adaptive variants exist). It says nothing about why an interval is wide.
• Ensembles are the strongest practical estimate of epistemic uncertainty and improve accuracy too, but cost M× in training, memory and latency. Distillation or sharing a backbone reduces the serving cost.
• MC dropout is nearly free to add to an existing model but tends to under-estimate uncertainty, especially far from the data, and its spread depends on a dropout rate chosen for other reasons.
• The bootstrap quantifies uncertainty in an estimate (a metric, a coefficient), not in individual predictions, and the percentile interval can be poor for small n or skewed statistics (BCa intervals correct this).
• Aleatoric versus epistemic is a modeling distinction: noise from a feature you did not measure looks aleatoric to this model and would become explainable with that feature.
• None of these methods reliably flags inputs that are far outside the training distribution; out-of-distribution detection is a separate problem, and shared biases (like all five cubics bending the same way) stay invisible.

Connections

References

• Efron. Bootstrap Methods: Another Look at the Jackknife. Annals of Statistics, 1979.
• Breiman. Bagging Predictors. Machine Learning, 1996.
• Lakshminarayanan, Pritzel and Blundell. Simple and Scalable Predictive Uncertainty Estimation using Deep Ensembles. NeurIPS 2017. arXiv:1612.01474
• Gal and Ghahramani. Dropout as a Bayesian Approximation: Representing Model Uncertainty in Deep Learning. ICML 2016. arXiv:1506.02142
• Kendall and Gal. What Uncertainties Do We Need in Bayesian Deep Learning for Computer Vision? NeurIPS 2017. arXiv:1703.04977
• Ovadia et al. Can You Trust Your Model's Uncertainty? Evaluating Predictive Uncertainty Under Dataset Shift. NeurIPS 2019. arXiv:1906.02530
• Vovk, Gammerman and Shafer. Algorithmic Learning in a Random World. Springer, 2005.
• Angelopoulos and Bates. A Gentle Introduction to Conformal Prediction and Distribution-Free Uncertainty Quantification. 2021. arXiv:2107.07511
• Romano, Patterson and Candès. Conformalized Quantile Regression. NeurIPS 2019. arXiv:1905.03222
• scikit-learn 1.9.1: BaggingRegressor, bootstrap indices. PyTorch v2.15.0: nn.Dropout, F.dropout.