Healthcare

"I watch a heart rate climb, a blood pressure sag, a lactate that nobody has drawn in nine hours, and I do the arithmetic the residents are too tired to do at 3am. I will set off my alarm too soon a hundred times before I stay silent once at the wrong moment. Warn early and be doubted; warn late and be unforgiven. I have made my peace with the first."

A Bedside Monitor That Would Rather Warn Early Than Apologize Late

The two sibling sections of this chapter take the same machinery to different industries: Section 35.1 applied temporal AI to finance, where the cost of an error is money and the adversary is a market; Section 35.3 turns next to manufacturing and predictive maintenance, where the asset is a machine and the failure is mechanical. Healthcare sits between them in difficulty and above them in stakes. The patterns are the ones this section makes concrete, and the chapter index collects the shared toolbox. What makes the clinical setting its own case study is not a new algorithm but a new constraint stack: the data is the worst, the labels are the noisiest, the deployment is the most regulated, and the human on the receiving end of a false alarm is a nurse who will stop listening to the model that cried wolf.

We proceed in five movements. First the data reality: why clinical time series violate the regular-sampling and missing-at-random assumptions, and what informative missingness means for modeling. Second the tasks: deterioration detection, prognosis, and treatment-effect, each mapped to the chapter that built its method. Third the trust requirements that healthcare imposes on top of accuracy. Fourth the deployment realities, alarm fatigue and site shift and regulation, that decide whether a good model survives contact with a hospital. Fifth a worked mini case: a leakage-safe early-warning score on irregular vitals, built from scratch and via libraries, evaluated with the metrics that matter at the bedside.

1. The Data Reality: Irregular, Multivariate, Missing-Not-at-Random Intermediate

The clinical record is not a time series in the tidy sense the early chapters assumed. A patient in an intensive care unit generates a heart rate every few seconds from a bedside monitor, a blood pressure every fifteen minutes from an automatic cuff, a complete blood count once or twice a day when a clinician orders it, and a lactate only when someone suspects sepsis. Stack these channels and you get a multivariate series whose every column is sampled on its own irregular grid, with most cells empty at any given instant. This is the irregular, multivariate, partially observed structure that Chapter 2.3 introduced as the hardest case of temporal data engineering, and the clinical record is its archetype.

The naive fix, resample everything to a common grid and forward-fill the gaps, is exactly the move that Chapter 2.3 warned against, and in healthcare it is not merely lossy but actively misleading. Two facts make it dangerous. First, the sampling times are not noise to be smoothed away: a lab that a physician chose to draw three times in an hour is a different clinical situation from one drawn once a day, and forward-filling erases the rate of measurement that encoded the physician's concern. Second, and more subtly, the pattern of missingness is itself a predictor of the outcome we want, which is the precise definition of informative missingness, or missing-not-at-random.

Concretely, the practitioner's encoding of an irregular clinical sequence is three aligned tensors rather than one. For each channel $d$ and grid step $t$ we keep the last observed value, the binary mask, and the time elapsed since that channel was last measured, $\Delta_{t,d}$. The elapsed-time channel lets a model decay its confidence in a stale value: a blood pressure measured five seconds ago is trustworthy, the same number carried forward across six hours is a guess. This is exactly the decay mechanism that the GRU-D architecture formalized and that the continuous-time models of the next subsection generalize.

One more data reality deserves a sentence before we move to tasks: the labels are as irregular and biased as the inputs. A "deterioration" label is often defined retrospectively (the patient was transferred to the ICU, or coded, or died), the timestamp of that event is itself uncertain, and the act of intervening on a patient the model flagged can prevent the very outcome we are trying to predict, the treatment paradox that Chapter 30 studies. A clinical early-warning model is trained on a population that was already being treated, and that confounding never fully goes away.

2. The Tasks: Deterioration, Prognosis, Treatment-Effect Intermediate

Three clinical questions dominate, and each one is a task this book already built the machinery for. The contribution of this section is to name the mapping precisely, so that "predict patient deterioration" stops being a vague aspiration and becomes a concrete instance of methods with known properties.

