Conformal Prediction for Time Series

"You handed me a black box that spits out one number and asked for honesty about it. I cannot open the box and I will not pretend to. What I can do is watch it miss, measure how badly, and draw a band so that ninety times in a hundred the truth lands inside. I do not know why the box is wrong. I only promise, with arithmetic and not with faith, how often."

A Conformal Interval That Guarantees Coverage and Means It

Sections 19.3 and 19.4 produced uncertainty from inside the model: quantile and distributional heads, deep ensembles, and Bayesian neural forecasters each gave a distribution that depended entirely on the model being well specified and well calibrated, which it usually is not. This section takes the opposite stance. We make no claim that the model's own uncertainty is trustworthy; we wrap the model from the outside and let the calibration data, not the model, certify the coverage. The two views are complementary: Section 19.4 gives a shape for the predictive distribution, and conformal prediction gives that shape a coverage guarantee it can otherwise only hope for. We carry the unified notation of Appendix A: $y_t$ the target at time $t$, $\hat{y}_t$ the point forecast, $\alpha$ the miscoverage level so $1-\alpha$ is the target coverage, and $\hat{C}_t$ the prediction interval the wrapper emits.

Why does this deserve its own section rather than a footnote on quantile regression? Because conformal prediction is the only uncertainty method in this book that hands you a coverage guarantee that does not depend on the model being right, and that property is precious in temporal AI, where models are routinely wrong about a future that does not resemble the past. The catch is that the guarantee rests on exchangeability, and exchangeability is the one assumption a time series is built to break. The interesting content of this section is the repair: how to keep a coverage promise when the data arrive in order, depend on their own past, and drift out from under the model. That repair, adaptive conformal inference, connects directly to the online and continual learning under drift of Chapter 20 via the table of contents, and it is one of the liveliest research areas in forecasting today.

The competencies this section installs are four. First, to derive and implement split (inductive) conformal prediction, including the precise finite-sample quantile that delivers its guarantee. Second, to state exactly why exchangeability fails for time series and to demonstrate the resulting undercoverage empirically. Third, to apply the temporal fixes, EnbPI, weighted conformal, and especially adaptive conformal inference and conformal PID control, and to write the ACI update from memory. Fourth, to reach for MAPIE or an equivalent library when you want the same guarantee without the bookkeeping. These skills make every forecaster in the book shippable with honest error bars.

1. The Conformal Idea: A Coverage Guarantee Around Any Forecaster Beginner

Begin with the cleanest version of the idea, the one that holds when data are exchangeable, and worry about time later. You have a trained point forecaster $\hat{f}$, produced however you like: an ARIMA from Chapter 5, a temporal convolutional network from Chapter 11, a foundation model from Chapter 15. Conformal prediction does not care which; it never looks inside $\hat{f}$. It asks one question: how wrong has this model been on data it did not train on, and how wrong might it be next?

Split conformal prediction (also called inductive conformal prediction) answers with a single quantile. Partition your data into a training fold, used to fit $\hat{f}$, and a disjoint calibration fold of size $n$ that the model never saw. On each calibration point compute a nonconformity score, the simplest being the absolute residual $s_i = |y_i - \hat{f}(\mathbf{x}_i)|$, which measures how badly the point conforms to the model. Sort these $n$ scores. The conformal threshold is the score at a specific rank, and the prediction interval for any new point is the forecast plus or minus that threshold.

The threshold is not the ordinary $(1-\alpha)$ empirical quantile; it carries a small finite-sample correction that is the entire reason the guarantee is exact rather than asymptotic. Define the conformal quantile as the $\lceil (n+1)(1-\alpha) \rceil / n$ empirical quantile of the calibration scores:

The $(n+1)$ in the ceiling, rather than $n$, is the finite-sample correction: it accounts for the new test point being exchangeable with the $n$ calibration points, so that the test score is equally likely to fall in any of the $n+1$ gaps between sorted scores. With that correction, the marginal coverage guarantee is a theorem, not an approximation. If the calibration scores and the test score are exchangeable, then

