ZIPBrain: Can EEG Foundation Models Be Faster, Locally Deployable, but Accurate?

arXiv:2608.07033 · cs.AI · Submitted 2026-08-07 · Read on arXiv

Listen

Transcript

Introduction to the show: ident: Paper Radio. Generated commentary on the latest Artificial Intelligence papers.

Tom: Next we'll be talking about the paper "ZIPBrain: Can EEG Foundation Models Be Faster, Locally Deployable, but Accurate?".

Jane: The paper was written by Lingwei Li, Yirong Kan, Peng Chen, Xu Cao, Zheng Chen et al. from Nara Institute of Science and Technology and RIKEN Center for Computational Science and University of Illinois Urbana-Champaign and SANKEN, The University of Osaka.

Tom: Stay tuned as we take you through the paper and discuss its implications.

Paper summary: Tom: So we finally sat down with this paper, and honestly, it's been on my mind all week. The question it asks is so direct. Can EEG foundation models be faster, locally deployable, and still accurate?

Jane: My honest answer after reading it? Yes. The team built a token compression module called ZIPBrain, and it plugs into existing models without retraining.

Lu: Wait, truly no retraining?

Jane: Truly none. That's rare in this field. Most efficiency tricks ask you to re-train or fine-tune; this one just sits between the attention block and the feed-forward network.

Tom: Context helps here. EEG foundation models are the big trend in brain-computer interfaces and seizure detection. You pre-train one model on lots of brain data, then adapt it to specific jobs.

Meng: But they're expensive. Self-attention grows quadratically with sequence length. A long EEG recording easily turns into thousands of tokens, and that kills real-time monitoring on a small device.

Tom: That's the wall they hit.

Jane: Their answer is to reduce the token count before the Transformer chews through it. Like dropping redundant pixels in an image, but for brain signals.

Lu: The headline numbers are strong. Across their experiments they get 1.3 percent to 10.5 percent average improvement over existing compression baselines.

Meng: And speed?

Lu: Wall-clock inference drops 32.7 percent. With CUDA Graph optimization, it reaches 41.8 percent faster. That's a genuine difference on edge hardware.

Jane: The wildest part is accuracy retention. At roughly 80 percent token compression, they preserve 99.65 percent of downstream accuracy on TUAB and 97.14 percent on TUEV.

Meng: They even beat the uncompressed model on some settings. Removing tokens made the model better.

Tom: There's a reason that works. EEG has a famously bad signal-to-noise ratio. Genuine neural activity sits buried under muscle artifacts and background noise.

Jane: So most tokens are mostly noise. That's usually a curse.

Lu: The paper reframes it. Noise means redundancy, and redundancy means compressible.

Lalam: Stepping back, that reframing matters beyond benchmarks. Real-time clinical monitoring needs models that run on local hardware, not a server farm. If token compression gets us there, it rewrites what's deployable.

Tom: Exactly. That's the arc of the whole paper. Let's start at page one, where they set up the efficiency problem.

Page 1: Jane: Page one opens with the familiar story — LLM breakthroughs pushed attention-based architectures into brain-signal modeling. Transformers need discrete token sequences, so EEG recordings get sliced into patches and embedded into tokens.

Tom: And that's where the pain starts. Self-attention computes pairwise correlations across every token. Double the sequence length, and you roughly quadruple the computation.

Lu: For EEG that's brutal. A long recording or a high-density electrode cap easily yields several thousand tokens. That's the barrier real-time clinical monitoring hits.

Meng: The paper adds a clever observation. EEG has low signal-to-noise ratio, so a substantial portion of those tokens carries little task-relevant information. They're not informative; they're just there.

Jane: And the more tokens you have, the more you pay for that redundancy.

Tom: They also contrast two prior lines of research. One line samples patches earlier, during preprocessing. Another replaces the Transformer with state-space models entirely.

Lu: But neither compresses tokens inside the model. That's the gap ZIPBrain fills.

Meng: The teaser figure makes the case. At around 80 percent compression, they cut computational burden by 42.30 percent on TUAB and 42.36 percent on TUEV.

Jane: While keeping 99.65 percent of TUAB accuracy and 97.14 percent on TUEV.