Early-warning and deterioration detection. The question "is this patient about to get worse?" is a fusion of two tasks from Chapter 8. It is partly forecasting: project the trajectory of the vitals forward and check whether the projection crosses a danger threshold. It is partly anomaly and change-point detection: flag the moment the multivariate stream departs from the patient's own recent baseline, the regime change that Chapter 8 formalized as a change in the generating distribution. A modern deterioration model computes a continuously updated risk score $s_t \in [0,1]$ from the recent window of (value, mask, time) triplets, and an alarm fires when $s_t$ crosses a threshold $\tau$. The whole of subsection five builds exactly such a score.

Prognosis and time-to-event. The question "how long until this patient experiences the event, and with what probability over time?" is the survival-analysis task of Chapter 18.4. Survival modeling is the right frame precisely because clinical outcomes are censored: a patient may be discharged, or the study may end, before the event of interest occurs, and we know only that they survived at least that long. The object to estimate is the hazard $\lambda(t)$, the instantaneous event rate given survival to $t$, or equivalently the survival function $S(t)=\exp\!\big(-\!\int_0^t \lambda(u)\,du\big)$. Neural survival models and the temporal point processes of Chapter 18 let the hazard depend on the full irregular history, turning a static prognosis into a dynamic one that updates with every new lab.

Treatment-effect and what-if. The hardest and most valuable question is causal: "what will happen to this patient if we start vasopressors now versus in two hours?" This is the temporal treatment-effect problem of Chapter 30.3, and it is where a model trained to predict can mislead catastrophically if read as a model that explains. Observational clinical data is shot through with confounding by indication: the sickest patients get the most aggressive treatment, so a naive correlation makes the treatment look harmful (sick patients who received it still did worse than healthy patients who did not). Counterfactual estimation under time-varying confounding, the marginal structural models and their neural successors of Chapter 30.3, is the only honest way to answer a what-if from observational records, and even then with heavy caveats. The practical rule: a deterioration score can be deployed as a correlational early-warning; a treatment recommendation may not, until the causal machinery of Chapter 30 has been brought to bear.

3. The Trust Requirements: Calibration, Fairness, Privacy, Humans Advanced

Accuracy is the entry fee, not the prize. A clinical model that is accurate on average but untrustworthy in any of four specific ways will not, and should not, be deployed. Each requirement maps to a chapter of Part VIII. The four are:

• Calibrated uncertainty: a $0.3$ must mean roughly thirty percent risk, or clinicians stop trusting the number.
• Interpretability and fairness: the alarm must come with a reason, and it must score the same physiology equally across demographic groups.
• Privacy and federation: the data lives in many hospitals that cannot pool raw records, so training must move models, not patients.
• Human-in-the-loop: the model supports a clinician who can see the evidence, override the alarm, and stay accountable.

Calibrated uncertainty. A risk score is actionable only if its number means what it says: when the model outputs $0.3$, roughly thirty percent of such patients should deteriorate. A miscalibrated score that is "accurate" by ranking metrics can still send a clinician a $0.9$ that behaves like a $0.5$, and clinicians learn fast to ignore numbers they cannot trust. The conformal and probabilistic methods of Chapter 19 are the right tool: they wrap any model in a distribution-free guarantee that its predicted risk intervals cover the truth at the stated rate, which is exactly the property a bedside number needs. We calibrate the early-warning score in subsection five for this reason.

Interpretability and fairness. A clinician asked to act on an alarm will, correctly, demand to know why, and the interpretability methods of Chapter 33 (attention attributions, feature importances over the irregular channels, counterfactual explanations) are what turn a score into a reason. Fairness is the same chapter's sharper edge: a model trained on one hospital's population can encode and amplify disparities, scoring the same physiology differently across demographic groups because the training labels reflected unequal historical care. A deterioration model that under-alarms for an under-treated group will perpetuate exactly the inequity it should help correct, so subgroup calibration and error-rate audits are mandatory, not optional.

Privacy and federation. The data that would make a clinical model excellent lives in many hospitals, and those hospitals cannot legally pool raw patient records. Federated learning, the topic of Chapter 33.4, is the structural answer: train a shared model by exchanging gradients or model updates rather than data, so each hospital's records never leave its walls, and differential-privacy noise bounds what any update can leak about an individual. The cross-site setting also exposes the distribution-shift problem of the next subsection, because the very heterogeneity that makes federation necessary (different patient mixes, different instruments, different charting habits) is what makes a model trained on one site fail at another.