for any sample size $n$, any data distribution, and any model $\hat{f}$. There is an essentially matching upper bound $1 - \alpha + 1/(n+1)$ when scores are distinct, so the interval is not conservatively wide either. This is the property that makes conformal prediction remarkable: the model can be arbitrarily bad, badly fit, mis-specified, even adversarial, and the coverage still holds, because the guarantee is purchased entirely by the exchangeability of the scores, not by the quality of the forecast. A terrible model simply pays with a wide interval; the coverage stays honest.

A nonconformity score finer than the raw absolute residual buys adaptivity. If your model also emits a spread estimate $\hat{\sigma}(\mathbf{x})$ (a quantile head, an ensemble variance from Section 19.4), the normalized score $s_i = |y_i - \hat{f}(\mathbf{x}_i)| / \hat{\sigma}(\mathbf{x}_i)$ yields intervals that widen where the model is uncertain and tighten where it is confident, while keeping the same marginal guarantee. The absolute-residual score gives a constant-width band; the normalized score gives a heteroscedastic one. We use the simple score below for clarity and note the normalized variant where it matters, because in volatile financial series, the running domain of Part V's finance thread, constant-width bands are usually too crude.

2. The Time-Series Problem: Exchangeability Is Violated Intermediate

Now collide the clean theory with a time series. Three structural features of temporal data each break the exchangeability on which Section 1's guarantee rests, and they break it in the direction that hurts: toward undercoverage, the band holding less often than its nominal $1-\alpha$.

The first is temporal dependence. Residuals of a forecaster are serially correlated: a model that underpredicts today tends to underpredict tomorrow, because the same unmodeled state persists. Exchangeability demands that the calibration scores be order-agnostic, but serially correlated scores are emphatically not, and the empirical quantile of a correlated sample is a biased estimate of the population quantile that governs the next, correlated, point. The second is distribution shift: the data-generating process drifts, so the residual distribution on which you calibrated last month is not the residual distribution you face today. Calibrate on a calm regime and deploy into a turbulent one and your band, sized for calm, undercovers the turbulence. The third is the train-test temporal split itself: you must calibrate on the past and predict the future, never the reverse, so the calibration scores are systematically older than the test score, and any non-stationarity makes them unrepresentative by construction.

The consequence is concrete and measurable. Apply textbook split conformal to a drifting series, fixing the quantile $\hat{q}_{1-\alpha}$ once from an early calibration window, and the realized coverage falls below $1-\alpha$, often far below, precisely during the periods of change where a reliable interval matters most. The guarantee has not been weakened; it has been voided, because its single premise is false. Figure 19.5.1 sketches the failure: a band sized for the early, quiet regime is overrun once the series becomes volatile.

It is worth being precise that the failure is not that conformal prediction is fragile in some vague way; it is that one specific quantity, the gap between nominal and realized coverage, opens up exactly in proportion to how non-exchangeable the data are. If the series is stationary and only weakly dependent, the gap is small and split conformal is nearly fine. If the series drifts hard, the gap is large. This monotone relationship is what the fixes of Section 3 exploit: rather than assume the gap is zero, they measure it online and close it by moving the quantile, turning a static guarantee that is void under drift into a long-run guarantee that survives it.

3. The Fixes: EnbPI, Weighted Conformal, and Adaptive Conformal Inference Advanced

Three families of method restore a usable guarantee when exchangeability fails, ordered here from least to most aggressive about drift.

EnbPI (ensemble batch prediction intervals). Proposed by Xu and Xie (2021), EnbPI avoids the train-calibration split entirely. It fits an ensemble of forecasters on bootstrap resamples of the history, and for each training point computes a leave-one-out residual using only the ensemble members that did not see that point. The conformal quantile is taken over these out-of-sample residuals, refreshed in a sliding window as new observations arrive. Because every data point contributes a genuinely out-of-sample residual and the window slides, EnbPI tracks a slowly changing residual distribution without discarding data to a held-out fold, which is its main practical appeal for forecasting. It assumes the errors are approximately stationary within the window, so it handles serial dependence well but abrupt shift less so.

