Beat-level vs record-level classification

"You asked me whether the patient has an arrhythmia. I answered by grading all eighty thousand of their heartbeats individually. We are both, technically, correct."

A Pedantic AI Agent

Two problems wearing the same electrodes

Beat-level classification treats the QRS complex as the atom. You detect each R-peak (Section 29.1), window a fixed span around it, and assign a morphology class. The field's reference taxonomy comes from the AAMI EC57 standard, which collapses the messy zoo of annotations in the MIT-BIH Arrhythmia Database into five superclasses: N (normal and bundle-branch beats), S (supraventricular ectopic), V (ventricular ectopic), F (fusion), and Q (unknown or paced). The output is a label per beat, so a single recording produces a long ribbon of predictions.

Record-level classification treats the whole strip as the atom. The label is a rhythm or diagnosis attached to the entire signal: the PhysioNet/CinC 2017 Challenge asked for one of four classes (normal, AFib, other rhythm, noisy) from a single short lead; PTB-XL and CPSC2018 ask for multi-label diagnostic statements over a full twelve-lead resting ECG. Here the model must integrate evidence across many beats, because the very definition of a rhythm, an irregular RR interval with no organized P-wave for AFib, only exists at the level of a beat sequence.

The distinction is not academic. Atrial fibrillation is invisible in any single beat; a run of three ventricular beats (a salvo) is invisible to a classifier that scores beats independently and forgets their neighbors. Conversely, a beat-level model that flags one premature ventricular contraction per hour is clinically boring, while a record-level model that says "frequent PVCs, more than 10 percent burden" changes management. What you can express is bounded by the unit you chose.

The label-granularity mismatch, and how to bridge it

The practical headache is that labels rarely arrive at the granularity you want. MIT-BIH is beat-annotated by cardiologists, an extraordinarily expensive resource; almost every large modern corpus (PTB-XL, hospital archives, wearable exports) is labeled only at the record level, because that is what a clinical report contains. So the common situation is: coarse labels, fine-grained ambition. You know the recording contains AFib somewhere, but not which beats.

This is exactly the setting of multiple-instance learning (MIL). Treat the record as a bag of beat instances. The bag carries a label; the instances do not. Under the standard MIL assumption, a bag is positive if at least one instance is positive. A classifier scores each beat, and an aggregation function pools those scores into a bag prediction. The aggregation you pick is the assumption you make about the disease:

A max (or noisy-OR) pool says "one bad beat condemns the record," which matches presence-detection tasks like "is there any ectopy here." A mean pool says "the record's label reflects the average beat," which matches burden-style questions but dilutes rare events into invisibility. A learned attention pool, \( z = \sum_i a_i h_i \) with weights \( a_i = \mathrm{softmax}(w^\top \tanh(V h_i)) \), lets the model decide which beats matter and, as a bonus, hands you \( a_i \) as a free localization heatmap over the strip. The following experiment makes the stakes of that choice concrete.

import numpy as np
rng = np.random.default_rng(0)

# 400 records, each a "bag" of 60 beats. A record is ABNORMAL if it contains
# at least one ectopic beat. Ectopy is RARE: ~2 percent of beats.
n_records, beats_per = 400, 60
beat_is_ectopic = rng.random((n_records, beats_per)) < 0.02
record_label = beat_is_ectopic.any(axis=1).astype(int)      # noisy-OR truth

# A per-beat detector emits a score; higher for true ectopic beats, but noisy.
score = rng.normal(0.2, 0.3, (n_records, beats_per))
score += 0.9 * beat_is_ectopic                              # weak, overlapping signal

def auc(y, s):                                              # rank-based AUC, no sklearn
    order = np.argsort(s); r = np.empty_like(order, float)
    r[order] = np.arange(len(s))
    pos, neg = y == 1, y == 0
    return (r[pos].mean() - r[neg].mean()) / len(s) + 0.5

mean_pool = score.mean(axis=1)                              # dilutes the rare beat
max_pool  = score.max(axis=1)                               # keeps the strongest beat
print(f"record AUC, mean pooling: {auc(record_label, mean_pool):.3f}")
print(f"record AUC, max  pooling: {auc(record_label, max_pool):.3f}")

Run it and the two AUCs diverge sharply: mean pooling drowns the single decisive beat, while max pooling surfaces it. The lesson generalizes past this toy. When the clinical target is "does this event ever occur," any averaging aggregator is structurally wrong no matter how good the per-beat detector is. When the target is "how much of this occurs," averaging is right and max is noisy. Match the pool to the question before you tune a single weight.

Two evaluations that must not be confused

Because there are two units, there are two ways to count errors, and reporting the wrong one is a classic way to publish an inflated number. Beat-level metrics tally true and false positives per heartbeat, then compute per-class sensitivity, positive predictive value, and F1. The AAMI EC57 protocol, followed by de Chazal's influential inter-patient split (train on records DS1, test on the disjoint patients in DS2), is the canonical harness here. Record-level metrics tally errors per recording, often as a macro-averaged multi-label F1 across diagnostic classes.

The trap is that a model can look brilliant at one granularity and useless at the other. Because normal beats vastly outnumber abnormal ones, a beat-level accuracy of 99 percent can coexist with missing half the patients who have any ectopy at all. Beat-level accuracy is dominated by the majority class; the clinically meaningful question is a record-level, per-patient one. Always report the metric at the granularity of the decision the system actually drives, and never let a favorable beat-count stand in for a patient-count you did not measure. When you do aggregate, the patient-disjoint discipline from Chapter 5 still governs: the split is on the person, whichever unit you score.

Choosing a granularity, and the middle path

The decision reduces to a few questions. Do you have beat annotations, or only record labels? Is the clinical target a morphology (a beat property) or a rhythm (a sequence property)? Does the downstream user need localization ("show me the abnormal beats") or just a verdict? Beat-level models excel when annotations exist and morphology is the target, and they give interpretable, time-stamped outputs that clinicians trust. Record-level models are unavoidable for rhythm diagnosis and scale to the cheap, abundant labels that real archives contain.

In practice the strongest systems refuse the binary and take the middle path: a shared encoder produces a beat-or-segment embedding, a sequence model (a temporal convolution or transformer, developed in Chapter 14 and Chapter 15) mixes information across neighbors, and a learned pool produces the record verdict while the attention weights recover beat-level evidence. You train with whatever labels you have (record-level supervision if that is all there is) and still read out where the model is looking. This is the architecture Section 29.5 builds toward.

What's Next

In Section 29.5, we turn the shared-encoder-plus-pooling sketch into real architectures: the deep convolutional and transformer models that dominate ECG benchmarks, and the emerging ECG foundation models that learn beat and segment representations once and then serve both beat-level and record-level tasks from the same embedding.