Tom: And at 40 percent compression, there's a bonus. Accuracy improves 0.2 percent on TUAB. The compressed model actually beats the original.

Jane: That's the hook that made me keep reading.

Tom: Same. When does removing information improve a model?

Lu: Maybe when the information is mostly noise.

Tom: Precisely. And that's the central bet of the paper.

Lalam: There's also a deployment angle hiding in that figure. The diagram shows the model running on a server, then compressing tokens, then shipping to an edge device. That's the real-world workflow they're targeting — not just faster math, but moving computation to where the patient is.

Meng: Good point. The burden isn't only compute. It's memory, energy, and fitting the model on hardware that doesn't have a cooling tower.

Jane: Right. And that's why the next page matters. The authors say making this work is genuinely hard, and they list three specific challenges.

Page 2: Tom: Page two digs into why you can't just copy vision compression methods. The authors list three specific hurdles.

Jane: First, token selection. In images, you have obvious cues — a salient object pops out. In text, semantics guide you. EEG tokens carry no such explicit signal.

Lu: Second, identifying redundant tokens. The low SNR makes tokens redundant, not task-irrelevant. Many of them repeat the same noisy patterns. Quantifying that redundancy was basically unexplored.

Meng: Third, merging. If you naively average a redundant token with its target, you shrink feature magnitude. An averaged vector's norm is bounded by its largest constituent. Salient EEG signatures get flattened.

Jane: That's a subtle failure mode. Averaging feels harmless, but you're erasing the spikes that matter.

Tom: The related work traces the EEG model lineage — BIOT, LaBraM, EEGPT, CBraMod, and newer ones like CodeBrain and ST-EEGFormer. Each improved representations, but deployment stayed heavy.

Lu: On the compression side, vision researchers split into two camps. Importance-based methods like EViT score tokens and drop uninformative ones. Redundancy-based methods like ToMe and DART find duplicated tokens and merge them.

Meng: Those methods lean on image-specific assumptions. A bird in the corner outranks sky pixels. EEG doesn't give you that hierarchy.

Jane: The paper makes the point bluntly. Naively transferring vision-oriented strategies risks discarding critical neural information and degrading model capability.

Tom: The page closes with formal definitions. Token pooling, redundancy measurement, merging functions — three problems that map directly to their solution.

Lu: I like that they define the problem before selling the answer.

Meng: And the definitions reveal their priorities. Partition tokens into groups, measure redundancy, merge each group into one representative.

Jane: There's one more detail worth appreciating. They define the assignment as a binary matrix, where every token lands in exactly one group. That framing keeps the whole method clean and deterministic.

Tom: Which matters for clinical use. You want reproducibility, not random behavior.

Lu: The next page shows how those three problems become a concrete architecture. That's the fun part.

Page 3: Tom: Page three presents the module. ZIPBrain sits between the self-attention block and the feed-forward network. No retraining, no backbone surgery.

Jane: Step one is pivot selection. They rank tokens by L2 norm and keep the largest as pivots. Those anchors represent the collective information of the whole sequence.

Lu: The intuition is simple. High-norm tokens carry more energy. In low-SNR EEG, norm becomes a rough proxy for signal strength.

Meng: Step two scores every non-pivot token. The redundancy score is its cumulative cosine similarity to all pivots. If you point in the same direction as the anchors, you're probably repeating them.

Tom: Then they sort by that score. The top-r most redundant tokens go into the redundant set; the rest, including every pivot, stay in the unique set.

Jane: Step three is matching. Each redundant token gets paired with its most similar unique token. It's like assigning roommates based on compatibility.

Lu: Step four is the norm-preserving merge. They average the directions within each group, then rescale the result to the maximum norm present in the group.

Meng: That rescaling is the anti-flattening move. The merged token keeps the energy of its strongest member, so salient EEG features survive.

Jane: The whole pipeline is static-shape and training-free. That has huge implications for deployment tooling later.

Tom: I also noticed the design choice of inserting after attention. They're reusing the intermediate representations instead of recomputing anything.

Lu: Right. No extra encoder passes, no auxiliary networks. The overhead is tiny, and the module slots anywhere.