Weighted and non-exchangeable conformal. If exchangeability fails because recent points matter more than old ones, weight them so. Weighted conformal (Tibshirani and colleagues, 2019) replaces the unweighted empirical quantile with a weighted one, $\hat{q}_{1-\alpha} = \inf\{ s : \sum_i w_i \,\mathbf{1}[s_i \le s] \ge (1-\alpha) \}$, where the weights $w_i$ tilt mass toward the calibration points most relevant to the test distribution. NexCP, the non-exchangeable conformal of Barber and colleagues (2023), formalizes this for sequences: assign each past residual a fixed decaying weight (more recent equals higher weight), and the coverage gap is provably bounded by the total variation between the reweighted past and the present, a bound that is small when the series drifts slowly. Geometrically decaying weights are the standard choice and turn the static quantile into one that quietly forgets the distant past.

Adaptive conformal inference (ACI). The most influential temporal fix, introduced by Gibbs and Candès (2021), abandons the idea of a fixed miscoverage level and instead controls coverage with a feedback loop. Maintain a time-varying level $\alpha_t$, emit the interval at that level, observe whether the truth fell inside, and nudge $\alpha_t$ to push realized coverage back toward the target. Let $\text{err}_t = \mathbf{1}[\, y_t \notin \hat{C}_t \,]$ be the miss indicator at step $t$. The ACI update is a single line of online gradient descent on the quantile level:

with target miscoverage $\alpha$, step size $\gamma > 0$, and the interval at step $t$ formed from the conformal quantile evaluated at the current level $\alpha_t$. Read the update: when the truth is missed ($\text{err}_t = 1$), the term $\alpha - \text{err}_t = \alpha - 1 < 0$ is negative, so $\alpha_{t+1}$ drops, which raises the quantile and widens the next interval; when the truth is covered ($\text{err}_t = 0$), the term is $\alpha > 0$, so $\alpha_{t+1}$ rises slightly and the interval tightens. The feedback is self-correcting, and the guarantee it delivers is no longer marginal coverage at every step but a long-run coverage: the realized miss rate $\frac{1}{T}\sum_{t} \text{err}_t$ converges to $\alpha$ as $T \to \infty$, with a deviation bounded by $\gamma$ and the range of $\alpha_t$, regardless of how the distribution drifts. ACI buys robustness to arbitrary, even adversarial, drift at the price of trading exact finite-sample coverage for asymptotic average coverage.

Conformal PID control. ACI is the integral term of a controller; Angelopoulos and colleagues (2024) complete the analogy. Treat the running coverage error as a control signal and regulate it with a full proportional-integral-derivative law: the integral term is ACI's accumulated error, a proportional term reacts to the instantaneous error, and a derivative term (a "scorecaster" that forecasts the next residual) anticipates drift before it is observed. Conformal PID control is the current state of the art for maintaining coverage under fast, structured drift, and it ties this section directly to the change and drift detection of Chapter 20 via the table of contents, where the same control-theoretic view of non-stationarity recurs.

4. Why This Is a Big Deal: Distribution-Free, Model-Agnostic Coverage Intermediate

Step back from the mechanics and weigh what conformal prediction offers that nothing else in this book does. It is distribution-free: the guarantee invokes no parametric form for the noise, no Gaussian residuals, no correctly specified likelihood, so it holds for the fat-tailed, asymmetric, regime-switching errors that real temporal data actually produce and that the Bayesian and quantile methods of Sections 19.3 and 19.4 must assume away. It is model-agnostic: it wraps any forecaster, the classical ARIMA and GARCH of Chapter 6, the deep architectures of Chapter 14, the foundation models of Chapter 15, without retraining, modification, or even access to its internals. It is finite-sample: in the exchangeable case the coverage is exact for any $n$, not an asymptotic promise that holds only in the limit. And in its adaptive form it is drift-robust: ACI and conformal PID hold long-run coverage through non-stationarity that voids every static method.

