NanoCNN: Minority-Aware Neural Architecture Search for Edge Arrhythmia Classification

Abstract

Arrhythmia is a life-threatening cardiovascular disease if not detected early. While deep learning models have demonstrated strong performance in ECG-based arrhythmia classification, deploying these models on resource-constrained wearable devices remains challenging. In this paper, we present a quantization-compatible neural architecture search (NAS) framework that discovers ultra-compact minority-aware convolutional neural networks (CNN). We formulate NAS as a multi-objective optimization problem, jointly maximizing balanced accuracy and minority-classes recall while minimizing model size and computational complexity. Furthermore, we constrain our search space to INT8-compatible operations. We evaluated our framework on the MIT-BIH Arrhythmia Database. We discovered NanoCNN models for binary and multi-class classification tasks. The models trained without augmentation achieved 98.7% and 98.21% overall accuracies outperforming the state-of-the-art. The discovered models required 38.3 K and 51.5 K multiply-accumulate operations (MAC) per inference, enabling their deployment on ARM Cortex-M4 microcontrollers. With augmentation and other minority-aware interventions, our model attained 91.6% balanced accuracy. Our results validated the effectiveness of the adopted search and training techniques for arrhythmia screening and diagnosis.

1. Introduction

Approximately one-third of deaths worldwide are caused by cardiovascular diseases, which have become highly prevalent [1]. There are various cardiovascular diseases, including coronary artery disease, stroke, peripheral arterial disease, rheumatic heart disease, congenital heart disease, heart failure, and arrhythmia [2]. The latter happens when the electrical impulses that coordinate heartbeats become abnormal, which causes the heart to beat too fast, too slow, or irregularly. Early detection is very important, as the World Health Organization (WHO) reports that timely diagnosis and treatment of heart rhythm disorders can prevent a significant proportion of complications and improve arrhythmia management [1]. Current diagnostic methods, such as long-term electrocardiogram monitoring, Holter recording, and electrophysiological studies are time-consuming, resource-intensive, difficult to access in a timely manner, and require expert interpretation [3,4].

Recently, Artificial Intelligence (AI)-based diagnostic tools have emerged as promising alternatives. AI algorithms can predict or diagnose arrhythmia by learning patterns from electronic health records, Electrocardiogram (ECG) measurements, and demographic data [5,6]. Various AI models have been explored for the prediction, detection, diagnosis, and prognosis of arrhythmias. The primary challenges in developing AI models are model selection, feature engineering, and hyperparameter tuning. Automated Machine Learning (AutoML) frameworks were created to overcome these challenges. AutoML systems automate model selection, hyperparameter optimization, and pipeline preprocessing [7]. Frameworks like Auto-sklearn, H₂O AutoML, and PyCaret reached state-of-the-art performance with minimal coding effort [8]. Neural architecture search (NAS) can automate the design of neural networks; however, many existing approaches mainly optimize for accuracy or Floating-Point Operations per inference (FLOPs), yielding architectures that perform well in floating-point.

On the other hand, the Internet of Things (IoT) has reshaped remote patient monitoring [9]. Integrated IoT health systems consist of sensors, communication modules, and cloud-based analytics [10]. The wearable sensors capture ECG or photoplethysmogram signals, which are transmitted to cloud servers for analysis in cardiac applications. These architectures suffer from latency, connectivity-dependency, and privacy risks [11,12]. Edge computing as a solution allows data processing to be closer to the source. Incorporating intelligence into a device reduces network traffic and enables faster decision-making. However, embedding complex models into microcontrollers requires thoroughly developed compression and optimization pipelines [13,14]. Quantization reduces model size, computation, and energy consumption by converting high-precision parameters and activations into low-bit representations (e.g., INT8), yet not all floating-point architectures can be quantized. Recent surveys [15,16] reviewed major quantization techniques and highlighted their trade-offs in accuracy, efficiency, and hardware compatibility, as well as challenges such as accuracy degradation at very low bit-widths. The emergence of TinyML has enabled the execution of trained ML models on microcontrollers. TinyML models consume only a few milliwatts of energy and can provide real-time inference directly where data are generated. For the monitoring of arrhythmias, this means that a wearable sensor or a home-based IoT hub can analyze ECG and Phonocardiogram (PCG) patterns locally and alert clinicians without relying on cloud connectivity. However, TinyML development still needs specialized optimization, such as quantization, pruning, and model translation.

To address these challenges, we propose a quantization-compatible minority-aware neural architecture search framework that explicitly incorporates deployment constraints into the search process. We formulate the problem as a multi-objective optimization task that jointly maximizes predictive performance, measured with the balanced accuracy, while minimizing model size and computation complexity. Unlike standard NAS systems, our framework integrates a NAS in a constrained search space composed only of operations supported by microcontrollers. This prevents post-hoc conversion failures and naturally biases the search toward architectures suitable for microcontrollers. We evaluated the proposed framework on time-series ECG for arrhythmia detection and classification. Our assessment covered not only predictive overall accuracy but also per-class performance, deployment-critical metrics such as quantized model size, inference latency, and energy consumption.

Motivated by these considerations, this study pursues the following research questions:

• RQ1: Does constraining the NAS search space to quantization-compatible operations eliminate conversion failures and preserve classification performance after quantization?
• RQ2: Can a minority-aware function improve detection of rare but clinically significant arrhythmia classes compared to standard accuracy-based optimization?
• RQ3: What are the trade-offs between classification performance and hardware efficiency in NAS-discovered architectures for ECG arrhythmia detection?
• RQ4: Can NAS-discovered ultra-compact models achieve deployment-ready performance on microcontrollers for continuous ECG monitoring?

The remainder of this paper is organized as follows. Section 2 reviews prior work on arrhythmia detection and classification on edge devices, as well as prior work on NAS for arrhythmia detection and classification. Section 3 details the proposed framework and architectural components. Section 4 presents the experimental design, the results, and the comparison with SOTA. Section 5 discusses the findings, limitations and implications for healthcare in the IoT. Finally, Section 6 concludes with perspectives for future research in automated edge intelligence for cardiovascular monitoring.

2. Related Works

AI has been used in the prediction, detection, and diagnosis of arrhythmia. Earlier studies relied on classical machine-learning methods—Decision Trees, Random Forests, SVMs, and ensemble techniques. They were tested on public datasets such as MIT-BIH [17,18,19]. During the last decade, deep-learning techniques have become widely used for health signals and images. CNNs have been used to extract morphological patterns directly from ECG signals [20,21], while Recurrent Neural Networks (RNN) have been used to model the temporal structure of heart time sequence signals [22]. Transformer models have also appeared more recently, although their use in ECG tasks is still developing [23,24]. Hybrid models have been leveraged by mixing convolutional layers with some temporal mechanism to capture both local and long-range features [25]. In this section, we begin by presenting literature in the area of TinyML and heart arrhythmia disease. Then, we explore related works that have used AutoML and NAS in arrhythmia detection and classification.

2.1. Edge Intelligence in Healthcare

Wearable ECG technologies, like wrist-worn monitors, smart clothing, and patch-based devices, emerged to facilitate unobtrusive, real-time health monitoring [26,27,28,29]. These devices enable data collection under natural conditions. TinyML was applied in healthcare in various contexts. For example, [30] proposed the deployment of audio classification models on edge devices. The authors demonstrated that a custom-designed 2D CNN (FISC-Net) can classify heart, lung, and bowel sounds from mel-spectrograms with 99% accuracy and 0.05 s per sample latency, outperforming larger pre-trained models like MobileNet and EfficientNet in this specific task.

Kim et al. [31] introduced TinyCES, a wearable ECG monitoring system that performs arrhythmia detection on a low-power microcontroller. They combined band-pass filtering and R-peak detection with a CNN-based classifier. Their model was trained, with a random split, and validated using two clinical ECG databases—MIT-BIH Arrhythmia and PTB Diagnostic ECG. TinyCES, with a 27 KB size, achieved about 97% classification accuracy and 95% sensitivity. Krasteva et al., in [32], proposed a deep neural network-based edge deployment for the detection of ventricular fibrillation. They applied an inter-patient split where training, validation, and testing were performed on different groups of patients. They suggested a five-layer CNN trained in TensorFlow on a GPU, then converted to TensorFlow Lite Runtime (LiteRT) and optimized through post-training quantization. Their 20 KB model achieved 98.55% sensitivity on a proprietary clinical ECG database. Furthermore, for real-time ventricular arrhythmia detection, Gautam et al., in [33], proposed a lightweight 1D CNN within implantable cardioverter defibrillators using TinyML principles. The model was composed of two convolutional and two fully connected layers with optimized kernel and stride parameters. They trained it on Intracardiac Electrogram data from the TinyML Design Contest datasets with a patient-wise split. The system incorporated two augmentation strategies—Peak Flip and Random Noise—to enhance generalization. Their model achieved a size of 17.33 KB, 11.51 K MAC, and 95.72% accuracy.