Meng: The diagram on this page is helpful too. Four steps, one clean flow: select pivots, score redundancy, match tokens, merge.

Jane: And because it doesn't care about the backbone, the same module can serve very different foundation models. We'll see that tested soon.

Lalam: There's something elegant about the norm-preserving trick. EEG signatures are often amplitude-coded — think sharp spikes in seizure activity. If merging shrinks amplitudes, you lose clinical meaning. Rescaling protects exactly that.

Tom: Good connection. The authors clearly thought about the signal, not just the math.

Jane: Before the results, page four goes deeper on the scoring math and one surprising design flexibility. Let's look.

Page 4: Jane: Page four is the math page, but it's not scary. The redundancy score is just the sum of cosine similarities between a token and all pivots.

Tom: Pivots get a hard-coded score of zero. That guarantees they survive compression — they're the anchors, so you never merge them away.

Lu: There's a neat efficiency trick. Instead of comparing each token to every pivot individually, they sum the pivot vectors first. One comparison per token. Linear time.

Meng: Matching follows the same cosine logic. Each redundant token points at its most similar unique token, and that pairing forms the merge groups.

Jane: The norm-preserving merge formula is elegant. You take the average direction of the group's vectors, then stretch it back up to the maximum constituent norm.

Tom: So the merged token keeps the group's dominant energy. That directly answers the feature attenuation problem from page two.

Lu: The last part of the page surprised me. ZIPBrain is representation-agnostic. You can run the whole pipeline on the post-attention output, or on the query, key, or value projections.

Meng: Why would that matter? Different representations emphasize different things. Keys and queries capture interaction structure; the post-attention output carries context.

Jane: The paper treats that as a modular choice. You search over which representation works best for each backbone and task.

Tom: That's a practical touch. One module, several knobs, and the hyperparameter optimization picks the right configuration.

Lu: It also hints at why the results later are so consistent. The module adapts to the model instead of forcing one behavior.

Meng: The appendix mentions the search space is huge — over three thousand candidate configurations. They tame it with a two-stage grid search.

Jane: Which keeps it reproducible. They fix the procedure deterministically, so results don't depend on random luck.

Tom: That level of rigor shows up again on page five. The experiments span four foundation models and five datasets.

Lu: I'm curious whether the wins hold across all of them. Let's see the numbers.

Page 5: Tom: Page five launches the experiments. They test on four EEG foundation models — LaBraM, EEGPT, BIOT, and TFM-Tokenizer. Different architectures, different pretraining strategies.

Jane: And five datasets. TUAB and EEGMAT are binary tasks. TUEV has six seizure types. ISRUC is sleep staging. EarEEG uses ear-centered electrodes.

Lu: The baselines are the heavy hitters from computer vision: ToMe, ToFU, EViT, and DART. ToMe does bipartite matching, ToFU merges tokens with norm preservation, EViT prunes by attention score, DART prunes duplicates.

Meng: Important detail — official checkpoints for the EEG models are mostly unavailable, so they fine-tune everything themselves. That keeps the comparison honest.

Tom: The metrics are task-appropriate too. AUROC for binary classification, Cohen's Kappa for the imbalanced multi-class sets. Kappa handles chance agreement well.

Jane: Table 1 is striking. Under maximum compression, ZIPBrain beats every baseline on almost every cell. The paper counts 16 top-1 results and 20 out of 20 top-2 finishes across twenty settings.

Lu: Not a single setting where it falls outside the top two. That consistency is more convincing than one big win.

Meng: Some baselines degrade hard under aggressive compression. EViT especially seems to lose its footing on EEG data.

Tom: Which reinforces the page-two argument. Vision compression methods don't transfer cleanly to brain signals. You need the redundancy-aware design.

Jane: I also noticed the compression schedule differs by model. BIOT and TFM compress at every layer, LaBraM at all twelve, EEGPT at every other layer.

Lu: Right — the number of removed tokens per reduction is tuned to the architecture. They're not forcing one recipe everywhere.

Meng: And the maximum compression is genuinely aggressive. We're talking about cutting most of the token stream.

Tom: That makes the accuracy retention even more impressive.