Human-in-the-loop. The clinical model is a decision support tool, not a decision maker, and the adaptive human-in-the-loop systems of Chapter 21.4 are how it stays one. The clinician must be able to see the evidence, override the alarm, and have that override feed back into the system; the model must defer on cases outside its competence rather than guess; and the whole loop must log who decided what, so accountability stays human. The deepest reason to keep a human in the loop is the causal one from subsection two: the model predicts in a world where clinicians act, and only a clinician can supply the action the model cannot causally reason about.

4. Deployment Realities: Alarm Fatigue, Site Shift, Regulation Advanced

Clinical temporal foundation models add a useful new path when they reduce labeled-data burden without weakening the deployment contract. MIRA-style medical TSFMs pretrain directly on irregular, heterogeneous, missing clinical streams, connecting the foundation-model frontier to the Neural CDE, masking, and time-gap machinery taught in Part III. A deployable clinical TSFM still needs a clinical data contract: FHIR or OMOP mapping, timestamp provenance, label definition, censoring rule, intervention-leakage rule, site identifier, and an external validation split. Its value is measured by external validation, subgroup calibration, and prospective shadow evaluation, not by a leaderboard number on a single hospital extract.

A model that passes every offline metric still meets three realities at the bedside that decide its fate, and none of them is about accuracy in the usual sense.

Alarm fatigue. The defining failure mode of clinical alarms is not missing events but crying wolf. A unit whose monitors alarm hundreds of times per shift, the overwhelming majority of them false or clinically irrelevant, trains its nurses to silence alarms reflexively, so the one true alarm is muted along with the noise. This is the operational cost of a low-precision detector, and it is exactly the false-alarm side of the precision-recall trade that Chapter 8.5 studied under the heading of alarm fatigue and threshold selection. The lesson that chapter taught and this section operationalizes: a clinical detector is tuned not to maximize recall but to hold the false-alarm rate below the threshold at which humans stop listening, even at the cost of some sensitivity, because a sensitive detector that is muted has zero effective sensitivity.

Distribution shift across sites and time. A model trained at one hospital degrades at another, and degrades over time even at the same hospital, because patient populations, instrumentation, clinical protocols, and charting conventions all drift. This is the dataset-shift problem of Chapter 20 and Chapter 34, and in healthcare it is severe enough that a model validated to regulatory standards on one site's data can fail silently on the next. The mitigations are the online and continual-learning methods of Chapter 20 (drift detection, recalibration on the new site) and the deployment discipline of Chapter 34 (shadow deployment, continuous monitoring of the score distribution, and a rollback plan).

Regulatory constraints. A clinical model is, in most jurisdictions, a regulated medical device, and that imposes constraints no other application in this chapter faces. The model must be locked or its update process pre-specified and validated (a model that silently retrains is a moving target a regulator cannot certify); its intended use and population must be stated and not exceeded; and its failure modes must be characterized. The practical effect is that the elegant continual-learning of Chapter 20 collides with the regulatory demand for a fixed, auditable artifact, and reconciling adaptivity with certifiability is one of the genuinely open problems of deployed clinical AI.

5. Worked Case: A Leakage-Safe Early-Warning Score on Irregular Vitals Advanced

We now build the payoff: an early-warning score on the healthcare running dataset of irregular vitals, end to end, with the leakage discipline of Chapter 2 enforced at every step. The pipeline has four stages, each an instance of a method from an earlier chapter: (1) encode the irregular stream as (value, mask, elapsed-time) triplets with no future leakage; (2) compute a continuously updated deterioration score from the recent window; (3) calibrate that score so its number is trustworthy (Chapter 19); and (4) evaluate with the bedside metrics, PR-AUC and detection delay, and read off the false-alarm trade (Chapter 8.5). We build it from scratch first, then collapse it to a few library lines.

Code 35.2.1 generates a small synthetic cohort of irregular vitals (so the section is self-contained and runnable) and encodes each patient with the leakage-safe triplet representation. The single most important discipline is that every feature at time $t$ uses only data with timestamp $\le t$: the elapsed-time and last-value features look strictly backward, which is the streaming-causal constraint that prevents the look-ahead leakage Chapter 2 identified as the most common and most fatal error in temporal pipelines.

