🤖 AI

Separating Expert Retention from Autonomous Source Inference in Raw-ECG-Replay-Free Continual ECG Deployment

This paper proposes a replay-free continual learning framework for multi-source ECG deployment that separates expert retention from autonomous source inference by using a frozen backbone with an incremental expert bank and a lightweight router, demonstrating that while expert retention is highly effective, the inability to infer source identities without metadata remains the primary performance bottleneck.

Original authors: Yufan Lu, Xinhui Liu, Chenyang Xu, Yuxi Zhou, Hao Wang, Shenda Hong

Published 2026-07-03

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yufan Lu, Xinhui Liu, Chenyang Xu, Yuxi Zhou, Hao Wang, Shenda Hong

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are running a specialized medical clinic that sees patients from four different cities. Each city has its own unique way of recording heartbeats (ECGs) due to different machines, local populations, or recording habits.

Your goal is to build a single AI system that can accurately diagnose heart problems from any of these cities, but you face two major rules:

No Re-reading Old Files: You cannot keep the raw heart recordings from the past. Once you learn from a city, you must delete the raw data to save space and protect privacy.
No "Name Tags": When a new patient walks in, you don't know which city they are from. You just have their heartbeat.

This paper, titled "Separating Expert Retention from Autonomous Source Inference," tackles the challenge of building this clinic under those strict rules. Here is how they did it, explained simply.

The Core Problem: Two Different Jobs

The authors realized that solving this problem actually involves two very different tasks, which are often confused:

Keeping the Experts (Retention): Making sure the AI remembers how to diagnose City A, City B, City C, and City D without forgetting any of them.
Guessing the City (Inference): Figuring out which expert to call when a new patient arrives, without knowing their city.

The paper argues that while the first job is easy, the second job is the real bottleneck.

The Solution: The "Frozen Library" (IRFE-ECG)

The team built a system called IRFE-ECG. Think of it like a library with a very specific setup:

The Universal Translator (The Backbone): They used a pre-trained AI (called ECGFounder) that acts like a universal translator. It takes a raw heartbeat and turns it into a 1,024-number "fingerprint" (a feature vector). This translator is "frozen," meaning it never changes. It's the same for everyone.
The Specialized Doctors (The Experts): For each city, they hired a tiny, specialized doctor (a simple linear classifier).
- When City A arrives, they train a doctor for City A and then freeze them. They never touch that doctor again.
- When City B arrives, they hire a new doctor for City B and freeze them.
- Result: You now have a bank of four frozen doctors. Because they never interact, they don't "forget" their skills or interfere with each other. This solves the Retention problem perfectly.

The Tricky Part: The Receptionist (The Router)

Now, a patient walks in. You have their heartbeat fingerprint, but you don't know if they are from City A or City B. You need a Receptionist (a router) to look at the fingerprint and decide which doctor to call.

The Challenge: Since you deleted the raw data, you can't look at the original files to guess the city. You only have the "fingerprints" left in memory.
The Receptionist's Job: The team trained a small AI (an MLP router) to look at the fingerprints and guess the city.
- Option 1: The Receptionist picks one doctor (Top-1).
- Option 2: The Receptionist picks the top two most likely doctors and asks them to vote (Top-2 Fusion).

What They Found

The results were surprising and very clear:

The Doctors are Perfect (When you know the city): If you tell the system, "This patient is from City A," and you send them to the City A doctor, the system is incredibly accurate (about 79% correct). This proves that keeping separate, frozen experts works great.
The Receptionist is the Weak Link: When the system has to guess the city on its own (Autonomous mode), accuracy drops slightly (to about 77.8%).
- The gap between "knowing the city" and "guessing the city" is small but real.
- The team tried a "Top-2" strategy (asking two doctors to vote) to fix this. It helped a tiny bit, but not enough to close the gap completely.
The Main Conclusion: The problem isn't that the AI is forgetting old skills (the doctors are fine). The problem is that the Receptionist isn't good enough at guessing the city without help.

The Catch: It's Not "Memory-Free"

The title says "Raw-ECG-Replay-Free," which sounds like it uses zero memory. That's half-true.

They do not store the raw heart waveforms (the actual audio-like data).
However, they do store the "fingerprints" (the 1,024 numbers) of the training patients to teach the Receptionist.
So, it's not "memory-free," but it is much lighter than storing all the raw data.

Summary Analogy

Imagine you have four different cooking recipes (one for each city).

Old Way: You keep trying to mix all four recipes into one giant pot. Eventually, the flavors get muddy, and the dish tastes bad (this is "parameter interference").
This Paper's Way: You write down four separate, perfect recipes and lock them in a vault (Frozen Experts).
The Problem: When a customer orders a dish, you don't know which city they are from. You have a waiter (the Router) who has to guess which recipe to pull from the vault.
The Result: The recipes are perfect. The waiter is good, but not perfect. Sometimes the waiter picks the wrong recipe, or picks two and they don't agree perfectly. The paper concludes: Don't blame the recipes; fix the waiter.

Final Takeaway

The paper proves that in a world where you can't keep old data, you can keep separate "experts" for different data sources very effectively. The remaining challenge is simply building a better "guessing machine" to figure out which expert to use when you don't have the source information.

Technical Summary: Separating Expert Retention from Autonomous Source Inference in Raw-ECG-Replay-Free Continual ECG Deployment

1. Problem Statement

The paper addresses the challenge of deploying Electrocardiogram (ECG) systems in multi-source, continual learning environments where raw historical data cannot be retained or replayed due to data governance and sharing constraints. A critical distinction is made between two coupled but distinct problems:

Expert Retention: The ability to maintain source-specific decision boundaries for new domains without overwriting previous knowledge (parameter interference).
Autonomous Source Inference: The ability to correctly identify the source domain of a test ECG and select the appropriate expert when source metadata (e.g., hospital ID, device type) are unavailable at inference time.

The authors argue that while parameter isolation (freezing backbones and adding isolated heads) solves retention, it does not solve deployment if the system cannot autonomously route inputs to the correct expert. Treating source-aware performance as a complete solution obscures the primary failure mode in real-world, source-unknown scenarios.

2. Methodology: IRFE-ECG

The proposed framework, IRFE-ECG (Incremental Raw-Feature-Expert ECG), operates under a "raw-ECG-replay-free" protocol. It utilizes a frozen foundation model and an incremental expert bank.

Frozen Backbone: The system uses ECGFounder, a pretrained foundation model, as a fixed feature extractor. It maps single-lead ECGs to 1024-dimensional feature vectors ( $h$ ). The backbone parameters ( $\theta$ ) are never updated.
Incremental Expert Bank: As each new domain $t$ $t$ arrives, a new isolated linear expert $g_t$ $g_{t}$ is trained on the frozen features.
- Architecture: $g_t(h) = W_t h + b_t$ .
- Training: Experts are optimized using Balanced Softmax to handle class imbalance, with domain-specific decision thresholds ( $\tau_t$ ) calibrated on validation data.
- Isolation: Once trained, experts and the backbone are frozen; they are never updated for subsequent domains.
Autonomous Router: Since source IDs are unavailable at test time, a lightweight router is trained to infer the source domain.
- Memory: The router is trained on retained frozen feature vectors and domain labels from all previously seen domains. No raw ECG waveforms are stored or replayed.
- Architecture: A compact Multi-Layer Perceptron (MLP) with a 1024-dimensional input, LayerNorm, a 128-unit hidden layer, GELU activation, and dropout.
- Training: The router is re-fitted after each new domain is observed, using cross-entropy loss on the stored feature set.
Inference Strategy (Top-2 Margin Fusion): Instead of committing to a single "Top-1" expert, the system identifies the two most likely experts ( $K(h)$ ) based on router logits. It fuses their outputs using a validation-calibrated margin rule:
$m(h) = \sum_{k \in K(h)} \alpha_k(h) (p_k(h) - \tau_k)$
where $p_k$ is the predicted probability and $\tau_k$ is the domain-specific threshold. The final prediction is positive if $m(h) \geq 0$ .

3. Key Contributions

Problem Formulation: The paper explicitly decouples expert retention from autonomous source inference in the context of raw-data-free continual learning. It posits that retention is solvable via parameter isolation, but inference remains the bottleneck.
IRFE-ECG Framework: The authors instantiate this formulation using a frozen ECGFounder backbone, isolated Balanced-Softmax linear experts, and an autonomous MLP router trained on retained features.
Empirical Analysis of the Bottleneck: Through extensive evaluation on four ECG datasets (CPSC, PTB-XL, Georgia, Chapman-Shaoxing), the study demonstrates that the performance gap between source-aware oracle selection and autonomous routing is the primary limitation, not the forgetting of expert parameters.

4. Experimental Results

The experiments were conducted on four domains with three random seeds. Key findings include:

Source-Aware vs. Autonomous Performance:
- Source-Aware Oracle: Achieves 0.7915 ± 0.0036 Macro-F1. This performance is nearly identical to a matched offline independent-head reference (0.7885), confirming that sequential isolation effectively prevents parameter interference.
- Autonomous Routing (MLP): Achieves 0.7756 ± 0.0027 Macro-F1.
- Top-2 Margin Fusion: Achieves 0.7782 ± 0.0022 Macro-F1.
Significance of Gaps:
- The gain from Top-2 fusion over hard Top-1 routing is small (+0.0026) and statistically insignificant (95% CI includes zero).
- The gap between the autonomous Top-2 model and the source-aware oracle remains 0.0111–0.0133 across different domain orders.
Routing Accuracy: The MLP router achieves 81.5% route accuracy, significantly outperforming centroid, kNN, and linear classifiers, but still leaving a measurable error rate that impacts final Macro-F1.
Memory Trade-off: The system is not "memory-free" as it retains frozen feature vectors. However, retaining only 10% of training features reduces storage from ~140 MiB to ~14 MiB with only a 0.0063 drop in Macro-F1 compared to full memory.
Baseline Comparisons: Shared-parameter baselines (e.g., EWC, LwF, small replay) suffer from negative Backward Transfer (BWT) and lower final Macro-F1 (0.64–0.73) compared to the routed expert bank (0.7782).

5. Significance and Claims

The paper claims that autonomous source inference is the limiting factor for deploying isolated expert banks in source-unknown ECG scenarios, rather than the ability to retain expert parameters.

Modest Claims on Fusion: The Top-2 margin fusion is presented as a "modest operational refinement" rather than a breakthrough, as it does not statistically close the gap with hard routing.
Limitations Acknowledged:
- Patient-Level Leakage: The study uses waveform-hash grouping to prevent exact duplicate waveforms but cannot guarantee patient-level separation due to the lack of reliable patient identifiers in the processed splits. Results are record-level benchmarks, not clinical validations.
- Memory: The method is not memory-free; it requires storing frozen feature vectors for router updates.
- Scope: The findings are specific to binary normal/abnormal classification on single-lead ECGs and may not generalize directly to multi-label diagnosis or different data splits.
Conclusion: The system successfully separates expert retention from inference, proving that while experts can be preserved perfectly, the ability to autonomously route inputs to them without metadata remains the "main remaining bottleneck." Future work must focus on improving source inference and validating patient-level splits before claiming robust clinical deployment.