Jane: But one table isn't the whole story. Page six asks whether that holds at gentler compression ratios, and whether the method ever beats the uncompressed original.

Page 6: Jane: Page six runs the sweep. They compress at 20 percent, 40 percent, 60 percent, and 80 percent, on two model-dataset pairs.

Tom: ZIPBrain stays on top at every single ratio. That's the robustness story — most compression methods degrade as you squeeze harder.

Lu: The really interesting finding is the denoising effect. ZIPBrain sometimes beats the uncompressed original model.

Meng: Concrete example: BIOT on TUAB hits 0.8812 AUROC at 80 percent compression. The original model only gets 0.8782. Removing tokens improved the result.

Jane: On TUEV with LaBraM, they gain up to 2.21 percent in Kappa at 20 percent compression. The pooling acts like a filter, suppressing redundant noise.

Tom: Then comes the ablation study. They swap each component for a dumb version. Random grouping, random matching, simple averaging.

Lu: Random grouping barely hurts — less than a quarter percent on TUAB. Simple averaging costs a bit more.

Meng: But random matching is devastating. Kappa drops 3.47 percent on TUEV. On TUAB, AUROC falls 1.27 percent. Matching is the heart of the method.

Jane: That makes sense. If you pair a redundant token with the wrong roommate, the merged token becomes a confused mixture.

Tom: It also explains why naive averaging underperforms. You need both the right pairings and the norm-preserving merge.

Lu: The ablations also confirm each design choice pays off. The full module beats every simplified variant on both datasets.

Meng: One thing I appreciate — they report the drop relative to the original model, not just relative to the full method. That's transparent.

Jane: And it shows the components are doing real work, not just adding parameters.

Tom: Page seven pushes further with two more ablations. Pooling versus pruning, and what to do with pivots. Plus the deployment case study.

Lu: The deployment part is what I've been waiting for. Let's see it.

Page 7: Lu: Page seven starts with a head-to-head: pooling versus pruning. Pruning just throws the redundant tokens away. Pooling merges them into their matched partners.

Tom: On TUAB, the two are basically tied — within 0.10 percent. But on the harder datasets, pooling pulls ahead by 0.8 percent to 0.88 percent.

Meng: The standout is TUEV with LaBraM. Pooling beats pruning by 3.04 percent Cohen's Kappa. Discarded information still carries signal.

Jane: Then they ask a subtle question — should pivots themselves be treated as regular tokens? Their answer is no.

Tom: Preserving pivots as unique tokens lifts TUAB by 0.09 percent and TUEV by 1.47 percent. The high-norm tokens behave like attention sinks.

Lu: Attention sinks are those tokens that attract a ton of attention regardless of content. The heatmaps on page seven show vertical lines — consistent attention patterns across the sequence.

Meng: If you merge those anchors with other tokens, you dilute them and destabilize the attention pattern. Keeping them intact keeps the model stable.

Jane: The deployment case study is the payoff. They run LaBraM on a Jetson AGX Orin — a tiny edge computer — via ONNX Runtime.

Tom: Baseline inference takes 54.936 milliseconds. With ZIPBrain, that drops to 36.997 milliseconds. Add CUDA Graph, and it's under 32 milliseconds.

Lu: The profiling shows why. Kernel launch overhead and synchronization cost nearly vanish. Static shapes let CUDA Graph capture the whole pipeline.

Meng: That's a 41.8 percent speedup on hardware you could actually put in a clinic.

Jane: And it's not just about speed. The memory footprint shrinks too, which matters on devices with limited RAM.

Lalam: This is the moment the paper stops being theoretical. A foundation model running at 32 milliseconds on edge hardware — that's the difference between a research demo and a bedside tool.

Tom: Agreed. And the ablation story ties together nicely: pooling beats pruning, pivots deserve protection, and matching quality drives everything.

Jane: Let's wrap up with the conclusion and what this means for the field.

Conclusion: Tom: We've reached the conclusion, and the paper closes the loop. ZIPBrain is training-free, plug-and-play, and exploits the redundancy baked into low-SNR EEG signals.