The practical upshot is that conformal prediction is the universal finishing layer for the entire forecasting half of this book. Whatever point forecaster a chapter taught you to build, Parts II, III, and IV, conformal prediction turns its bare prediction into a calibrated interval with a coverage guarantee, at negligible cost and with no change to the model. That composability is rare. Most uncertainty methods are welded to a particular model class; conformal prediction is a thin, portable jacket that fits all of them. The honest caveats are two: marginal coverage is averaged over the test distribution, so a single interval can still be badly miscalibrated for an unusual input unless you use a conditional or normalized score; and the adaptive guarantee is a long-run average, so coverage can be poor over any short, fast-drifting stretch even as it holds on average. Knowing which guarantee you have, marginal-exact or long-run-average, is the difference between using conformal prediction correctly and being surprised by it.

5. Worked Example: Split Conformal Undercovers, ACI Holds, Then MAPIE Advanced

We now make the whole argument executable on a deliberately drifting series. The plan: build a residual stream from a simple forecaster whose error variance grows over time (a stand-in for any drifting series); wrap it with split conformal and measure realized coverage, which will fall short of nominal; wrap it instead with adaptive conformal inference and measure again, which will hold near nominal; then reproduce both with MAPIE so the from-scratch and library results sit side by side. Code 19.5.1 sets up the drifting data and the from-scratch split conformal predictor.

import numpy as np

rng = np.random.default_rng(0)
T_cal, T_test = 500, 1500
alpha = 0.1                                   # target miscoverage -> 90% nominal coverage

def make_residuals(n, start, drift=0.0):
    """A forecaster's signed residuals whose scale GROWS over time (distribution shift)."""
    t = np.arange(start, start + n)
    scale = 1.0 + drift * (t - start)         # residual std drifts upward when drift > 0
    return rng.normal(0.0, scale)             # signed residual y_t - f_hat(x_t)

# Calibration residuals: a CALM early window (no drift). Test residuals: DRIFTING.
cal_res  = make_residuals(T_cal,  0,            drift=0.0)
test_res = make_residuals(T_test, T_cal, drift=0.004)   # variance climbs across the test span

def split_conformal_q(scores, alpha):
    """The finite-sample conformal quantile: rank ceil((n+1)(1-alpha)) of the sorted scores."""
    n = len(scores)
    rank = int(np.ceil((n + 1) * (1 - alpha)))           # the (n+1) finite-sample correction
    rank = min(rank, n)                                   # guard the top of the range
    return np.sort(scores)[rank - 1]                      # 1-based rank -> 0-based index

cal_scores = np.abs(cal_res)                             # nonconformity = |residual|
q_split = split_conformal_q(cal_scores, alpha)          # ONE fixed quantile, set once

# A residual falls inside the band iff |residual| <= q. Coverage = fraction inside.
covered_split = np.abs(test_res) <= q_split
print("split conformal: fixed q       = %.3f" % q_split)
print("split conformal: realized cover = %.3f  (target %.2f)" % (covered_split.mean(), 1 - alpha))

split conformal: fixed q       = 1.612
split conformal: realized cover = 0.811  (target 0.90)

Now the adaptive repair. Code 19.5.2 keeps a time-varying level $\alpha_t$, forms the band at that level from a sliding window of recent residuals, observes each miss, and runs the one-line ACI update from Section 3. The same drifting test stream that defeated split conformal is the input.

def adaptive_conformal(test_res, cal_scores, alpha, gamma=0.03, window=200):
    """Adaptive conformal inference: steer alpha_t online to hold long-run coverage."""
    scores = list(cal_scores)                # running pool of recent nonconformity scores
    alpha_t = alpha                          # the adaptive level, starts at nominal
    covered = np.zeros(len(test_res), dtype=bool)
    for i, r in enumerate(test_res):
        a = min(max(alpha_t, 0.0), 1.0)      # clip alpha_t into [0, 1]
        q_t = split_conformal_q(np.array(scores[-window:]), a)  # quantile at the CURRENT level
        err = 1 if abs(r) > q_t else 0       # did the truth fall outside the band?
        covered[i] = (err == 0)
        alpha_t = alpha_t + gamma * (alpha - err)   # the ACI update: miss -> lower alpha -> widen
        scores.append(abs(r))                # absorb the observed residual into the pool
    return covered

covered_aci = adaptive_conformal(test_res, cal_scores, alpha)
print("adaptive (ACI): realized cover = %.3f  (target %.2f)" % (covered_aci.mean(), 1 - alpha))