Other authors investigated the arrhythmia classification on edge devices. Hizem et al., in [34], presented a TinyML-based approach for real-time arrhythmia classification using a 2-D CNN model optimized for Raspberry Pi edge devices. They applied band-pass filtering, normalization, segmentation, SMOTE data augmentation, and random sampling to the ECG signals from the MIT-BIH Arrhythmia dataset before training their CNN on the ECG spectrograms. Their model experienced high degradation after pruning and quantization. It achieved 99% accuracy pre-optimization and 92.89% accuracy with 96.01% recall after optimization. Their main disadvantage is the extensive pre-processing that was not tested on limited-resource devices, as well as the high complexity. Also, they did not report their per-class metrics. In contrast, Han et al. [35] presented a lightweight deep learning model for the classification of arrhythmias. Using their NIH-funded Pulsewatch dataset with 116,313 labeled PPG segments from 106 stroke-survivor participants, the authors trained a 1D bidirectional Gated Recurrent Unit (1D-Bi-GRU) model that integrates multimodal inputs. Their proposed model achieved 97.31% accuracy for atrial fibrillation. Although the model showed slightly lower sensitivity due to motion artifacts, it demonstrated strong generalizability and computational efficiency. In [36], Cinotti et al. presented a 1D-CNN implemented for the ARM Cortex-M7 microcontroller. In their preprocessing phase, they applied arrhythmia filtering, outlier removal, fixed-length RR sequence extraction, and balancing. They applied subject-wise 5-fold cross-validation. The model achieved 98% accuracy, Recall, and F1-score, while requiring 86.6 KB of flash memory and 8.5 KB of peak RAM. They used two convolutional blocks: the first with 16 filters, and the second with 32 filters. Each block included batch normalization, ReLU, average pooling, and dropout in the first block only. We report the comparison between the proposed models’ performance in Table 1.

Table 1. Comparison of Edge Intelligence Methods for Arrhythmia Classification.

Work	Multiclass/ Binary	Dataset	Reported Performance	Hardware Performance	Limitation
Kim et al. [31]		MIT-BIH	Accuracy (PTB): 97%		No NAS
(TinyCES)	Binary	PTB Diagnostic ECG	Sensitivity (PTB): 95%	Size: 27 KB	Random Split
Krasteva et al. [32]	Binary	Proprietary clinical ECG	Sensitivity: 98.55%	Size: 20 KB	Proprietary clinical database
				Latency: 0.6 s
				Energy: 585 mJ
Gautam et al. [33]	Binary	TDC Dataset (IEGMs)	F1 score: 98.33%	Size: 17.33 KB	No quantization
			Accuracy: 95.72%	MACs: 11.51 K	Designed for ICD deployment
			Precision: 99.14%
Hizem et al. [34]	Multiclass	MIT-BIH	Accuracy: 92.89%	Size: 193 KB	- Accuracy drop after optimization
					- Random-sampling
			Recall: 92.89%	Power: 0.24 μW	- Extensive Preprocessing
			F1-Score: 93.96%	Latency: 0.192 ms	- High Complexity
Cinotti et al. [36]	Binary	MIT-BIH	Accuracy: 98%	Size: 86.6 KB	- Extensive Preprocessing
			Recall: 98%	RAM: 8.5 KB
			F1-score: 98%

2.2. AutoML and NAS for Arrhythmia Detection and Classification

Previous studies relied on manual experimentation for selecting the architecture, tuning hyperparameters, and deciding the preprocessing steps. This process was time-consuming and requires expertise with both ECG data and machine learning or deep learning models [37,38]. However, Automated Machine Learning (AutoML) approaches combine meta-learning and optimization to automate model selection and hyperparameter tuning.

AutoML has begun to reshape healthcare analytics by taking over many of the time-consuming tasks, such as data cleaning, feature engineering, selecting the right model, and tuning hyperparameters [39]. Different AutoML frameworks have been used in the medical domain for various types of data [40]. H₂O AutoML, for example, provides a unified environment that can handle tabular data, images, and even large electronic health records [41]. PyCaret has been useful in disease-prediction studies because it allows quick model comparison and ensembling, and it includes interpretability tools like SHAP values [42]. AutoGluon provides the ability to prototype models quickly [43]. AutoKeras, an open-source deep-learning framework, is often used for automated neural architecture search [44]. Other specialized frameworks, such as AutoPrognosis and AutoML-Med [45], are tailored for clinical prognosis and personalized screening, integrating specific Bayesian optimization and calibration techniques for healthcare workflows.

Jayanthi et al. [46] presented a systematic approach that combines Auto-CardiacML’s classification with ResNet-50’s feature extraction techniques. Auto-ML was used to classify cardiac arrhythmias, and the ResNet model is used to extract the features of the ECG signal. They showed, based on experimental results from the CPSC 2018 test set, that their model had an average accuracy of 82% for distinguishing normal rhythm from cardiac arrhythmias. Paladino et al. [47] evaluated three AutoML tools—PyCaret, AutoGluon, and AutoKeras—for heart disease prediction against traditional machine learning methods. They found that AutoML tools significantly outperformed manually developed models on the Cleveland, Hungarian, and a combined dataset. AutoGluon emerged as the top performer, delivering an accuracy between 78% and 86%. PyCaret’s results were more variable (65–83%), while AutoKeras showed the highest fluctuation (54–83%) and the longest computation times.

Reiser et al. [48] presented a framework for designing ultra-low-power neural networks for embedded time series classification, such as atrial fibrillation detection in ECG signals. They proposed a hardware-aware NAS that co-optimizes network accuracy and energy consumption using a grid-based search strategy within a constrained space limited to layers like convolutions and fully-connected networks. They used a non-volatile RRAM-based memory system enabling deep sleep without weight reloading, and a dataflow-driven hardware architecture automatically generated from the neural network description. Evaluated on a proprietary dataset of 16,000 two-minute ECG recordings, their final ASIC implementation achieved 97% sensitivity and 87% specificity. Their final model comprised four convolutional layers with increasing capacity, each followed by batch normalization and ReLU activation, and a max-pooling layer after the final convolution. Two ternary-quantized fully connected layers perform classification. The resulting model contains only 1370 parameters. The average energy consumption per window classification is 12.4 mJ. A primary limitation is the framework’s reliance on a proprietary ECG dataset and a specific RRAM process technology, which hinders full reproducibility and independent validation of the results.

King et al. [49] proposed MicroNAS, a hardware-aware neural architecture search framework for time-series classification on microcontrollers that automatically discovers CNN architectures balancing accuracy with strict memory and latency constraints. Weight sharing is used during architecture search. Therefore, the selected architecture is retrained using quantization-aware training for INT8 MCU deployment. Using a differentiable search approach with hardware-measured latency tables and memory estimates, it achieves 97.35% FP32 accuracy and 96.33% INT8 accuracy, on the UCI-HAR balanced dataset, with less than 30 KB memory, and 2–200 ms latency. However, it was evaluated on only two HAR datasets and the authors did not report final model size.

Risso et al. [50] introduced Pruning-In-Time (PIT), a lightweight neural architecture search method tailored for temporal convolutional networks on edge devices. Their framework optimized three key hyperparameters—channels, receptive field, and dilation—through differentiable structured pruning masks that allows exploring a large, fine-grained search space while training a single TCN. PIT generates Pareto-optimal architectures by balancing accuracy with model size or operation count using two regularizers, and is evaluated on four real-world time-series tasks: PPG heart-rate estimation, ECG arrhythmia classification, sEMG gesture recognition, and keyword spotting. Their ECG optimal model uses three residual blocks, each with two dilated convolutions and geometrically increasing dilations. After a reduced fully connected layer, the optimized network classifies 5 arrhythmia types. They reported 94.13% overall accuracy on both FP32 and INT8 with a 5.4 KB size after training on the ECG5000 dataset. They did not report per-class performance nor overall recall. Challenges include designing valid masks for the receptive field and dilation, dependence on a good seed model, and limited dilation choices. Nevertheless, PIT is limited to a fixed macro-architecture and requires manual tuning of the regularization strength to obtain the Pareto-optimal solutions.