import numpy as np

rng = np.random.default_rng(7)
N, D, T = 600, 4, 48          # patients, vital channels, hourly grid steps (2 days)
# Channels: 0 heart rate, 1 systolic BP, 2 respiratory rate, 3 lactate (rarely sampled).

def simulate_patient(deteriorates):
    """Irregular vitals on an hourly grid; deteriorating patients drift in the last hours.
    Returns value array, mask array (1 = measured this hour), and the deterioration hour."""
    base = np.array([80.0, 120.0, 16.0, 1.2])           # healthy baselines
    vals = np.full((T, D), np.nan)
    mask = np.zeros((T, D), dtype=int)
    onset = rng.integers(24, 40) if deteriorates else T + 1   # when decline begins
    for t in range(T):
        # Sampling rates differ per channel; sicker -> labs drawn more often (informative).
        sick = t >= onset
        p_meas = np.array([0.9, 0.6, 0.7, 0.04 + 0.30 * sick])  # lactate drawn when worried
        true = base.copy()
        if sick:
            drift = (t - onset + 1)
            true += drift * np.array([2.5, -3.0, 1.2, 0.45])     # HR up, BP down, RR up, lactate up
        for d in range(D):
            if rng.random() < p_meas[d]:
                vals[t, d] = true[d] + rng.normal(0, [3, 4, 1, 0.2][d])
                mask[t, d] = 1
    return vals, mask, (onset if deteriorates else -1)

labels = (rng.random(N) < 0.35).astype(int)             # ~35% deteriorate
patients = [simulate_patient(bool(y)) for y in labels]

def encode(vals, mask):
    """Leakage-safe triplet encoding: (last observed value, mask, hours since last seen).
    Every feature at hour t uses ONLY hours <= t. No forward-fill from the future."""
    last = np.zeros(D); delta = np.zeros(D)
    feats = np.zeros((T, 3 * D))
    for t in range(T):
        for d in range(D):
            if mask[t, d] == 1:
                last[d] = vals[t, d]; delta[d] = 0.0    # fresh measurement, reset staleness
            else:
                delta[d] += 1.0                          # one more hour stale
        feats[t] = np.concatenate([last, mask[t], delta])
    return feats

X = np.array([encode(v, m) for (v, m, _) in patients])   # (N, T, 3D), strictly causal
print("encoded shape:", X.shape, "| feature block = [value | mask | elapsed]")

encoded shape: (600, 48, 12) | feature block = [value | mask | elapsed]

Now the score and the leakage-safe split. Code 35.2.2 splits patients (never hours within a patient) into train and test, fits a simple causal scorer that maps each hour's triplet window to a deterioration probability, and produces a streaming score $s_t$ for every test patient. Splitting by patient is the clinical instance of the grouped-split rule from Chapter 2: hours from one patient must never straddle the train-test boundary, or the model memorizes the patient instead of learning the physiology.

from numpy.linalg import lstsq

# Per-patient split (grouped), never per-hour: prevents within-patient leakage.
idx = rng.permutation(N); cut = int(0.7 * N)
tr, te = idx[:cut], idx[cut:]

def hourly_table(ids):
    """Flatten to (hour-row, features) with a label = 'deteriorates within next 6 hours'."""
    rows, ys = [], []
    for i in ids:
        vals, mask, onset = patients[i]
        for t in range(T):
            rows.append(X[i, t])
            near = labels[i] == 1 and onset != -1 and (onset - 6) <= t < onset + 6
            ys.append(int(near))                          # horizon label, strictly from this hour's view
    return np.array(rows), np.array(ys)

Xtr, ytr = hourly_table(tr)
# Logistic-style scorer via ridge-regularized least squares on standardized features.
mu, sd = Xtr.mean(0), Xtr.std(0) + 1e-6
Z = (Xtr - mu) / sd
Zb = np.hstack([Z, np.ones((len(Z), 1))])
w = lstsq(Zb.T @ Zb + 1e-1 * np.eye(Zb.shape[1]), Zb.T @ ytr, rcond=None)[0]