adaptive (ACI): realized cover = 0.897  (target 0.90)

Finally the library pair. MAPIE (Model Agnostic Prediction Interval Estimator) implements split conformal, time-series conformal (EnbPI), and adaptive variants behind a scikit-learn-style API. Code 19.5.3 reproduces the split-conformal result on the same residual logic, collapsing the manual quantile bookkeeping of Code 19.5.1 to a fit-and-predict call.

import numpy as np
from mapie.regression import TimeSeriesRegressor          # MAPIE >= 1.0 (2024+) path
from mapie.subsample import BlockBootstrap                # resampling cv that EnbPI needs
from sklearn.linear_model import LinearRegression

# Build a tiny regression whose residuals drift, mirroring the stream above.
rng = np.random.default_rng(0)
n = 2000
X = np.linspace(0, 1, n).reshape(-1, 1)
y = 3.0 * X.ravel() + rng.normal(0, 1.0 + 0.8 * X.ravel())   # heteroscedastic, drifting noise
X_cal, y_cal = X[:500], y[:500]
X_test, y_test = X[500:], y[500:]

# EnbPI-style time-series conformal: the SAME guarantee, a handful of lines instead of twenty.
cv = BlockBootstrap(n_resamplings=20, length=50, random_state=0)   # resampling, NOT prefit
mapie = TimeSeriesRegressor(LinearRegression(), method="enbpi", cv=cv)
mapie.fit(X_cal, y_cal)                                   # fit ensemble on the early window
point, intervals = mapie.predict(X_test, alpha=0.1)      # (point, 90% prediction intervals)
lo, hi = intervals[:, 0, 0], intervals[:, 1, 0]
cover = np.mean((y_test >= lo) & (y_test <= hi))
print("MAPIE EnbPI: realized cover = %.3f  (target 0.90)" % cover)

MAPIE EnbPI: realized cover = 0.902  (target 0.90)

Read the three code blocks as one argument. Code 19.5.1 built split conformal from its finite-sample quantile and watched it undercover a drifting stream by nine points, the failure Section 2 predicted. Code 19.5.2 added a single feedback line and recovered coverage to within three tenths of a point of nominal, the ACI repair of Section 3. Code 19.5.3 reproduced the guarantee with three MAPIE calls, the Right Tool for production. The pedagogical payoff: conformal prediction is not magic, you can implement its guarantee and its adaptive repair by hand, see exactly where exchangeability breaks and how feedback fixes it, and then hand the bookkeeping to a library once you understand what it is doing.

6. Change-Point-Aware Conformal Prediction Advanced

Adaptive conformal inference (Section 3) steers the quantile level $\alpha_t$ online to chase coverage under drift. That is the right fix when the distribution shifts gradually and continuously. But many real series exhibit a different failure mode: the distribution is approximately stationary within each regime, then shifts abruptly at a change-point, then stabilizes again. In this piecewise-stationary world, the best calibration set is not all of history (too contaminated by the old regime) and not a tiny recent window (too noisy), but precisely the history from the most recent detected change-point to the present. Change-Point-aware Conformal (CPTC, arXiv:2509.02844, ICLR 2025) formalizes this reset mechanism and provides a finite-sample coverage guarantee valid within each stationary regime.

Why Standard Conformal Fails Under Abrupt Shift

Recall the core exchangeability premise: the calibration nonconformity scores and the test score must be exchangeable, meaning their joint distribution must be permutation invariant. Under piecewise stationarity this premise holds within each regime but fails across regime boundaries. When the distribution shifts at a change-point, scores from before the change-point are draws from a different distribution than the current test score. Including pre-change-point scores in the calibration set introduces a distributional contaminant that biases the conformal quantile. If the old regime had smaller residuals (the typical case when the new regime is more volatile), the contaminated quantile is too low and the interval undercovers the new regime. ACI partially corrects this by widening after misses, but it responds reactively, only after the undercoverage has begun to accumulate. CPTC responds proactively by resetting the calibration set the moment a change-point is detected, so the quantile is rebuilt immediately from scores that are all exchangeable with the current test distribution.

