TL;DR
EEG2MCU is a "sensing-to-execution" co-design framework that enables high-performance EEG neural networks to run on tiny, resource-constrained microcontrollers. By optimizing everything from the number of electrodes to how data is streamed through memory, it slashes peak memory usage by over 11x and energy consumption by 2.5x while maintaining nearly full-montage accuracy.
What Problem Does This Paper Address?
Wearable EEG devices are essential for continuous health monitoring, seizure detection, and brain-computer interfaces. However, running modern AI models (like Transformers or advanced CNNs) on these devices is a nightmare for engineers.
The primary bottleneck isn't just the model's total size; it's the "front end." High-density EEG recordings use many electrodes (often 62), creating a massive, high-dimensional input. Before the "smart" part of the AI even starts, the device must generate and store a huge time-frequency representation of this data. As shown in the paper's analysis, this first layer can account for over 80% of the total computation and requires memory that far exceeds the SRAM available on standard microcontrollers (MCUs). This creates a "feasibility gateway": if the first layer doesn't fit in memory, the model simply cannot be deployed, no matter how much you compress the rest of the network.

Methods
The authors propose EEG2MCU, a framework that treats the entire pipeline—from the sensors to the silicon—as a single optimization problem. It operates across three levels:
- Sensing Level (Montage Co-design): Instead of using all 62 electrodes, the system uses a "saliency-guided" approach to select a subset (e.g., 19) that provides the most task-relevant information while maintaining spatial coverage across the scalp.
- Representation Level (Streamed Generation): Standard approaches pre-calculate a massive 3D tensor for the entire input window. EEG2MCU instead keeps a compact, low-resolution representation and only generates the high-resolution "tiles" needed for the current step of the neural network on-the-fly.
- Execution Level (Tiled & Locality-Aware): The first convolution layer is executed in small tiles to fit within SRAM. The system uses "halo reuse"—caching overlapping data between tiles—to avoid redundant calculations. It also strategically places data across different types of on-chip memory (Flash, SRAM, and DTCM) based on how frequently it's accessed.

Datasets
The framework was evaluated using the SEED dataset, a well-known benchmark for three-class emotion recognition. The models were trained on 62-electrode data and then evaluated on the optimized 19-electrode montages derived by the framework.
Key Insights and Ideas
- The "Feasibility Gateway": The authors highlight that backbone compression (making the middle of the AI smaller) is useless if the input layer is too big to load. You must optimize the "stem" of the model.
- Sensing as a Variable: Most AI research treats the input data as a fixed property. EEG2MCU argues that in hardware-constrained environments, the number of sensors is a design variable that should be tuned alongside the software.
- On-Demand Materialization: By fusing interpolation and quantization directly into the execution of the first layer, the system avoids ever having to store the full, high-resolution input tensor in memory.
- Universal Stem: Because most EEG models (CNNs, Transformers, Mamba) start with a similar convolutional "stem" to process electrodes, these optimizations are architecture-agnostic and can benefit a wide variety of model families.
Key Results
Testing on an ARM Cortex-M7 MCU (a common high-end microcontroller), the researchers achieved:
- 11.38× reduction in peak SRAM usage compared to the baseline.
- 2.57× reduction in latency and 2.48× reduction in energy consumption.
- 94–96% accuracy retention when moving from 62 electrodes down to the optimized 19-electrode montage.
- The system successfully fit models into a 1024 KiB SRAM budget that were previously completely undeployable.

Limitations and Future Work
While EEG2MCU solves the memory crisis, the first layer still consumes a disproportionate share of the execution time (roughly 67.6% of the total latency after optimization). The authors suggest that future work should focus on joint stem-backbone optimization to further reduce this computational burden. Additionally, while the framework supports "hub-assisted inference" (offloading heavy layers to a nearby phone or tablet), the current study focuses primarily on the on-device "front end" optimizations. Expanding the co-design to include the communication costs for distributed execution is a promising next step.
Summary updated