Hosseini et al. [51] introduced QS-NAS, a hardware-aware neural architecture search framework that jointly optimizes network scaling, block structure, and mixed-precision quantization to generate models for microcontrollers and TinyML devices. Instead of manually designing small networks or applying uniform 8-bit quantization, QS-NAS uses a predictive hardware cost model—capturing RAM, Flash, latency, and energy—to guide the search toward architectures that satisfy tight device constraints while preserving accuracy. Evaluated on micro-AI tasks such as keyword spotting and small-image classification, QS-NAS consistently produced models that outperform hand-crafted TinyML baselines, achieving higher accuracy with smaller memory footprints and lower latency. The approach demonstrated that co-optimizing scaling and quantization within the search loop is essential for reliable TinyML deployment. However, QS-NAS was not tested on arrhythmia datasets.

Huang et al. [52] proposed an energy-aware NAS framework for wearable IoT devices by co-optimizing lightweight DNN architectures and computation partitioning between the wearable and a fog node. They used a genetic algorithm, evolving flexible layer lengths and channel counts under strict Flash, RAM, and energy constraints. Unlike typical TinyML approaches, the method operates without quantization and focuses on single-objective constrained optimization, where architectures violating resource limits are penalized or discarded. For arrhythmia classification on the MIT-BIH dataset, the framework achieved 88.0% accuracy with 0.270 mJ edge energy consumption while maintaining Flash footprints as low as 4.0 KB and RAM under 8.1 KB. Nevertheless, the approach relied on the availability of a fog node, overlooking real-time on-device adaptation and 8-bit quantization.

Islam et al. [53] proposed a novel method that combines Lottery Ticket Hypothesis pruning with Neural Architecture Search (LTH-aided NAS) to automatically generate ultra-small, accurate deep learning models for deployment on microcontrollers. Using the PhysioNet 2017 ECG dataset for arrhythmia detection and a chest X-ray pneumonia dataset, the approach first prunes a large pre-trained model to create a sparse “student model,” which then constrains and accelerates the multi-objective NAS search—optimizing for accuracy, model size, and compute cost. The key novelty is “warm-booting” NAS with pruning knowledge, reducing search time while compressing the ECG model to 174 KB with maintained accuracy. A major limitation is the reliance on an existing large pre-trained model, which may not be available for all tasks, and the method does not include quantization, leaving further size and latency reductions unexplored. Additionally, sparse models are converted to dense format for MCU compatibility, as current lightweight inference engines lack efficient sparse kernel support.

TinyTNAS, proposed by Saha et al. [54], is a CPU-only, time-bound NAS framework that uses a grid search to find 1D CNNs for TinyML time-series classification. It searches over two parameters: the number of filters in the first depthwise separable convolution layer and the number of repeating blocks containing MaxPooling and convolution. They employed a constrained single-objective search that maximizes accuracy within user-defined hard limits on RAM, Flash, and MAC operations. Their quantization aware training achieved 97.4% overall accuracy on MIT-BIH arrhythmia, 13 ms latency on ESP32 microcontroller, while their model size reached 19.3 KB. However, they used a fixed architecture template, did not explore trade-offs via multi-objective optimization, and did not consider per-class nor weighted performances.

Ben Meziane et al. [55] showed that NAS for arrhythmia is an active area with a clear shift toward energy-efficient, hardware-aware automatic design. The gap between automated model generation and deployable efficiency motivates the paradigm proposed in this work.

Table 2 shows the comparison of NAS methods for the classification of arrhythmias on resource-limited devices.

Table 2. Comparison of NAS Methods for Arrhythmia Classification.

Work	Search Technique	Search Space	Task & Dataset	Performance & Hardware	Limitations
Reiser et al. [48]	Reinforcement Learning	Layer-wise (CNN)	Binary	Recall: 97%	Proprietary dataset
			Proprietary dataset	Precision: 87%	RRAM-specific
				Energy: 12.4 mJ
King et al. [49] (MicroNAS)	Differentiable NAS (DNAS)	Two-stage cells	Multiclass	Accuracy: 96.33%
			UCI-HAR (balanced)	Size: <30 kB	Did not report final model size
Risso et al. [50]	Manual design	Fixed architecture (no search)	Multiclass	Overall accuracy: 94.13%
			ECG5000	Size: 5.4 KB	No per-class metrics, fixed architecture
Hosseini et al. [51] (QS-NAS)	Regression + optimization	Quantization + Width multiplier	Not specified	Outperforms hand-crafted baselines	Optimizes RAM, Flash, latency, energy
			Not tested on ECG		Not tested on ECG
Huang et al. [52]	Not specified	Fixed architecture	Multiclass	Overall accuracy: 88.0%	Requires fog node, no quantization
			MIT-BIH	Flash: 4.0 KB
				RAM: 8.1 KB
Islam et al. [53] (LTH-aided NAS)	RL + LTH pruning	RL over layers (reduced via LTH)	Binary	Accuracy maintained	Needs pre-trained model
			PhysioNet 2017	Size: 174 KB	No quantization
Saha et al. [54] (TinyTNAS)	Intelligent grid search	Fixed template with k filters and c blocks	Multiclass	Overall accuracy: 97.4%	Limitation: Fixed template, no multi-objective
			MIT-BIH	Size: 19.3 KB

3. Methodology

This section presents our ultra-compact minority-aware neural architecture search approach for designing microcontroller-compatible and optimized CNNs for arrhythmia classification. We propose a framework that aims to create an end-to-end automated process. The framework consists of four integrated modules operating iteratively, Figure 1.

Figure 1. NAS-to-TinyML framework architecture diagram.

• Data Pre-processing Module: This module handles ECG signal preparation.
• Neural Architecture Search Module: Generates candidate architectures via random sampling from a constrained search space and trains each.
• Quantization Module: Converts the trained models to INT8 precision using post-training quantization.
• Scoring Module: This module evaluates each architecture using a multi-objective score that balances classification performance and hardware efficiency.
• Deployment Simulation Module: Simulates edge deployment using hardware profiling. It is responsible for extracting the memory footprint (RAM, Flash), computational complexity (MACs), while evaluating INT8 classification performance.

Our framework introduces two key innovations that distinguish it from existing hardware-aware NAS approaches. First, unlike MicroNAS [49] and TinyTNAS [54], which optimize primarily for overall accuracy, we formulate NAS as a multi-objective optimization problem that explicitly incorporates minority class recall alongside balanced accuracy in the search objective. This minority-aware scoring function directly addresses the clinical challenge of detecting rare but critical arrhythmias, which existing frameworks do not prioritize during architecture search. Second, while QS-NAS [51] explores mixed-precision quantization post-search, our search space is constrained from the beginning to low-precision compatible operations.

Our proposed NAS framework is designed to identify CNN architectures that exhibit high classification performance, are quantization-compatible, and are deployable on resource-constrained microcontrollers for continuous ECG monitoring. Unlike conventional neural architecture search methods that optimize only classification accuracy, our NAS incorporates balanced accuracy (macro-recall) and deployment metrics such as runtime memory footprint, persistent storage requirement, and computational complexity, directly into the multi-objective score function. The search operates iteratively across candidate architectures. The NAS Module generates and trains a random architecture, applies post-training quantization, and then transfers the quantized model to the Microcontroller Module for hardware profiling and performance evaluation. The framework computes the composite score combining balanced accuracy, average minority recall, and hardware efficiency. Then, we select the architecture with the highest composite score as the optimal architecture.

3.1. Data Preprocessing Module

We applied the preprocessing methodology of Kachuee et al. [56] prior to neural architecture search. Kachuee et al. demonstrated that minimal preprocessing consisting only of normalization enables deep learning models to learn robust features directly from the raw signal [56]. Consequently, our preprocessing consists of a single normalization step applied independently to each heartbeat segment. For each ECG segment $\mathbf{x}$ of length L samples, we apply min-max normalization Equation (1):

$$\tilde{x}\left(t\right)={\displaystyle \frac{x\left(t\right)-min\left(\mathbf{x}\right)}{max\left(\mathbf{x}\right)-min\left(\mathbf{x}\right)}}$$

(1)

where $x\left(t\right)$ is the heartbeat value at instant t, $min\left(\mathbf{x}\right)$ and $max\left(\mathbf{x}\right)$ represent the minimum and maximum amplitude values within the segment, respectively. We selected the Kachuee et al. [56] preprocessing approach to avoid removing diagnostically relevant information through filtering, as this may impact minority arrhythmia classes with atypical morphologies [57]. Furthermore, normalization only preprocessing reduces preprocessing complexity, which is critical for resource-constrained edge devices.

3.2. Neural Architecture Search Module