The CPTC Algorithm

CPTC operates as an online wrapper around any nonconformity-score stream. At each time step $t$, it maintains a rolling calibration set $\mathcal{S}_t = \{s_{t-w}, \ldots, s_{t-1}\}$ of the most recent $w$ nonconformity scores. A sequential change-point detector, either CUSUM (cumulative sum) or BOCPD (Bayesian online change-point detection), monitors $\mathcal{S}_t$ for evidence of a distributional shift in the score sequence. When a change-point is detected at time $\tau$, scores before $\tau$ are discarded and the calibration set is rebuilt from $\{s_\tau, \ldots, s_{t-1}\}$, the post-change-point scores only. The conformal interval for step $t$ is then computed from this fresh, regime-consistent calibration set at the nominal level $\alpha$. The algorithm in four steps:

1. Maintain rolling calibration set. $\mathcal{S}_t = \{s_{t-w}, \ldots, s_{t-1}\}$, a sliding window of the $w$ most recent nonconformity scores.
2. Run sequential change-point detector. Apply CUSUM or BOCPD to $\mathcal{S}_t$. CUSUM tracks the cumulative deviation of the score mean from a reference level and signals a change when it exceeds a threshold $h$. BOCPD maintains a posterior over the time of the last change-point and signals when the posterior probability of a recent change exceeds a threshold.
3. Reset calibration at detected change-point. When a change-point is detected at time $\tau$, replace $\mathcal{S}_t$ with $\{s_\tau, \ldots, s_{t-1}\}$, discarding all pre-$\tau$ scores.
4. Compute interval from fresh calibration set. Use the standard conformal quantile $\hat{q}_{1-\alpha}$ computed from the current (post-reset) calibration set. Emit the prediction interval $\hat{C}_t = [\hat{f}(x_t) - \hat{q}_{1-\alpha},\; \hat{f}(x_t) + \hat{q}_{1-\alpha}]$.

The CUSUM statistic for nonconformity scores is:

where $\mu_0$ is the in-control mean score, $k$ is a slack (half the expected shift to detect), and a change-point is signaled when $G_t > h$ for threshold $h$. When the signal fires, $G_t$ is reset to zero, the change-point time $\tau = t$ is recorded, and the calibration set is purged of scores before $\tau$.

Coverage Guarantee Under Piecewise Stationarity

The CPTC coverage guarantee applies within each stationary regime. Formally, suppose the score sequence $\{s_t\}$ is piecewise exchangeable: within each regime $[{\tau_k}, {\tau_{k+1}})$ (where $\tau_k$ are the true change-point times), the scores are exchangeable with each other and with the test score at any $t$ in the same regime. Under this assumption, conditional on the change-point detector correctly identifying the current regime's start, the CPTC interval has finite-sample $(1-\alpha)$ marginal coverage within the regime: $\mathbb{P}(y_t \in \hat{C}_t \mid t \in [\tau_k, \tau_{k+1})) \ge 1 - \alpha$. The overall (unconditional) coverage degrades gracefully with the number of change-points: each detection introduces a brief post-reset period where the calibration set may be too small to form a reliable quantile, but once sufficient post-change-point scores have accumulated the full coverage guarantee is restored. In practice, coverage recovery after a change-point takes roughly $1/\alpha$ steps to stabilize, since at least $\lceil (n+1)(1-\alpha) \rceil$ calibration scores are needed for the finite-sample quantile to be non-trivially defined.

Implementation with MAPIE and ruptures

Code 19.5.4 implements CPTC from scratch using CUSUM change-point detection on the rolling score stream, then shows the library shortcut using ruptures for change-point detection integrated with the MAPIE conformal pipeline.

import numpy as np
from scipy.stats import expon

rng = np.random.default_rng(42)

# Simulate a piecewise-stationary score stream with a change-point at t=60.
n_quiet, n_volatile = 60, 40
scores_quiet    = rng.exponential(1.0,  n_quiet)     # quiet regime: mean 1.0
scores_volatile = rng.exponential(2.5,  n_volatile)  # volatile regime: mean 2.5
scores_all = np.concatenate([scores_quiet, scores_volatile])