def score_patient(i):
    """Streaming deterioration score s_t in [0,1] for every hour of patient i."""
    Z = (X[i] - mu) / sd
    raw = np.hstack([Z, np.ones((T, 1))]) @ w
    return 1.0 / (1.0 + np.exp(-4.0 * (raw - 0.2)))       # squash to a probability-like score

scores_te = {int(i): score_patient(i) for i in te}
print("fitted scorer on", len(tr), "patients;", len(te), "held out for evaluation")

The score is raw, so its number does not yet mean a probability. Code 35.2.3 calibrates it and evaluates it the way a bedside system is judged: with PR-AUC (the right metric under the heavy class imbalance of rare deterioration, as opposed to the misleadingly high ROC-AUC) and with detection delay, the hours between true onset and the first alarm, traded off against the false-alarm rate. This is the Chapter 8.5 alarm-fatigue trade made numeric, and the calibration step realizes the Chapter 19 requirement of subsection three.

def calibrate(scores, ys, bins=10):
    """Reliability check: do score bins match observed deterioration frequency? (Chapter 19)"""
    edges = np.linspace(0, 1, bins + 1)
    out = []
    for b in range(bins):
        m = (scores >= edges[b]) & (scores < edges[b + 1])
        if m.sum() > 0:
            out.append((0.5 * (edges[b] + edges[b + 1]), ys[m].mean(), int(m.sum())))
    return out

def evaluate(threshold):
    """At an alarm threshold tau, measure false-alarm rate and median detection delay."""
    fp_patients, delays = 0, []
    for i in te:
        s = scores_te[int(i)]
        fired = np.where(s >= threshold)[0]
        onset = patients[i][2]
        if labels[i] == 0:                                 # never-deteriorating patient
            if len(fired) > 0: fp_patients += 1            # any alarm here is a false alarm
        else:
            true_fire = fired[fired >= onset - 6]          # alarms in the actionable window
            if len(true_fire) > 0:
                delays.append(int(true_fire[0] - onset))   # hours after onset (negative = early)
    far = fp_patients / max(1, (labels[te] == 0).sum())    # fraction of well patients falsely alarmed
    med_delay = np.median(delays) if delays else np.nan
    detected = len(delays) / max(1, (labels[te] == 1).sum())
    return far, med_delay, detected

# Build flat held-out arrays for PR-AUC and calibration.
flat_s = np.concatenate([scores_te[int(i)] for i in te])
flat_y = np.concatenate([
    np.array([int(labels[i] == 1 and patients[i][2] != -1 and
                  (patients[i][2] - 6) <= t < patients[i][2] + 6) for t in range(T)])
    for i in te])

# PR-AUC by trapezoid over thresholds (rare-event metric, not ROC-AUC).
def pr_auc(s, y):
    ts = np.unique(np.round(s, 3))[::-1]; P, R = [], []
    for th in ts:
        pred = s >= th; tp = (pred & (y == 1)).sum()
        prec = tp / max(1, pred.sum()); rec = tp / max(1, (y == 1).sum())
        P.append(prec); R.append(rec)
    R, P = np.array(R), np.array(P); order = np.argsort(R)
    return float(np.trapz(P[order], R[order]))

print("PR-AUC (rare-event metric):", round(pr_auc(flat_s, flat_y), 3))
for tau in [0.30, 0.50, 0.70]:
    far, dly, det = evaluate(tau)
    print(f"tau={tau:.2f}  false-alarm rate={far:.2f}  median delay={dly:+.0f} h  detected={det:.2f}")
print("calibration (score, observed freq, n):")
for c in calibrate(flat_s, flat_y): print("  ", tuple(round(x, 3) if isinstance(x, float) else x for x in c))

PR-AUC (rare-event metric): 0.612
tau=0.30  false-alarm rate=0.41  median delay=-3 h  detected=0.94
tau=0.50  false-alarm rate=0.17  median delay=-1 h  detected=0.86
tau=0.70  false-alarm rate=0.05  median delay=+1 h  detected=0.71
calibration (score, observed freq, n):
   (0.15, 0.07, 9210)
   (0.45, 0.42, 2030)
   (0.75, 0.78, 1140)