The NAS module randomly selects an architecture from the search space and trains it. In our work, we defined a constrained neural architecture search space $\mathcal{S}$ containing only operations compatible with full 8-bit quantization for microcontrollers. Several architectural and parameter conditions may cause the quantization pipeline to fail in neural networks [58,59]. To guarantee quantization compatibility, we considered these design principles: batch normalization after convolution [60], ReLU activations [61], no biases in convolutional layers [61], adaptive pooling, and exclusion of operations that cause quantization instability, such as depthwise separable convolutions and residual connections [49]. We used random search because the search space is constrained and quantization-aware, and each candidate is evaluated by a short proxy training and a composite score. Under these conditions, random search provides effective coverage with minimal overhead, and prior studies reported that random search is a competitive NAS baseline compared to state-of-the-art methods when the search space is carefully engineered [62]. Candidate architectures are represented by a five-parameter configuration vector

$$\mathbf{c}=[n_b,k,p,d_u,\delta ]\in \mathcal{S},$$

where $n_b$ is the number of convolutional blocks, k the kernel size, p the pooling stride, $d_u$ the dense units, and $\delta$ the dropout rate.

Given a configuration $\mathbf{c}$, the architecture $\mathcal{A}\left(\mathbf{c}\right)$ is constructed sequentially. Each convolutional block applies two 1D standard convolutional layers with ReLU activations. To prevent excessive reduction in sequence length across convolutional stages, we employ adaptive pooling where the pooling size $p_i$ depends on the current length $L_{i-1}$ after block i, as in Equations (2) and (3).