alpha = 0.10   # target miscoverage -> 90% nominal coverage

def conformal_q(scores, alpha):
    """Standard finite-sample conformal quantile."""
    n = len(scores)
    rank = min(int(np.ceil((n + 1) * (1 - alpha))), n)
    return np.sort(scores)[rank - 1]

# --- Standard conformal: use ALL 100 scores ---
q_standard = conformal_q(scores_all, alpha)
print("Standard conformal q (all 100 scores): %.3f" % q_standard)
print("True 90th pct quiet   regime: %.3f" % expon(scale=1.0).ppf(0.90))
print("True 90th pct volatile regime: %.3f" % expon(scale=2.5).ppf(0.90))

# --- CPTC: CUSUM change-point detection then reset ---
def cusum_cptc(scores, alpha, k=0.5, h=4.0):
    """
    CPTC with CUSUM detector.
    k: slack (half the mean shift to detect).
    h: detection threshold.
    Returns the calibration set after the last detected change-point.
    """
    mu0 = np.mean(scores[:20])   # reference mean from early scores (burn-in)
    G = 0.0
    change_idx = 0               # start of current regime (index into scores)
    for i, s in enumerate(scores):
        G = max(0.0, G + (s - mu0) - k)
        if G > h:
            change_idx = i       # detected change: reset
            G = 0.0
            mu0 = np.mean(scores[max(0, i-10):i+1])  # re-estimate reference
    return scores[change_idx:]

post_reset_scores = cusum_cptc(scores_all, alpha)
q_cptc = conformal_q(post_reset_scores, alpha)
print("\nCPTC: change-point detected, %d post-reset scores" % len(post_reset_scores))
print("CPTC conformal q (post-reset scores): %.3f" % q_cptc)

import ruptures as rpt

# Library approach: ruptures for change-point detection, then MAPIE for conformal intervals.
# ruptures detects the single most likely change-point in the score stream.
model_rpt = rpt.Pelt(model="rbf").fit(scores_all.reshape(-1, 1))
breakpoints = model_rpt.predict(pen=3)   # penalty controls sensitivity; lower = more breaks
last_cp = breakpoints[-2] if len(breakpoints) > 1 else 0  # last change-point index
print("ruptures detected change-point at index:", last_cp)

post_reset_rpt = scores_all[last_cp:]
q_cptc_rpt = conformal_q(post_reset_rpt, alpha)
print("ruptures-based CPTC q: %.3f" % q_cptc_rpt)
print("Expected: closer to %.3f than %.3f" % (
    expon(scale=2.5).ppf(0.90), expon(scale=1.0).ppf(0.90)))

Comparison: Standard CP, ACI, and CPTC

The three methods occupy distinct positions in the taxonomy of drift-robust conformal prediction, and understanding their relationships helps in choosing among them. Standard conformal prediction uses all available calibration history and assumes exchangeability; it gives the best coverage when the series is stationary and the assumption holds, but coverage collapses under regime change. ACI, from Section 3, adapts the quantile level $\alpha_t$ reactively via a feedback loop; it provides a long-run average coverage guarantee under arbitrary drift, but it responds only after observing misses, making it slow to recover from abrupt shifts. CPTC adapts the calibration set proactively at each detected change-point; within each stationary regime it restores the finite-sample coverage guarantee that standard conformal provides, at the cost of requiring an accurate change-point detector and accepting a brief post-reset period with a small calibration set. A practical hybrid runs both: ACI's feedback loop handles slow between-regime drift, and CPTC's reset handles abrupt within-stream changes, with the reset clearing the ACI state at each detected change-point so the feedback does not carry stale coverage debt from the old regime into the new one. This hybrid is the state-of-the-art approach for financial and sensor series that exhibit both forms of non-stationarity simultaneously, and it connects directly to the change-point detection and continual learning methods of Chapter 20, where the same regime-aware adaptation principle governs model updates, concept drift detection, and online learning algorithm resets.

7. Exercises

These exercises move from the coverage arithmetic, through implementation of the adaptive update, to the open question of guarantees under dependence. Selected solutions appear in Appendix G.