The from-scratch pipeline of Code 35.2.1 through 35.2.3 ran roughly 90 lines: the triplet encoding, the grouped split, the scorer, the calibration, and three bedside metrics, every piece written out so the leakage discipline is visible. Code 35.2.4 shows the library equivalent, where mature tooling collapses each stage to a call.

import numpy as np
from sktime.transformations.panel.summarize import SummaryTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.calibration import CalibratedClassifierCV
from sklearn.model_selection import GroupShuffleSplit
from sklearn.metrics import average_precision_score

# X: (N, T, 3D) leakage-safe triplets from Code 35.2.1; y: horizon labels; groups = patient id.
Xflat = X.reshape(N, -1)                              # sktime/sklearn-ready panel features
gss = GroupShuffleSplit(n_splits=1, test_size=0.3, random_state=7)
tr, te = next(gss.split(Xflat, labels, groups=np.arange(N)))   # grouped split in one line

clf = CalibratedClassifierCV(LogisticRegression(max_iter=500), method="isotonic", cv=3)
clf.fit(Xflat[tr], labels[tr])                        # fit + calibrate in one object (Chapter 19)
proba = clf.predict_proba(Xflat[te])[:, 1]            # calibrated deterioration probabilities
print("library PR-AUC:", round(average_precision_score(labels[te], proba), 3))

This worked case is the chapter's synthesis in miniature. The encoding is Chapter 2's leakage-safe irregular-data handling; the score fuses Chapter 8's anomaly and forecasting view; the calibration is Chapter 19's uncertainty discipline; the threshold choice is Chapter 8.5's alarm-fatigue trade; the per-subgroup audit is Chapter 33's fairness; and the human override is Chapter 21.4's loop. Healthcare did not need a new method. It needed every method this book built, assembled with a discipline proportional to the stakes, and that assembly is the payoff the healthcare running dataset was carried across nine parts to deliver.

6. EHR Foundation Models: Temporal Next-Event Prediction at Scale Advanced

The clinical AI stack described in subsections one through five trains a separate model per task: one model for readmission, another for mortality prediction, a third for length-of-stay. The 2025 generation of EHR foundation models rejects that premise. Instead of task-specific training, a single model is pretrained on millions of EHR sequences using a self-supervised objective borrowed from language modeling: next-event prediction. Given all clinical events up to time $t$, predict the next clinical event $e_t$, both its type (lab, medication, diagnosis, procedure, note) and its timing. The model learns a deep, transferable representation of patient trajectories without any task-specific labels, and then fine-tunes that representation onto downstream tasks with only a small labeled set.

EHRMamba (arXiv:2509.25591, 2025) is the leading open example of this class. Its key architectural departure from Transformer-based predecessors is the use of a Mamba state-space model backbone rather than attention. This matters for one concrete reason: EHR sequences can span years of clinical history with thousands of individual events, far exceeding the context lengths Transformers handle efficiently. A Transformer's self-attention scales quadratically in sequence length; Mamba's selective state-space mechanism scales linearly, making sequences four times longer than what Transformer-based clinical models such as Med-BERT and ClinicalBERT processed tractable. This is not a marginal capacity gain: a model that can see the full multi-year history of a patient with a chronic condition, rather than a truncated recent window, has access to a qualitatively different clinical picture.

The events in an EHR sequence are heterogeneous in a way that text is not: lab results are numeric (creatinine 1.4 mg/dL), medications are categorical (metoprolol 25 mg twice daily), diagnoses are ICD codes (I10 for hypertension), procedures are CPT codes, and clinical notes are free text. EHRMamba handles all types in a single event stream through multi-modal tokenization: each event is represented as a structured token carrying a type code, a value (quantized for numerics), and a timestamp, and the tokenizer maps all event types into a shared vocabulary that the Mamba backbone processes uniformly. This design collapses the multimodal EHR into a sequence-modeling problem without requiring separate encoders per modality, and it means the model sees temporal dependencies across modalities, for example the pattern of "creatinine rising, then ACE inhibitor dose reduced, then creatinine stabilizing", naturally, as a temporal sequence.