Jane: The evidence spans four foundation models, five datasets, and compression ratios from 20 percent to 80 percent. No retraining, no architecture changes.

Lu: The core claim holds up. You can make EEG foundation models faster and locally deployable without sacrificing accuracy. Often, you gain a little.

Meng: The mechanism is worth remembering. Redundancy-based pooling beats pruning, matching matters more than anything, and the norm-preserving merge protects salient signal.

Jane: And the Jetson demo proves it's not just theory. A model running under 32 milliseconds on edge hardware is something a clinician could actually use.

Tom: The paper also points forward. Combining ZIPBrain with weight pruning and quantization could squeeze even more. And generative EEG models are a whole new frontier.

Lu: I'd love to see this tested on streaming, real-time seizure monitoring next. That's where the latency savings would be most visible.

Meng: There's a question about the matching stage's quadratic cost too. The authors flag it as a limitation — a future linear approximation could push this even further.

Lalam: Zooming out — this paper is part of a bigger shift. Foundation models in medicine only matter if they run where the patients are. Token compression is one bridge across that gap.

Jane: Well said. We'll be watching for what comes next from this group.

Tom: That's our time with this one. Thanks for listening, and we'll see you on the next paper.

Lingwei Li, Yirong Kan, Peng Chen, Xu Cao, Zheng Chen, Yasuhiko Nakashima

Nara Institute of Science and Technology · RIKEN Center for Computational Science · University of Illinois Urbana-Champaign · SANKEN, The University of Osaka

cs.AI

Submitted: 2026-08-07

Updated: 2026-08-10

Comments: 7 pages(14 pages including appendix), 5 figures

Code: https://github.com/ycq091044/BIOT

License: http://creativecommons.org/licenses/by/4.0/

Importance score: 63/100

The gist: The paper investigates "whether Electroencephalograph (EEG) foundation models (EFMs) can be made faster and locally deployable without sacrificing accuracy." The authors note that "EEG foundation

Key concepts

Token compression: Reducing the number of tokens (chunks of EEG data) processed by a Transformer model. ZIPBrain does this by selecting high-energy tokens as pivots, scoring others for redundancy, and merging redundant ones into a single representative token, cutting compute without retraining.
Norm-preserving merge: When merging tokens, ZIPBrain averages their directions but rescales the result to the maximum norm (magnitude) in the group. This prevents shrinking important EEG signal amplitudes, like seizure spikes, which would otherwise be flattened by simple averaging.
Signal-to-noise ratio (SNR): EEG data has low SNR, meaning most of the signal is noise. The paper reframes this as redundancy: many tokens carry little task-relevant information, so they can be compressed. This makes the model faster and sometimes even more accurate by removing noise.
Foundation models: Large pre-trained models like LaBraM, EEGPT, BIOT, and TFM-Tokenizer, which are trained on broad EEG data and then fine-tuned for specific tasks like seizure detection or sleep staging. ZIPBrain plugs into these models without retraining, making them more efficient for local deployment.

Terminology