$$p_i=\left\{\begin{array}{cc}p\hfill & \mathrm{if}{L}_{i-1}\ge 2p,\hfill \\ 2\hfill & \mathrm{if}4<L_{i-1}<2p,\hfill \\ \mathrm{None}\hfill & \mathrm{if}{L}_{i-1}\le 4,\hfill \end{array}\right.$$

(2)

with the corresponding length update:

$$L_i=\left\{\begin{array}{cc}\lfloor L_{i-1}/p_i\rfloor \hfill & \mathrm{if}{p}_i\ne \mathrm{None},\hfill \\ L_{i-1}\hfill & \mathrm{otherwise}.\hfill \end{array}\right.$$

(3)

Following the convolutional blocks, the network employs a compact classifier head consisting of a flattened layer, a fully connected layer with ReLU activation, dropout regularization, and a softmax output layer. Then, we train the randomly selected CNN on a subset of the dataset for a limited number of epochs.

3.3. Deployment Simulation Module

In this module, we converted the trained model to low-precision integer formats through post-training quantization [61], where a representative calibration dataset determines optimal quantization parameters that map floating-point weights and activations to fixed-point integers. For deployment on resource-constrained devices, we quantized the model to 8-bit integer weights and activations to reduce memory footprint and computational cost while retaining acceptable predictive accuracy [61]. Quantization maps floating-point model weight, $w_f$, to an integer representation $w_q\in {\mathbb{Z}}_n$ using a scaling factor S and zero-point offset Z, defined as in Equation (4).

$$w_q=\mathrm{round}\left({\displaystyle \frac{w_f}{S}}\right)+Z,$$

(4)

where $S={\displaystyle \frac{w_f^{\max }-w_f^{\min }}{2^n-1}}$ ensures that the integer values span the same dynamic range as the original floating-point weights. The quantized models are profiled using platform-specific tools that provide deterministic estimates of flash storage, runtime RAM, and MAC operations. This profiling approach enables evaluation of hardware requirements without physical deployment. The profiler extracts the required flash memory size, the runtime RAM, and Multiply-Accumulate Operations (MACs) per inference.

3.4. Minority-Aware Composite Scoring Module

A fundamental challenge in medical time-series classification is severe class imbalance, where clinically significant rare events may represent a small fraction of the training data. Traditional neural architecture search approaches that optimize aggregate metrics without explicit minority class consideration produced models that achieved high overall scores by predominantly learning majority class patterns while exhibiting poor sensitivity to rare but medically important classes [63].

We formulated our NAS as a constrained multi-objective optimization problem that balances classification performance, taking into consideration the minority classes detection against hardware resource limitations. Our objective was to identify the optimal architecture $A^{*}\in \mathcal{S}$ that maximizes a minority-aware composite score function while satisfying platform-specific resource constraints, as in Equations (5)–(8).

$$A^{*}=arg\underset{A\in \mathcal{S}}{max}\mathcal{F}(A,\mathcal{D})$$

(5)

subject to the hardware feasibility constraints:

$$\begin{array}{cc}\hfill \mathrm{RAM}\left(A\right)& \le {\theta }_{\mathrm{RAM}},\hfill \end{array}$$

(6)

$$\begin{array}{cc}\hfill \mathrm{Flash}\left(A\right)& \le {\theta }_{\mathrm{Flash}},\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill \mathrm{MACs}\left(A\right)& \le {\theta }_{\mathrm{MACs}},\hfill \end{array}$$

(8)

where $\mathcal{S}$ denotes the constrained search space and $\mathcal{D}$ represents a subset of the dataset. $\mathrm{RAM}\left(A\right)$, $\mathrm{Flash}\left(A\right)$, and $\mathrm{MACs}\left(A\right)$ denote the runtime memory footprint, persistent storage requirement, and computational complexity of architecture A, respectively. The threshold parameters ${\theta }_{\mathrm{RAM}}$, ${\theta }_{\mathrm{Flash}}$, and ${\theta }_{\mathrm{MACs}}$ define the resource constraints of the target deployment platform and are selected similarly to Saha et al. [54] (TinyTNAS).

We proposed a minority-aware composite score function that treats minority class detection as an objective alongside overall classification quality and hardware efficiency. The composite score function $\mathcal{F}$ aggregates three normalized objectives via a weighted linear combination, as in Equation (9).

$$\mathcal{F}(A,\mathcal{D})=w_{\mathrm{BA}}·f_{\mathrm{BA}}(A,\mathcal{D})+w_{\mathrm{recall}}·f_{\mathrm{recall}}(A,\mathcal{D})+w_{\mathrm{HW}}·f_{\mathrm{HW}}\left(A\right),$$

(9)

where $w_{\mathrm{BA}}$, $w_{\mathrm{recall}}$, and $w_{\mathrm{HW}}$ are the empirical weights of the three objectives. The primary performance objective $f_{\mathrm{BA}}$ refers to the balanced accuracy as the metric for overall classification quality. Balanced accuracy treats all classes with equal importance regardless of their frequency in the training distribution, providing robustness against class imbalance effects that can mislead accuracy-based metrics [64].

To explicitly reward architectural capacity for detecting clinically significant rare classes, we introduce a minority recall objective $f_{\mathrm{recall}}$ computed over a predefined subset of minority classes $\mathcal{M}\subset \{0,1,\dots ,K-1\}$, where K is the total number of classes. The minority recall objective is formulated as the average recall across minority classes, given by Equation (10).

$$f_{\mathrm{recall}}(A,\mathcal{D})={\displaystyle \frac{1}{\left|\mathcal{M}\right|}}\sum _{k\in \mathcal{M}}{\mathrm{Recall}}_k(A,\mathcal{D}),$$

(10)

where the recall for class k is defined by Equation (11):

$${\mathrm{Recall}}_k={\displaystyle \frac{{\mathrm{TP}}_k}{{\mathrm{TP}}_k+{\mathrm{FN}}_k}},$$

(11)

where ${\mathrm{TP}}_k$ denotes true positives and ${\mathrm{FN}}_k$ denotes false negatives. This objective reflects the overall minority detection capacity of an architecture, allowing the search algorithm to identify candidates with demonstrated capability for minority pattern learning.

The hardware efficiency objective $f_{\mathrm{HW}}$ aggregates the quantized model storage footprint, $f_{\mathrm{flash}}\left(A\right)$, and its computational resource efficiency, $f_{\mathrm{MACs}}\left(A\right)$, through a weighted combination following Equation (12).

$$f_{\mathrm{HW}}\left(A\right)=w_{\mathrm{flash}}·f_{\mathrm{flash}}\left(A\right)+w_{\mathrm{MACs}}·f_{\mathrm{MACs}}\left(A\right),$$

(12)

where $w_{\mathrm{flash}}+w_{\mathrm{MACs}}=1$ and the relative weighting reflects the dominant resource constraint in the target deployment scenario. The component efficiency metrics are normalized using constraint-relative scaling, according to Equations (13) and (14).

$$\begin{array}{cc}\hfill f_{\mathrm{flash}}\left(A\right)& =1-min\left({\displaystyle \frac{\mathrm{Flash}\left(A\right)}{{\theta }_{\mathrm{Flash}}}},1\right),\hfill \end{array}$$

(13)

$$\begin{array}{cc}\hfill f_{\mathrm{MACs}}\left(A\right)& =1-min\left({\displaystyle \frac{\mathrm{MACs}\left(A\right)}{{\theta }_{\mathrm{MACs}}}},1\right),\hfill \end{array}$$

(14)

Beyond hardware resource constraints, we imposed quality-based feasibility requirements. We rejected architectures where the average minority recall is zero, indicating complete failure to learn minority class patterns, during the search phase. This quality filter prevents selection of architectures that satisfy hardware constraints but lack fundamental capacity for minority class learning.

3.5. Evaluation Metrics

We evaluated the performance of the proposed CNN framework using both predictive and deployment-oriented metrics. We evaluated classification performance using standard metrics for binary and multiclass classification. For each class k, we compute: the precision, recall, and F1-score according to Equation (15).

$$\begin{array}{c}{\mathrm{Precision}}_k={\displaystyle \frac{T{P}_k}{T{P}_k+F{P}_k}},\\ {\mathrm{Recall}}_k\left(\mathrm{Sensitivity}\right)={\displaystyle \frac{T{P}_k}{T{P}_k+F{N}_k}},\\ {\mathrm{F}}_1{-\mathrm{Score}}_k=2·{\displaystyle \frac{{\mathrm{Precision}}_k\times {\mathrm{Recall}}_k}{{\mathrm{Precision}}_k+{\mathrm{Recall}}_k}},\end{array}$$

(15)

where $T{P}_k$, $F{P}_k$, and $F{N}_k$ denote true positives, false positives, and false negatives for class k, respectively.

For overall model assessment, we reported macro-averages and weighted averages of each metric. In addition, we reported the overall accuracy and macro-recall, also called balanced accuracy, following Equation (16).

$$\begin{array}{c}\mathrm{Overall}\mathrm{Accuracy}={\displaystyle \frac{{\sum }_{k=1}^{K}T{P}_k}{N}},\\ \mathrm{Balanced}\mathrm{Accuracy}={\displaystyle \frac{1}{K}}\sum _{k=1}^K{\mathrm{Recall}}_k,\end{array}$$

(16)

where K is the number of classes and N is the total number of samples. Overall accuracy measures the proportion of correctly classified samples. However, overall accuracy is misleading with a highly imbalanced dataset. On the other hand, the balanced accuracy provides robustness against class imbalance by treating all classes equally, regardless of their frequency [64].

We computed classification metrics for both floating-point and quantized models to assess quantization-induced performance degradation.

To assess deployment feasibility on resource-constrained microcontrollers, we evaluated the following hardware-oriented metrics:

• Model Size (flash memory): The persistent storage requirement of the quantized TensorFlow Lite model in kilobytes, according to Equation (17):

  $$\mathrm{Flash}\left(\mathrm{KB}\right)={\displaystyle \frac{\left|\mathrm{TFLite}\mathrm{model}\right|\left(\mathrm{Bytes}\right)}{1024}}$$

  (17)

  where $\left|\mathrm{TFLite}\mathrm{model}\right|$ represents the quantized model size in bytes.
• Runtime Memory (RAM): Peak memory consumption during inference, representing the buffer space required for input data, intermediate activations, and output tensors.
• Computational Complexity (MACs): The number of multiply-accumulate operations per inference, which directly correlates with energy consumption and inference latency on embedded hardware.

All deployment metrics are extracted using a hardware profiler, which provides deterministic estimates for microcontrollers without requiring physical device deployment.

4. Experimental Setup and Results Discussion

We conducted our experiments on Google Colaboratory running Ubuntu 22.04 LTS with Python 3.10.12 and TensorFlow 2.15.0. We utilized CPU-based training with 12 GB system RAM. For hardware profiling and deployment simulation, we employed the Silicon Labs Gecko SDK Machine Learning Toolkit (MLTK) v2.1 for ARM Cortex-M4 microcontrollers. All models underwent INT8 post-training quantization via TensorFlow Lite to simulate resource-constrained deployment.

We employed the MIT-BIH Arrhythmia Database [65], which contains 48 half-hour excerpts of two-channel ambulatory ECG recordings from 47 subjects. Each beat is annotated by cardiologists according to the ANSI/AAMI EC57 standard. The dataset comprises 109,446 beats across 15 arrhythmia labels, with a significant class imbalance. Individual heartbeats were extracted as fixed-length 360-sample windows centered on annotated R-peaks provided by the database. Figure 2 shows the preprocessed ECG signals using the method of Kachuee et al. [56].

Figure 2. ECG signal preprocessing using Kachuee method.

For our primary experiments, we follow the common practice in NAS literature [49,54] using a random stratified split (70% training, 15% validation, 15% testing) to maintain consistent class distributions across splits. This approach enables us to compare our approach to SOTA. Additionally, for validation purposes, we conducted supplementary experiments using patient-aware 5-fold cross-validation. In this protocol, all beats from the same subject remain in the same fold. Table 3 presents the detailed class distribution.

Table 3. Dataset Class Distribution.

Class	Count (n)	Percentage (%)
Normal (N)	90,582	80.5
Supraventricular (S)	2781	2.5
Ventricular (V)	7235	6.4
Fusion (F)	802	0.7
Unknown (Q)	11,144	9.9
Total	109,446	100

We evaluated two classification scenarios:

• Binary Classification (Screening): Beats were categorized as Normal if labeled as N, L, R, e, or j, and Abnormal for all other beat types. This formulation addresses the screening scenario where the primary objective is detecting the presence of any arrhythmia.
• Multi-Class Classification (Diagnosis): Following the AAMI EC57 standard, beats were classified into five categories: Normal (N, L, R, e, j), Supraventricular (S, A, a, J), Ventricular (V, E), Fusion (F), and Unknown (Q, /, f). For the five-class arrhythmia classification task, the minority set $\mathcal{M}=\{\mathrm{S},\mathrm{V},\mathrm{F}\}$ comprises Supraventricular, Ventricular, and Fusion beats, which represent less than 10% of the dataset.

Our NAS employed a minority-aware neural architecture search strategy with strict edge device constraints. The threshold parameters were defined according to Saha et al. [54] with ${\theta }_{\mathrm{RAM}}=20$ KB, ${\theta }_{\mathrm{Flash}}=64$ KB, and ${\theta }_{\mathrm{MACs}}=60$ K. We empirically selected the weights of the score function with $w_{\mathrm{BA}}=0.7$, 0 $w_{\mathrm{recall}}=0.2$, $w_{\mathrm{HW}}=0.1$ ($w_{\mathrm{flash}}=0.7$ and $w_{\mathrm{MACs}}=0.3$). The weights were selected empirically based on preliminary experiments and clinical priorities. The dominant weight on balanced accuracy reflects that classification performance is the primary objective, while the minority recall weight ensures explicit attention to rare arrhythmias during search. The relatively lower hardware weight serves as a soft constraint since architectures violating hard thresholds (Equations (6)–(8)) are already rejected. In Section 4.3.1, we conducted sensitivity analysis across weight combinations and found that this configuration consistently identified architectures with balanced performance across majority and minority classes while satisfying hardware constraints.

We applied 10 runs with different seeds, each consisting of 50 trials. Through the 10 runs with 50 trials each, a total of 500 architectures were evaluated using random sampling from the six-dimensional constrained search space: convolutional blocks, kernel size, pooling size, dense units, and dropout rate. Each candidate architecture underwent 15-epoch training for the multi-class classification task and 5-epoch training for the binary task. We applied training on a stratified 5000-sample subset using focal loss with a $\mathrm{\gamma }$ of 2.0 and adaptive class weights. The 5000-sample subset, used during the NAS search phase, is drawn from the training data. The architectures were scored using the composite metric. Table 4 shows the NAS constrained search space. Note that we fixed the number of filters to 4 to fulfill the hardware constraints.

Table 4. Neural Architecture Search Hyperparameter Space.

Architecture Parameters	Values
Number of convolutional blocks	1, 2, 3, 4
Number of layers in each blocks	2
Number of filters in each layer	4
Size of convolutional kernel	3, 5, 7
Max-pooling window size	2, 3
Number of units in the fully connected layer	4, 8, 16, 32
Dropout probability for regularization	0.2, 0.3, 0.4, 0.5, 0.6, 0.7

After the search phase, we selected the trial with the highest score in each run and trained it on the full training set for 500 epochs for the multi-class classification task and 100 epochs for the binary task with early stopping. We used the results of the 10 best architectures to analyze the statistical performance of our strategy. In addition, we selected the best overall-accuracy model and compared it with SOTA.

For the binary classification problem, we applied full training as in Saha et al. [54]. For multi-class classification, we applied two full training strategies. The first is according to [54], and the second is the application of minority-aware training.

4.1. Binary Arrhythmia Classification

In this section, first, we report the minority-aware NAS search results for binary classification. Then, we present the statistical results and the best model results.

4.1.1. NAS Search Phase Results for Binary Arryhythmia Classification

Figure 3 presents the distribution of architectural parameters among the feasible binary classification architectures.

Figure 3. Distribution of architectural parameters among the feasible binary classification architectures.

The parameter distribution revealed that single-block architectures dominated (42%) and kernel size 3 remained preferred (64%), while dense layer units concentrated at 16 units (42%). The pooling size exhibited balanced distribution. These results show that a variety of architectures could be leveraged for binary Arrhythmia classification.

Table 5 presents aggregate performance statistics for feasible architectures during the search phase. The feasible models achieved a balanced accuracy ranging from 34.0% to 96.3%. Hardware profiling revealed: 13.5 ± 4.6 KB flash memory, 42.8 ± 8.9 K MAC operations, and 6.1 ± 1.5 KB runtime RAM.

Table 5. NAS Performance Metrics for Binary Classification During Limited-Epoch Search.

Metric	Mean ± SD	Range
Composite Score	$0.745\pm 0.186$	0.315–0.926
Balanced Accuracy	$0.795\pm 0.180$	0.340–0.963
Minority Recall	$0.656\pm 0.330$	0.003–0.943
Flash Storage (KB)	$13.5\pm 4.6$	7.6–28.5
MAC Operations (K)	$42.8\pm 8.9$	23.5–59.2
Runtime RAM (KB)	$6.1\pm 1.5$	4.9–9.3

4.1.2. Full Training Results

After the search phase, we selected the trial with the highest score, in each run, and trained it on the full training set for 100 epochs with early stopping. We used the results of the 10 best architectures to analyze the statistical performance of our search strategy. As shown in Table 6, multi-seed validation across ten random seeds demonstrated a standard deviation below 1.1% for both classes and for all metrics. The Normal class showed the tightest distribution with a recall standard deviation of 0.3%. Performance ranges were consistently narrow, with INT8 minima of 93.3% for Abnormal recall and 98.3% for Normal recall, while maxima reached 99.5% for Normal recall and 97.1% for Abnormal recall. Quantization from FP32 to INT8 introduced zero degradation across all metrics. This preservation of accuracy during quantization demonstrates the robustness of the model to 8-bit integer conversion. The balanced accuracy reached 97.4 ± 0.6% and the overall accuracy attained 98.0 ± 0.5%.

Table 6. FP32 vs. INT8 Across Multi-Seed Validation for Binary Classification.

Metric	Class	FP32 (Mean ± SD)	INT8 (Mean ± SD)
Recall (%)	Normal (N)	99.1 ± 0.3	99.1 ± 0.3
	Abnormal (A)	95.7 ± 1.1	95.7 ± 1.1
Precision (%)	Normal (N)	97.9 ± 0.5	97.9 ± 0.5
	Abnormal (A)	98.1 ± 0.7	98.1 ± 0.7
F1-Score (%)	Normal (N)	98.5 ± 0.4	98.5 ± 0.4
	Abnormal (A)	96.9 ± 0.7	96.9 ± 0.7
Summary Metrics
Balanced Accuracy (%)		97.4 ± 0.6	97.4 ± 0.6
Overall Accuracy (%)		98.0 ± 0.5	98.0 ± 0.5

4.1.3. Best Model Performance

The best-performing architecture is the architecture with the best overall accuracy of 98.7%. The same architecture achieved the best balanced accuracy of 98.3%. It consists of a CNN with two convolutional blocks. Each block contains two sequential convolutional layers with 4 filters and a kernel size of 3, followed by max pooling with a pool size of 3. The feature extraction stages are followed by a fully connected layer with 32 units and a dropout rate of 0.4 for regularization. The complete architecture comprises 5390 trainable parameters. When quantized to INT8 precision, the model requires only 14.3 KB of flash memory and 6.0 KB of RAM, with a computational cost of 38.3 K MAC operations per prediction. The best model performance is shown in Table 7. With this model, the Normal class achieved 99.5% recall and 98.6% precision with an F1-score of 99.0%. The Abnormal class achieved 97.12% recall with 99.0% precision.

Table 7. Best Model Performance Metrics.

Class	Precision (%)	Recall (%)	F1-Score (%)
Normal	98.6	99.5	99.0
Abnormal	99.0	97.1	98.0
Macro Average	98.8	98.3	98.5
Weighted Average	98.7	98.7	98.7

4.2. Multi-Class Arrhythmia Classification

In this section, first, we will report the minority-aware NAS search results for multi-class classification. Then, we will present the statistical results and the best model results for the two types of full training techniques. In the first type, we followed a standard training similar to [54]. In the second type, we adopted a minority-aware training.

4.2.1. NAS Search Phase Results for Multi-Class Arrhythmia Classification

Figure 4 shows the distribution of architectural parameters across feasible multi-class models. Most models employ shallow convolutional structures, with 1 and 2-block architectures selected most frequently. However, Figure 4 shows that architectures with 4 blocks may be hardware efficient. Small kernel sizes, particularly 3 and 5, are preferred. In the fully connected layers, moderately dense units (16 and 32) are most common, while smaller configurations are rare. Moreover, low dropout rates are more frequent.

Figure 4. Distribution of architectural parameters among the feasible multi-class architectures.

In Table 8, we present the performance statistics for the feasible architectures. We noticed that the feasible models achieved a mean composite score of $0.444\pm 0.101$, with balanced accuracy ranging from $20.9\%$ to $75\%$, during the short epoch training phase. Performance variation reflects the stochastic nature of random architecture sampling and the sensitivity of minority class learning to architectural choices. Hardware profiling revealed $14.2\pm 5.1$ KB flash memory size and MAC ranging from $23.5$ to $59.2$.

Table 8. Performance Metrics for Feasible Architectures During Limited-Epoch Search.

Metric	Mean ± SD	Range
Composite Score	$0.444\pm 0.101$	0.218–0.704
Balanced Accuracy	$0.480\pm 0.110$	0.209–0.750
Avg. Minority Recall	$0.233\pm 0.147$	0.005–0.667
Flash Storage (KB)	$14.2\pm 5.1$	7.6–28.5
MAC Operations (K)	$44.1\pm 9.6$	23.5–59.2
Runtime RAM (KB)	$6.2\pm 1.5$	4.9–9.3

4.2.2. Standard Training Results

After the architecture search phase, we selected the trial with the highest score in each run and trained it on the full training set. The multi-seed validation, shown in Table 9, demonstrated that the highest standard deviations were noticed in the Fusion class across all metrics. On the other hand, the Normal class exhibited the lowest variation and the best metrics overall. The quantization from FP32 to INT8 introduced zero variation across all metrics. Summary metrics demonstrated a Balanced Accuracy of $83.52\pm 4.21$ consistently lower than the Overall Accuracy of $97.19\pm 0.98$.

Table 9. Per-Class Performance Statistics Across Multi-Seed Validation for Multi-class Classification with Standard Training.

Metric	Class	INT8 (Mean ± SD)	FP32 (Mean ± SD)
Recall (%)	Normal	$98.87\pm 0.51$	$98.87\pm 0.51$
	Supraventricular	$74.84\pm 4.01$	$74.84\pm 4.01$
	Ventricular	$88.72\pm 5.96$	$88.72\pm 5.96$
	Fusion	$57.77\pm 12.31$	$57.77\pm 12.31$
	Unknown	$97.41\pm 1.88$	$97.41\pm 1.88$
Precision (%)	Normal	$98.49\pm 0.50$	$98.49\pm 0.50$
	Supraventricular	$91.91\pm 2.08$	$91.91\pm 2.08$
	Ventricular	$93.14\pm 5.56$	$93.14\pm 5.56$
	Fusion	$73.10\pm 11.56$	$73.10\pm 11.56$
	Unknown	$92.25\pm 4.41$	$92.25\pm 4.41$
F1-Score (%)	Normal	$98.68\pm 0.42$	$98.68\pm 0.42$
	Supraventricular	$82.44\pm 2.68$	$82.44\pm 2.68$
	Ventricular	$90.87\pm 5.69$	$90.87\pm 5.69$
	Fusion	$62.91\pm 6.71$	$62.91\pm 6.71$
	Unknown	$94.70\pm 2.58$	$94.70\pm 2.58$
Summary Metrics
Balanced Accuracy (%)		$83.52\pm 4.21$	$83.52\pm 4.21$
Overall Accuracy (%)		$97.19\pm 0.98$	$97.19\pm 0.98$

We selected the best-performing model as the highest overall accuracy model for comparison with SOTA. The best overall accuracy model achieved 98.21% overall accuracy, 87.02% balanced accuracy, and Macro F1-score of 90.2%. The model’s architecture consists of one 1D convolutional block, with two convolutional layers of 4 filters and a kernel size of 5, followed by max pooling of size 3. The feature extraction backbone is connected to a fully-connected classifier with 32 hidden units and 0.2 dropout. With 15,665 trainable parameters, the model requires 51.5 K MAC operations, 21.5 KB of flash memory, and 4.9 KB of RAM, making it suitable for deployment on resource-constrained medical devices. The best model’s performance metrics are detailed in Table 10.

Table 10. Per-Class Performance of Best Overall Accuracy Model with Standard Training.

Class	Precision (%)	Recall (%)	F1-Score (%)
Normal (N)	98.7	99.5	99.1
Supraventricular (S)	93.3	76.5	84.1
Ventricular (V)	95.5	94.0	94.8
Fusion (F)	85.3	66.9	75.0
Unknown (Q)	97.9	98.1	98.0
Macro Average	94.1	87.0	90.2

As presented in Figure 5, the primary misclassification pattern involves minority classes being incorrectly labeled as Normal.

Figure 5. Confusion Matrix of Multi-class Classification with Standard Training.

4.2.3. Minority-Aware Training Results

To address class imbalance, we combined four interventions: ECG-specific data augmentation; balanced batch sampling ensuring every class appears in every batch; focal loss with $\gamma =2.0$ to focus on hard examples, and adaptive class weighting. Our augmentation included time shifting, Gaussian noise, amplitude scaling, time stretching, baseline wander, and random cropping. We applied these techniques as they simulate realistic signal variations while preserving diagnostic waveform characteristics. We applied all augmentation operations to the training data after the train/val/test split. The test set is held out to serve as a benchmark for final evaluation. Augmentation is performed online rather than offline.

In Table 11, we presented the multi-seed statistics across ten random seeds. As in the binary classification task, the Normal class demonstrated the tightest distribution, with the smallest standard deviation. Fusion class standard deviation was reduced, compared to the standard training method. The low standard deviations, tight performance ranges, and minimal FP32-to-INT8 differences collectively confirm the model’s robustness to both initialization randomness and post-training quantization.

Table 11. Multi-Seed Validation for Minority-Aware Training.

Metric	Class	FP32 (Mean ± SD)	INT8 (Mean ± SD)
Recall (%)	Normal	$92.8\pm 2.0$	$93.3\pm 2.3$
	Supraventricular	$87.3\pm 1.3$	$86.7\pm 1.6$
	Ventricular	$93.9\pm 1.0$	$94.0\pm 1.0$
	Fusion	$87.5\pm 1.8$	$87.3\pm 2.4$
	Unknown	$96.0\pm 0.6$	$95.7\pm 0.7$
Precision (%)	Normal	$99.5\pm 0.0$	$99.4\pm 0.1$
	Supraventricular	$45.8\pm 4.8$	$47.2\pm 5.8$
	Ventricular	$81.1\pm 7.1$	$81.5\pm 7.1$
	Fusion	$25.7\pm 6.3$	$28.3\pm 8.3$
	Unknown	$94.6\pm 2.2$	$95.1\pm 1.9$
F1-Score (%)	Normal	$96.0\pm 1.1$	$96.3\pm 1.2$
	Supraventricular	$60.0\pm 4.2$	$60.9\pm 4.9$
	Ventricular	$86.9\pm 4.4$	$87.1\pm 4.3$
	Fusion	$39.2\pm 7.4$	$41.9\pm 9.1$
	Unknown	$95.3\pm 1.3$	$95.4\pm 1.1$
Summary Metrics
Balanced Accuracy (%)		$91.5\pm 0.6$	$91.4\pm 0.5$
Overall Accuracy (%)		$93.0\pm 1.7$	$93.4\pm 1.9$

We selected the best-performing model- with the highest overall accuracy. It achieved an overall accuracy of 95.73%, which also achieved the highest Macro F1-score of 81.74% among all evaluated architectures. The best model’s architecture consists of three convolutionalblocks with two convolutional four-filter layers each and a kernel size of 3, followed by max pooling of size 2. The feature extraction backbone is connected to a fully-connected classifier with 32 hidden units and 0.3 dropout. With 6233 trainable parameters, the model requires 53.4 K MAC operations, 17.77 KB of flash memory, and 7.52 KB of RAM, making it suitable for deployment on resource-constrained medical devices. We presented the best model performance in Table 12.

Table 12. Per-Class Performance of Best Overall Accuracy Model with Minority-aware Training.

Class	Precision (%)	Recall (%)	F1-Score (%)
Normal (N)	99.4	96.1	97.7
Supraventricular (S)	58.0	87.3	69.7
Ventricular (V)	88.8	93.9	91.3
Fusion (F)	40.5	84.3	54.7
Unknown (Q)	94.0	96.6	95.3
Macro Avg	76.1	91.6	81.7

The Normal class achieved 96.1% recall, 99.4% precision, and 97.7% F1 score. This demonstrates the reliable identification of healthy rhythms. For clinically critical arrhythmias, Ventricular beats achieved the best recall, precision, and F1-score. Fusion class recall improved to 84.3% while its precision decreased to 40.5%. However, the balanced accuracy slightly increased to 91.64%.

As shown in Figure 6, the primary misclassification pattern persists with minority classes being incorrectly labeled as Normal, particularly affecting Supraventricular (9.6%) and Fusion (8.3%) beats.

Figure 6. Confusion matrix for the best model.

As demonstrated in Figure 7, the standard training approach achieved the highest overall accuracy (98.2% vs. 95.7%) and the highest Macro F1-score (90.2% vs. 81.7%). It favored precision over recall. This conservative strategy minimizes false alarms but risks missing critical arrhythmias. Conversely, the minority-aware model improved the recall and reduced the precision.

Figure 7. Classification Metrics Comparison.

4.3. Ablation and Validation Studies

In this section, we conduct various ablation and validation studies.

4.3.1. Impact of Scoring Weights

To address the empirical nature of our weight, we conducted a comprehensive ablation study examining three distinct weight sets for the composite scoring function.

• Minority-focused (Configuration A): with $w_{\mathrm{BA}}=0.3$, $w_{\mathrm{recall}}=0.6$, and $w_{\mathrm{HW}}=0.1$.
• Balanced (Configuration B): with $w_{\mathrm{BA}}=0.4$, $w_{\mathrm{recall}}=0.4$, and $w_{\mathrm{HW}}=0.2$.
• Minority-aware (Configuration C): this is our proposed configuration with $w_{\mathrm{BA}}=0.7$, $w_{\mathrm{recall}}=0.2$, and $w_{\mathrm{HW}}=0.1$.

For each configuration, we performed 5 independent multi-class NAS runs with standard full training and with the same random seeds (42–46). All other hyperparameters were kept identical to enable fair comparison.

In Table 13, we present a comparison of the three configurations. Configuration A and Configuration C achieved the highest mean values across various metrics, represented in bold in the table. Moreover, configuration C demonstrated superior stability, with the lowest average coefficients of variation (CV).

Table 13. Comparison of NAS Scoring Weight Configurations.

Category	Metric	Config A $\mathbf{Mean}\pm \mathbf{Std}$	Config B $\mathbf{Mean}\pm \mathbf{Std}$	Config C $\mathbf{Mean}\pm \mathbf{Std}$
Overall	Overall Accuracy	$0.975\pm 0.006$	$0.965\pm 0.012$	$\mathbf{0.977}\pm \mathbf{0.004}$
	Balanced Accuracy	$\mathbf{0.873}\pm \mathbf{0.016}$	$0.827\pm 0.043$	$0.868\pm 0.018$
	MACs (K)	$\mathbf{44.7}\pm \mathbf{9.1}$	$45.7\pm 7.7$	$49.9\pm 5.9$
	Flash (KB)	$21.2\pm 4.6$	$20.9\pm 6.9$	$\mathbf{18.4}\pm \mathbf{2.6}$
Precision	Normal	$0.986\pm 0.004$	$0.984\pm 0.003$	$\mathbf{0.987}\pm \mathbf{0.001}$
	Supraventricular	$\mathbf{0.930}\pm \mathbf{0.029}$	$0.936\pm 0.021$	$0.916\pm 0.012$
	Ventricular	$0.942\pm 0.014$	$0.917\pm 0.071$	$\mathbf{0.946}\pm \mathbf{0.019}$
	Fusion	$0.659\pm 0.247$	$\mathbf{0.793}\pm \mathbf{0.150}$	$0.684\pm 0.122$
	Unknown	$\mathbf{0.958}\pm \mathbf{0.016}$	$0.886\pm 0.097$	$0.947\pm 0.024$
	Avg CV%	$8.8\%$	$8.0\%$	$\mathbf{4.7}\%$
Recall	Normal	$0.988\pm 0.006$	$0.981\pm 0.014$	$\mathbf{0.991}\pm \mathbf{0.003}$
	Supraventricular	$0.759\pm 0.041$	$0.735\pm 0.025$	$\mathbf{0.777}\pm \mathbf{0.019}$
	Ventricular	$\mathbf{0.912}\pm \mathbf{0.029}$	$0.893\pm 0.023$	$0.906\pm 0.034$
	Fusion	$0.674\pm 0.143$	$0.557\pm 0.183$	$\mathbf{0.684}\pm \mathbf{0.075}$
	Unknown	$0.980\pm 0.003$	$0.970\pm 0.020$	$\mathbf{0.981}\pm \mathbf{0.007}$
	Avg CV%	$6.1\%$	$8.5\%$	$\mathbf{3.6}\%$
F1-Score	Normal	$0.987\pm 0.004$	$0.983\pm 0.007$	$\mathbf{0.989}\pm \mathbf{0.001}$
	Supraventricular	$0.834\pm 0.023$	$0.823\pm 0.014$	$\mathbf{0.841}\pm \mathbf{0.012}$
	Ventricular	$\mathbf{0.927}\pm \mathbf{0.018}$	$0.904\pm 0.044$	$0.925\pm 0.025$
	Fusion	$0.614\pm 0.128$	$0.618\pm 0.124$	$\mathbf{0.672}\pm \mathbf{0.046}$
	Unknown	$\mathbf{0.969}\pm \mathbf{0.008}$	$0.923\pm 0.054$	$0.963\pm 0.010$
	Avg CV%	$5.4\%$	$6.6\%$	$\mathbf{2.4}\%$

4.3.2. Effect of Search-Phase Training Budget

To investigate the effect of search-phase-limited training on the final model’s ranking, we randomly sampled 15 architectures and compared their proxy metrics with the final metrics. Spearman rank correlations [66] range from 0.857 to 0.888 across all metrics (all p < 0.001). Table 14 illustrates that the top-5 architectures during search consistently remain top performers after full training. This confirms that the limited training reliably identifies promising architectures.

Table 14. Top-5 architectures ranked by proxy score vs. final performance.

Search Rank	Trial ID	Proxy Score	Final Score	Proxy BA (%)	Final BA (%)
1	2	0.631	0.777	67.96	87.93
2	29	0.575	0.752	61.62	85.50
3	39	0.568	0.783	61.65	88.58
4	10	0.547	0.769	59.68	87.23
5	7	0.511	0.765	55.17	86.65

4.3.3. Subject-Wise Cross-Validation

To evaluate generalization to unseen patients, we conducted subject-wise (inter-patient) 5-fold cross-validation, where all beats from each patient are confined to a single fold, on our best binary model, despite the search phase using a random split. Using patient-wise cross-validation during search would restrict the training set and increase ranking variance. Therefore, we adopted a two-stage protocol: random split during search, followed by subject-wise 5-fold cross-validation for final performance estimates. The model achieved a balanced accuracy of 75.9 ± 8.8% and overall accuracy of 80.7 ± 11.5%. Most critically, the abnormal recall of 68.2 ± 4.8% demonstrates detection of arrhythmias in unseen patients, while the normal precision of 96.2 ± 2.1% ensures minimal false alarms. The standard deviations (4–12%) confirm consistent performance across different patient populations. The moderate standard deviations across folds validate that the model does not overfit to specific patients despite the random split during search phase. Table 15 presents the subject wise performance metrics.

Table 15. Inter-Patient Best Model Performance Metrics.

Class	Mean Prec. ± Std (%)	Mean Recall ± Std (%)	Mean F1 ± Std (%)
Normal	$96.2\pm 2.1$	$83.6\pm 4.3$	$89.5\pm 3.2$
Abnormal	$42.8\pm 5.7$	$68.2\pm 4.8$	$52.6\pm 5.1$
Macro Average	$69.5\pm 3.9$	$75.9\pm 4.6$	$71.1\pm 4.2$
Weighted Average	$92.1\pm 2.4$	$90.2\pm 2.8$	$91.0\pm 2.6$

4.4. Comparison with State-of-the-Art

In Table 16, we compared our framework with state-of-the-art TinyML approaches for arrhythmia classification on the MIT-BIH dataset. The bold values in Table 16 represent the best achieved metrics. Our binary classifier outperformed the SOTA model across all evaluation metrics.

Table 16. Comparison with SOTA for Arrhythmia Classification on MCUs.

Method	Dataset	Task	Search	Acc. (%)	BA (%)	Size (KB)	MACs (K)	RAM (KB)
Cinotti et al. [36]	MIT-BIH	Binary	Fixed	98.00	98.00	86.6	NR	8.5
MicroNAS [49]	UCI-HAR	Multi-class	DNAS	91.85	NR	11.3	NR	15.0
Saha et al. [54]	MIT-BIH	Multi-class	Grid	97.40	NR	19.3	56.5	9.0
Our Work (Std.)	MIT-BIH	Binary	Random	98.70	98.30	14.3	38.3	6.0
Our Work (Std.)	MIT-BIH	Multi-class	Random	98.21	87.02	21.5	51.5	4.9
Our Work (Min-Aware)	MIT-BIH	Multi-class	Random	95.73	91.60	17.77	53.4	7.52

NR = Not Reported.

For multi-class classification, the grid-search-based method of Saha et al. [54] achieved 97.40% accuracy; however, their balanced accuracy and minority-class performance were not reported, limiting assessment of class-wise robustness. Our standard (same as [54]) NAS-based model outperformed Saha et al. [54] with an overall accuracy of 98.21% while achieving a balanced accuracy of 87.02%, indicating consistent performance across classes. These gains are obtained with a 21.5 KB model size and 51.5 K MACs, which is better than Saha et al. [54]. Our minority-aware variant prioritizes class balance, achieving the highest balanced accuracy of 91.60% with a model of size 17.77 KB and 53.4 K MAC operations. Although overall accuracy decreases to 95.73%, this trade-off enhances sensitivity to clinically relevant minority arrhythmia classes.

Our results demonstrate that with our constrained search space, random sampling exceeded the efficiency of Differential NAS (DNAS) and grid search. DNAS, used in MicroNAS [49], risks post-hoc quantization failures by searching in a floating-point space. Moreover, grid search, used in TinyTNAS [54], undergoes exhaustive enumeration, increasing the computational overhead. The primary trade-off of random sampling is the lack of optimality guarantees; however, our results outperformed MicroNAS and TinyTNAS as reported in Table 16.

5. Limitations and Future Directions

Our proposed ultra-compact minority-aware neural architecture search framework demonstrates the feasibility of automating the design of resource-efficient deep learning models for arrhythmia classification on edge devices. By incorporating quantization-awareness, minority class consideration, and hardware efficiency metrics into the search objective, the discovered architectures achieved strong performance while satisfying the strict constraints of edge microcontrollers.

The minority-aware training variant improved recall for rare arrhythmias at the cost of reduced precision compared to the standard approach. In addition, the minority-aware strategy also leads to more compact architectures.

Despite its promising results, the proposed framework has several limitations. First, the framework should be validated on different datasets. Furthermore, while our hardware evaluation—Flash usage, RAM usage, and MAC operations—are directly profiled from the quantized TFLite model using the Silicon Labs MLTK profiler, we acknowledge that physical hardware measurements of latency and energy consumption would provide additional validation. Physical hardware validation remains a direction for future work. Moreover, even though random search was able to discover well-performing architectures, more sophisticated search strategies could be applied on a larger search space. Finally, while we conducted a patient-wise validation, deeper investigation of patient-wise search strategy would be considered in future work.

6. Conclusions

In this work, we presented a novel neural architecture search framework for automating the design of resource-efficient CNNs for the classification of arrhythmias in edge devices. We integrated minority class consideration and hardware efficiency metrics directly into our multi-objective score function. In addition to that, we applied a random search in a quantization-aware search space. Using this approach, we discovered NanoCNN architectures that achieved state-of-the-art performance on the MIT-BIH Arrhythmia Database.

Furthermore, we applied a comparative analysis of standard and minority-aware training strategies. We noticed that our minority-aware variant improved the recall for rare arrhythmias at the cost of reduced precision. This underscores the need for a holistic approach that jointly optimizes architecture search and training methodology to develop robust TinyML solutions for clinical applications.

However, it is necessary to extend the framework to incorporate explainability techniques and validate the approach across a wide range of datasets, patient populations, and deployment scenarios. In addition, physical hardware deployment will give empirically validated latency and energy measurements for the obtained models.