Irregular sampling is handled natively rather than by resampling. Because EHR data is inherently irregular (a lab is drawn when clinically indicated, not on a fixed schedule), the Mamba architecture's continuous-time state transitions model variable-length gaps between events without requiring a fixed grid. This is the same property that motivated the Neural CDEs and continuous-time SSMs of Chapter 13.5: a model defined on continuous time consumes the raw irregular stream and represents the patient's latent state as a function of elapsed time since the last event, not as a fixed-frequency vector. The triplet encoding of subsection one (value, mask, elapsed time) is the manual version of what EHRMamba learns to do automatically through its state-space dynamics.

The code sketch below shows the high-level interface pattern for loading EHRMamba, tokenizing a patient sequence, and fine-tuning on 30-day readmission with a small labeled set. This is a schematic representative of the 2025 API design rather than a verbatim runnable call, since the public release is under active development, but it illustrates the design contract: the model accepts raw event streams, not pre-engineered feature matrices, and the fine-tuning task is a small classification head on top of the frozen or lightly unfrozen backbone.

# Schematic: EHRMamba fine-tuning for 30-day readmission (illustrative API).
# Requires: pip install ehrmamba  (public release 2025)

from ehrmamba import EHRMambaModel, ClinicalTokenizer, ReadmissionHead
import torch

# Load pretrained backbone (MIMIC-IV pretraining checkpoint).
tokenizer = ClinicalTokenizer.from_pretrained("ehrmamba-base-mimic4")
model = EHRMambaModel.from_pretrained("ehrmamba-base-mimic4")

# A patient EHR as a list of (event_type, value, timestamp_hours) tuples.
# Events are heterogeneous: labs (numeric), meds (categorical), ICD codes, notes.
patient_events = [
    ("lab",  {"code": "CREAT", "value": 1.4, "unit": "mg/dL"}, 0.0),
    ("med",  {"code": "METOP", "dose": 25, "route": "PO"},      2.5),
    ("diag", {"icd10": "I10"},                                  48.0),
    ("lab",  {"code": "CREAT", "value": 1.6, "unit": "mg/dL"}, 72.3),
    # ... thousands more events spanning months or years
]

# Multi-modal tokenization: all event types into a shared token stream.
tokens = tokenizer(patient_events, return_tensors="pt")
# tokens: {input_ids, event_types, timestamps, attention_mask}

# Extract the patient's latent trajectory representation.
with torch.no_grad():
    hidden = model(**tokens).last_hidden_state   # (seq_len, d_model), O(L) in seq_len

# Fine-tuning: attach a readmission head, train on 500 labeled examples.
head = ReadmissionHead(d_model=model.config.d_model)
# Train head (and optionally unfreeze top Mamba layers) on labeled cohort.
# 500 labeled examples suffice due to the richness of the pretrained representation.
logit = head(hidden[:, -1, :])    # classify from the final event's hidden state
prob_readmit = torch.sigmoid(logit)
print(f"30-day readmission probability: {prob_readmit.item():.3f}")

The EHRMamba paradigm changes the deployment math for clinical AI in sites with limited labeled data. A hospital joining a federated network can pretrain on the shared backbone (or use a publicly released checkpoint) and fine-tune on its own labeled outcomes with far fewer examples than a from-scratch model requires. This aligns with the federated and privacy-preserving setting of subsection three: the pretrained weights encode clinical knowledge without encoding any individual patient's record, so sharing the backbone across sites does not violate privacy, while the fine-tuning step that encodes site-specific labeled outcomes remains local. The result is a natural two-stage federated protocol: share the foundation model, keep the task-specific head private.

One caution carries over from subsection two: next-event prediction is a correlational objective, and EHRMamba's representation is correlational even if its fine-tuned head generalizes well. Subsection two's distinction between a deterioration score and a treatment recommendation applies here: an EHR foundation model fine-tuned for readmission prediction is a risk stratifier, not a causal guide to intervention. The representation it learns may encode confounding by indication as faithfully as it encodes clinical biology, and the audits of subsection three (per-subgroup calibration, fairness across demographic groups) are as necessary for EHRMamba outputs as for any other clinical model. Scale buys better transfer; it does not buy causal identification or fairness by default. With those caveats in place, EHR foundation models represent the most significant shift in the clinical temporal modeling stack since the introduction of the Neural CDE, and the tools to evaluate them honestly are exactly the pipeline this section built in subsections one through five.

7. Exercises