Foundation Model — 39× in this paper · explained in 3 episodes
Redundancy — 39× in this paper · explained in 2 episodes
Foundation Models — 33× in this paper · explained in 7 episodes
Accuracy — 30× in this paper · explained in 1 episode
Transformer — 24× in this paper · explained in 2 episodes
AUROC — 21× in this paper · explained in 2 episodes
Pruning — 21× in this paper · explained in 4 episodes
AUC — 9× in this paper · explained in 2 episodes
Cosine Similarity — 8× in this paper · explained in 3 episodes
Aggregation — 7× in this paper · explained in 1 episode
Ablation — 6× in this paper · explained in 1 episode
Computational overhead — 5× in this paper · explained in 2 episodes
Quantization — 5× in this paper · explained in 12 episodes
Ablation study — 3× in this paper · explained in 1 episode
Benchmark — 3× in this paper · explained in 2 episodes
Core — 3× in this paper · explained in 2 episodes
Downstream Tasks — 3× in this paper · explained in 2 episodes
Fine-Tuning — 3× in this paper · explained in 5 episodes
Robustness — 3× in this paper · explained in 5 episodes
Ablation Studies — 2× in this paper · explained in 1 episode
Alignment — 2× in this paper · explained in 1 episode
Transformer Architecture — 2× in this paper · explained in 2 episodes
Adam — 1× in this paper · explained in 2 episodes
Clustering — 1× in this paper · explained in 2 episodes
Distillation — 1× in this paper · explained in 2 episodes
Edge Deployment — 1× in this paper · explained in 2 episodes
Hyperparameters — 1× in this paper · explained in 2 episodes
Knowledge Distillation — 1× in this paper · explained in 11 episodes
Large Language Models (LLMs) — 1× in this paper · explained in 6 episodes
Latent Representation — 1× in this paper · explained in 2 episodes
Latent Representations — 1× in this paper · explained in 3 episodes
Quantization-Aware Training — 1× in this paper · explained in 3 episodes
Signal-to-noise ratio (SNR) — 1× in this paper · explained in 2 episodes
Time Series Forecasting — 1× in this paper · explained in 3 episodes
Tokenization — 1× in this paper · explained in 2 episodes
Transformer Models — 1× in this paper · explained in 2 episodes
Two-Stage Optimization — 1× in this paper · explained in 2 episodes
Vision-language models — 1× in this paper · explained in 2 episodes

Summary

The paper investigates whether Electroencephalograph (EEG) foundation models (EFMs) can be made faster and locally deployable without sacrificing accuracy. The authors note that "EEG foundation models are a major trend, offering strong general-purpose representations. However, their computational burden grows quadratically with input length, hindering deployment on resource-constrained scenario, particularly for real-time clinical monitoring. The key insight motivating their approach is that EEG's low SNR further suggests many of these tokens are redundant and compressible with little accuracy cost."

The authors identify that Transformers, which are the backbones of LLMs, "require discrete token sequences as input. EEG signals are therefore segmented into patches, which are then embedded into tokens; self-attention operates over these tokens to capture dependencies across time and channels. The efficiency bottleneck arises because computing pairwise correlations across all tokens gives Transformers quadratic complexity in sequence length, both in computation and deployment. This burden is particularly acute for EEG, where long-duration or high-density recordings can easily yield token sequences of several thousand in length, restricting deployment in resource-constrained or real-time clinical monitoring scenarios."

The problem is compounded by the low signal-to-noise ratio intrinsic to EEG data: "genuine neural activity is often buried beneath physiological artifacts and background noise, so a substantial portion of the resulting tokens carries largely non-discriminative information rather than task-relevant signal."

The authors propose ZIPBrain, described as a plug-and-play, training-free token pooling framework for EEG foundation models that exploits the intrinsic redundancy of low-SNR EEG signals. ZIPBrain is seamlessly inserted between the self-attention module and the feed-forward network (FFN), enabling token compression without modifying the Transformer backbone.

The method consists of four sequential steps:

The pivots are chosen as the tokens with the largest l2-norms. The authors explain: Since pivots capture the core contextual information, a token's redundancy naturally corresponds to its alignment with these pivots. The number of pivots is controlled by a hyperparameter ratio ρ ∈ (0, 1].

The method evaluates the redundancy score si for each token xi by aggregating its similarities across all pivots, computed via cumulative cosine similarity between each token and the pivots. Tokens with the top-r redundancy scores are assigned to the redundant set Xr, while the remaining tokens are assigned to the unique set Xu. Notably, pivots are assigned a zero score to ensure their preservation during token compression.

For each redundant token, we match it with the most similar counterpart in unique set using cosine similarity: M(i) = arg max x̃i x̃Tj, ∀i ∈ Ir. This establishes groups consisting of a unique token plus its matched redundant tokens.

The merging mechanism "operates on the principle of norm preservation across all tokens within Gj. It first calculates the average direction of the cluster tokens and then scales this normalized vector by the maximum feature norm observed among the individual vectors in the set. This design ensures that the fused tokens maintain a feature energy consistent with the original latent distribution, thereby preserving the representational strength of critical EEG signatures throughout the compression sequence."

The method is representation-agnostic: ZIPBrain treats the representation space as a modular design choice — the three stages can be performed using either the post-attention representation X̂ or the Query, Key, and Value projections Q, K, V, with the optimal representation selected via hyperparameter optimization.

The paper identifies and addresses three major challenges:

Token Selection: EEG tokens carry no explicit visual or semantic cues. Unlike CV or NLP, there is no clear signal for which tokens matter most — addressed via the l2-norm-based pivot selection mechanism.
Redundant Token Identification: EEG signals have a low signal-to-noise ratio. Many tokens are therefore redundant, not task-irrelevant. Quantifying this redundancy remains largely unexplored — addressed via the explicit redundancy score based on accumulated cosine similarity to pivots.
Merging for Compression: Naively averaging redundant tokens with their target counterparts dampens feature magnitude. An averaged vector's norm is bounded by its constituents' maximum. This risks losing salient EEG signatures — addressed via the norm-preserving pooling operation.

The authors integrate ZIPBrain into four representative EEG foundation models spanning diverse architectures and pretraining objectives: LaBraM, EEGPT, BIOT, and TFM-Tokenizer. They compare against four CV token compression methods: ToMe (bipartite-matching token merging), ToFU (norm-preserving MLERP merging), EViT ([CLS]-attention-guided pruning), and DART (pivot-based duplicity pruning).

Experiments are conducted across five diverse EEG datasets: TUAB (binary normal-vs-abnormal classification), EEGMAT (binary resting-vs-arithmetic state classification), TUEV (6-class seizure type detection), ISRUC-Sleep (5-stage PSG sleep scoring), and EarEEG (6-class classification on sparse ear-centered electrodes). Metrics include AUROC for binary tasks and Cohen's Kappa for multi-class tasks, with PR-AUC, Weighted-F1, Accuracy, and Balanced Accuracy also reported.

Under maximum compression, ZIPBrain consistently outperforms all existing token reduction methods (EViT, ToMe, ToFu, and DART) across almost all settings, achieving 16 top-1 results and 20/20 top-2 results out of 20 settings compared to baselines. The paper reports 1.3%-10.5% average improvement over baselines.

Across compression ratios from 20% to 80%, "ZIPBrain consistently achieves the best performance. Even at an 80% compression ratio, where competing methods degrade substantially, ZIPBrain maintains stable accuracy, demonstrating strong robustness under aggressive token reduction."

ZIPBrain achieves reducing wall-clock inference time by 32.7% (up to 41.8% with CUDA Graph) compared to the original foundation model. Specifically, "ZIPBrain preserved 99.65% and 97.14% of LaBraM's downstream accuracy on TUAB and TUEV dataset at ∼80% compression ratio, with 42.30% and 42.36% reduction in computational burdens, and improved the accuracy by 0.2% at ∼40% compression ratio on TUAB." The deployment case study on Jetson AGX Orin shows baseline LaBraM takes 54.936 ms, while incorporating ZIPBrain reduces latency to 36.997 ms, and combining ZIPBrain with CUDA Graph further drops execution time to 31.975 ms.

The results "frequently surpass the uncompressed baseline (Original). On TUAB with BIOT, it achieves an AUROC of 0.8812 at an 80% compression ratio, exceeding the original model (0.8782). On TUEV with LaBraM, it improves Kappa by up to 2.21% at a 20% compression ratio. The authors suggest that token pooling may improve representation quality by suppressing redundant or task-irrelevant EEG signals."

The ablation study reveals that "replacing the proposed matching strategy results in the largest performance drop (−1.27% AUROC on TUAB and −3.47% Kappa on TUEV), indicating that accurate token matching is the most critical factor for effective token pooling."

Regarding pooling versus pruning, the study finds that preserving redundant information through token pooling is more effective than directly pruning tokens, especially on challenging datasets where pooling consistently outperforms pruning by 0.80%–0.88%, with the largest improvement of 3.04% Cohen's Kappa on TUEV using LaBraM.

Regarding pivot preservation, the study shows that preserving pivots yields better performance, improving AUROC by 0.09% on TUAB and Cohen's Kappa by 1.47% on TUEV. The authors offer a possible explanation: high-norm pivots behave similarly to attention sinks, serving as global structural anchors within the Transformer.

The overall complexity is O(Nd + r(N−r)d), where N is the number of input tokens, d the feature dimension, and r the number of removed tokens. The authors note: Because redundancy scoring and feature aggregation operate with linear complexity relative to the sequence length, the quadratic term in ZIPBrain originates solely from the target matching stage.

The paper concludes that ZIPBrain consistently preserves, and often improves, downstream performance while substantially reducing computational cost, suggesting that token compression is a practical solution for deploying large-scale EEG foundation models in resource-constrained and real-time clinical settings. Future work will explore combining ZIPBrain with complementary compression techniques, such as weight pruning and quantization, and extending token compression to generative EEG foundation models.

Improvements for AI systems

By adopting ZIPBrain’s training-free, plug-and-play token pooling, the AI system can be inserted into any pre-trained Transformer backbone without retraining, immediately reducing inference latency by 33–42% and computational load by up to 42% while preserving—and often improving—downstream accuracy.
By using l2-norm-based pivot selection, the system can automatically identify and preserve the most salient tokens (analogous to attention sinks), ensuring that critical contextual information remains intact even under aggressive sequence compression.
By applying cumulative cosine-similarity redundancy scoring against pivots, the system can quantify token redundancy in noisy, low-SNR inputs without needing labels or task-specific cues, allowing it to selectively compress uninformative tokens while retaining task-relevant signal.
By matching each redundant token to its most similar unique counterpart via cosine similarity, the system can maintain semantic alignment during pooling, which is the most critical factor for accuracy retention (−1.27% AUROC / −3.47% Kappa drop if replaced).
By using norm-preserving feature merging (scaling the average direction by the maximum norm among cluster tokens), the system avoids the feature-dampening effect of naive averaging, preserving the energy of strong EEG signatures and preventing loss of salient information during compression.
Because the pooling operates on post-attention representations or Q/K/V projections interchangeably, the system can be made representation-agnostic, enabling the same mechanism to work across diverse model families (LaBraM, EEGPT, BIOT, TFM-Tokenizer) and multiple tasks (binary classification, sleep staging, seizure detection, ear-EEG).
Through token pooling rather than pruning, the system can suppress redundant noise while retaining a soft ensemble of similar information, yielding a denoising effect that surpasses the uncompressed model—for instance, improving BIOT on TUAB from 0.8782 to 0.8812 AUROC at 80% compression, and boosting LaBraM Kappa by 2.21% at 20% compression.
By integrating with CUDA Graph acceleration, the system can reduce wall-clock execution time from 54.9 ms to 32.0 ms on edge hardware (Jetson AGX Orin), enabling real-time clinical EEG monitoring on resource-constrained devices.
By stacking with complementary techniques like weight pruning and quantization, the system can be further optimized for low-latency, high-throughput deployment, making it suitable for battery-powered wearables, bedside monitors, and portable diagnostic tools.
By retaining stable performance even at 80% token reduction (where competing methods degrade substantially), the system can process longer-duration or higher-density recordings—thousands of tokens—without quadratic cost, allowing analysis of entire EEG sessions rather than short windows.

Abstract

This work investigates whether Electroencephalograph (EEG) foundation models (EFMs) can be made faster and locally deployable without sacrificing accuracy. EEG foundation models are a major trend, offering strong general-purpose representations. However, their computational burden grows quadratically with input length, hindering deployment on resource-constrained scenario, particularly for real-time clinical monitoring. EEG's low SNR further suggests many of these tokens are redundant and compressible with little accuracy cost. We propose ZIPBrain, a novel redundancy-aware EEG token pooling module that leverages this low-SNR characteristic to reduce token count. Given a token sequence, ZIPBrain partitions tokens into redundant and unique groups, then merges each redundant token with its most similar counterpart in the unique group. Furthermore, ZIPBrain serves as a training-free, plug-and-play module that seamlessly integrates into standard Transformer encoders with negligible computational overhead. Extensive experiments across multiple EEG foundation models show ZIPBrain's strong versatility, achieving 1.3%-10.5% average improvement over baselines, while reducing wall-clock inference time by 32.7% (up to 41.8% with CUDA Graph) compared to the original EEG foundation models.