Efficient Polish-Language Keyword Spotting on Microcontrollers: Compact Neural Architectures, Quantization, and On-Device Validation on the Raspberry Pi Pico 2

1. Introduction

Voice interfaces have become one of the most natural and ergonomic methods of human–machine interaction. Keyword Spotting (KWS) is the task of detecting predefined words or short phrases in a continuous audio stream. It constitutes the foundation of modern virtual assistants, such as Amazon Alexa, Apple Siri, and Google Assistant, where a lightweight, always-on detector listens for a wake word before activating more complex processing pipelines.

With the rapid expansion of the Internet of Things (IoT), there is a growing demand for touchless operation of smart-home appliances and industrial automation systems. However, streaming audio to remote cloud servers introduces critical challenges, including unacceptable latency, high network bandwidth usage, increased power consumption, and privacy concerns regarding user data [1]. A remedy is offered by Edge Computing and the TinyML paradigm, which shift acoustic analysis directly onto low-cost microcontrollers at the edge of the network.

Historically, speech recognition was dominated by Hidden Markov Models (HMMs) combined with Gaussian Mixture Models (GMMs), which successfully captured the sequential and stochastic nature of speech [2]. For microcontrollers operating in an always-on listening mode with only hundreds of kilobytes of RAM, however, these classical models proved too resource-hungry and energy-inefficient [3].

These limitations were largely overcome by deep learning, which replaced HMM decoding with neural networks that predict keyword probabilities directly from acoustic features, such as Mel-Frequency Cepstral Coefficients (MFCCs) [3]. Over the past decade, a range of specialized small-footprint architecture families has emerged—convolutional (CNN), convolutional-recurrent (CRNN), depthwise-separable (DS-CNN), and broadcasted-residual (BC-ResNet) networks—which are reviewed in detail in Section 2.

The overwhelming majority of small-footprint KWS studies have been developed and evaluated on English data, most notably on the Google Speech Commands dataset [4], and the transferability of their conclusions to typologically different languages remains largely unverified. Here, we target Polish, a West Slavic language spoken by approximately 40 million people, whose phonological profile differs considerably from that of English. Polish is characterized by a consonant-rich phonology with long and dense consonant clusters (e.g., the keyword wstecz, “backward”, begins with a three-consonant cluster) and an unusually large inventory of fricatives and affricates, including a typologically rare three-way place contrast between dental, retroflex, and alveolo-palatal sibilants [5]. In addition, its rich inflectional morphology gives rise to numerous phonetically similar word forms. These properties make Polish keywords particularly difficult to discriminate when the effective spectral resolution is reduced—as exemplified in our experiments by near-minimal pairs such as ptak (“bird”) and tak (“yes”)—and thus make Polish a demanding and informative test case for resource-constrained KWS.

In this work, we present a complete, hardware-validated KWS solution for the Polish language targeting devices with severely constrained resources. Throughout the paper, we distinguish between an architecture family (a general class of network designs established in the literature, e.g., CRNN), an architecture (a concrete instantiation of a family, i.e., a specific configuration of layers, their dimensions, and the resulting parameter count), and a model (a trained instance of an architecture). The main contributions of this paper are as follows:

• We design three original, compact architectures—belonging to the CNN, CRNN, and DS-CNN families—tailored to Polish-language KWS on microcontrollers, and we benchmark them against BC-ResNet [6], a state-of-the-art reference architecture for small-footprint KWS.
• We provide a systematic evaluation of small-footprint KWS for the Polish language, which remains under-represented in the KWS literature dominated by English-language benchmarks. All models are trained and evaluated on a dataset of 25 Polish keywords.
• We study the effect of post-training 8-bit integer (INT8) quantization, a crucial step for TinyML deployments [1,7], on accuracy, model size, and inference latency. Notably, we show that the accuracy ranking of the evaluated architectures inverts after quantization, and that the most parameter-efficient architecture does not necessarily yield the fastest or most robust quantized model.
• We deploy and benchmark the complete system on custom-designed hardware: a dedicated printed circuit board (PCB) integrating the Raspberry Pi Pico 2 board with the RP2350 microcontroller and an analog audio front-end based on an electret microphone, on which all inference latencies are measured.

The remainder of this paper is organized as follows. Section 2 reviews related work on small-footprint KWS. Section 3 introduces the necessary background: the KWS problem, MFCC feature extraction, TinyML, model quantization, and inference frameworks for microcontrollers. Section 4 describes the proposed network architectures. Section 5 presents the hardware platform and the experimental results, and Section 6 discusses the findings. Finally, Section 7 concludes the paper.

2. Related Works

Early speech recognition systems employed statistical sequence modelling, which led to the long-standing dominance of Hidden Markov Models (HMMs). HMMs successfully captured the sequential and stochastic nature of speech [2]. In HMM-based KWS systems, a keyword model is compared against a background noise or filler model, and the Viterbi search algorithm is used to find the optimal path through the decoding graph. However, deploying HMM-based models on microcontrollers is demanding, as Viterbi decoding requires considerable computational and memory resources [1].

In 2014, Chen et al. demonstrated that Deep Neural Networks (DNNs) can effectively replace HMMs for small-footprint KWS [8]. Their system predicts keyword probabilities directly from acoustic features, eliminating the need for complex sequence search algorithms such as Viterbi decoding. This reduced latency and simplified the computational requirements, making the approach attractive for real-time applications. The main drawback of plain DNNs, however, is their inability to exploit the local temporal and spectral correlations present in the speech signal.

To overcome this limitation, Sainath and Parada introduced Convolutional Neural Networks (CNNs) to the KWS domain [9]. By treating the extracted acoustic features as two-dimensional images, CNNs effectively capture local time–frequency patterns and achieve higher accuracy with fewer parameters than DNNs.

Arik et al. proposed the Convolutional Recurrent Neural Network (CRNN) for KWS [10], in which convolutional layers first extract local features and recurrent layers subsequently encode the global temporal context. This combination achieves high accuracy and noise robustness with a relatively small memory footprint [1].

A further step towards efficiency was the Depthwise Separable Convolutional Neural Network (DS-CNN), inspired by the MobileNet architecture [11]. Zhang et al., in their “Hello Edge” study [3], demonstrated that factorising standard convolutions into separate depthwise and pointwise (1×1) operations drastically reduces the parameter count and computational load. Their DS-CNN model achieved an accuracy of 95.4% on the Google Speech Commands dataset [3,4].

More recently, Kim et al. introduced broadcasted residual learning and the BC-ResNet architecture to address the computational trade-off between 1D and 2D convolutions [6]. Standard 1D temporal convolutions are efficient but lack invariance along the frequency dimension, whereas 2D convolutions are computationally demanding. BC-ResNet resolves this by performing frequency-wise convolutions on 2D features, averaging them into 1D temporal features, and then broadcasting the 1D residual information back onto the 2D spatial dimensions. The BC-ResNet-1 model achieved state-of-the-art performance (96.6% accuracy) with fewer than 10k parameters on the Google Speech Commands dataset [1,6].

Notably, all of the above milestones were established on English data, with the Google Speech Commands dataset [4] serving as the de facto standard benchmark. Research on KWS for other languages has gained momentum only recently. Mazumder et al. released the Multilingual Spoken Words Corpus, covering more than 340,000 keywords in 50 languages [12], and proposed a few-shot transfer-learning approach that enables keyword spotting in a new language from only a handful of training examples [13]. Multilingual speech-command collections derived from crowd-sourced recordings, such as the 15-language dataset used in this work [14], follow the same direction. Nevertheless, Slavic languages—including Polish, whose consonant-rich phonology and dense consonant clusters [5] pose specific challenges for acoustic modelling—remain scarcely represented in the small-footprint KWS literature. To the best of our knowledge, no prior work has systematically benchmarked small-footprint KWS architectures for Polish, covering both full-precision and quantized models together with latency measurements on physical microcontroller hardware. The present study addresses this gap.

3. Preliminaries

3.1. Keyword Spotting Problem

The workflow of a deep learning-based KWS system involves three main stages: extraction of acoustic features from the raw speech signal, application of a deep neural network model that generates probabilities for the individual keywords, and a decision stage that detects the presence of the target keywords [1].

KWS is a dynamic process in which the system continuously monitors the input audio signal and produces a sequence of posterior probabilities in real time. The feature extraction function converts the raw signal into a concise spectral representation: a two-dimensional matrix containing a temporal series of K-dimensional feature vectors, of which the model sequentially processes overlapping segments [1].

The deep learning model maps each temporal input segment to an N-dimensional vector representing the probability distribution over N keyword classes. The system then selects the class with the highest probability; if the score of the targeted keyword class exceeds a preset threshold, the keyword is detected, otherwise the segment is rejected as background noise or an unknown word [1].

3.2. Feature Extraction

Raw audio waveforms must first be transformed into a compact and reliable representation. The most widely adopted feature extraction method in speech processing is Mel-Frequency Cepstral Coefficients (MFCCs). These acoustic features mimic human sound perception by reflecting the nonlinear frequency sensitivity of the human ear [15,16].

The standard feature extraction pipeline is shown in Figure 1. It consists of several sequential digital signal processing blocks: pre-emphasis, framing, windowing, the Fast Fourier Transform (FFT), the application of a Mel filter bank, logarithmic compression, and the Discrete Cosine Transform (DCT) [15,16].

Figure 2 illustrates the successive representations of a one-second speech-like signal: the raw waveform, its log-Mel spectrogram, and the resulting MFCC matrix. The final representation is a compact two-dimensional image whose horizontal axis corresponds to time and whose vertical axis corresponds to the cepstral coefficients.

First, a pre-emphasis filter is applied to the raw audio signal to boost its high-frequency components, since speech energy is concentrated in the low-frequency band; this balances the spectrum and increases the amount of information available to the model. Next, the signal is segmented into overlapping frames (typically 30–40 ms long with a 25–75% shift), which captures the quasi-stationary nature of speech. Each frame is then multiplied by a window function (most commonly a Hamming window) to reduce spectral leakage, and the FFT is applied to compute the power spectrum. The spectrum is subsequently passed through a bank of triangular band-pass filters spaced according to the Mel scale, and a logarithm is applied to the filter bank outputs to imitate the loudness perception of the human ear. Finally, the DCT is applied to decorrelate the log-energies and reduce their dimensionality, yielding the MFCC matrix. The resulting features are treated as two-dimensional images and used as the input to the neural networks [15].

3.3. TinyML and Model Quantization

Tiny Machine Learning (TinyML) is a subfield of artificial intelligence and edge computing that focuses on deploying machine learning and deep learning models directly on ultra-low-power, resource-constrained embedded devices, especially microcontrollers. Such platforms often feature less than 500 KB of SRAM, less than 2 MB of Flash storage, and severe energy constraints [17].

To fit deep neural networks into microcontrollers, neural network quantization is commonly applied as an optimization step. Quantization reduces the numerical precision of the network weights and intermediate activation maps: during the conversion of a trained model, 32-bit floating-point values are mapped to lower-precision formats, such as signed 8-bit integers. This conversion shrinks the model size and removes the dependence on a Floating-Point Unit (FPU), drastically reducing inference latency and energy consumption [7].

3.4. Inference Frameworks

The deployment of models on edge hardware relies on specialized software frameworks. Several libraries are available for running neural network models on microcontrollers. In this work, we use TensorFlow Lite for Microcontrollers (TFLM, now part of LiteRT), an open-source library developed by Google as a reduced version of TensorFlow Lite [18]. It does not require an underlying operating system and is designed specifically for model inference on microcontrollers and other edge devices.

To execute a model, a FlatBuffer is created from the .tflite file and loaded into an interpreter, together with a pre-allocated tensor arena (a static memory buffer used for the input, output, and working tensors during inference). TFLM relies heavily on optimized backend libraries, such as the Cortex Microcontroller Software Interface Standard Neural Network (CMSIS-NN) library provided by ARM [19,20], which offers highly optimized implementations of neural network kernels for ARM Cortex-M processors.

4. Implementation

4.1. Neural Network Architectures

Three original, compact architectures were designed, trained, and evaluated: a CNN, belonging to the family introduced by Sainath and Parada [9]; a CRNN, following the design of Arik et al. [10]; and a DS-CNN inspired by the architecture proposed in [3]. In addition, the BC-ResNet architecture [6] was reimplemented as a state-of-the-art reference for benchmarking. All models were engineered to process two-dimensional MFCC features as input. Each architecture was kept within a small-footprint budget suitable for microcontroller deployment, ranging from approximately 13k parameters for the BC-ResNet reference to 76k for the CNN (Table 1). As discussed in Section 5, parameter count alone is not predictive of accuracy in this regime: the largest model (CNN) is in fact the least accurate, indicating that the inductive bias of each architecture family, rather than raw capacity, is the dominant factor.

The CNN model is designed to function as an acoustic feature extractor. The model architecture is shown in Figure 3. The architecture utilizes standard two-dimensional convolutional layers to capture local time-frequency correlations, such as formants and pitch shifts. The multidimensional output is subsequently flattened and processed through fully connected dense layers, culminating in a Softmax classifier that outputs the target vocabulary probabilities.

To better capture the sequential nature of speech, a hybrid CRNN architecture was implemented (Figure 4). The initial convolutional layer forms a spatial front-end that reduces the input dimensionality. Next, the spatial dimensions are flattened while the temporal axis is preserved, forming a time-series representation. This is fed into a single GRU layer with 32 units (see Figure 4), which allows the model to capture long-term phonetic dependencies. The final layer is a dense classification layer with a Softmax activation.

The DS-CNN architecture design is based on [3]. Model structure is shown in the Figure 6. The model contains 4 DS blocks (Figure 5). Each block consists of a Depthwise Phase and a Pointwise Phase. In the Depthwise part, a spatial filtering step applies a $3\times 3$ kernel independently to each input channel. It is followed by Batch Normalization for training stabilization and a ReLU activation function. In the Pointwise part, a $1\times 1$ convolution is used to linearly combine the feature maps generated by the depthwise phase into output channels. As in the first phase, it is followed by Batch Normalization and a ReLU activation function.

The CNN, CRNN, and DS-CNN models were trained using the Adam optimizer with sparse categorical cross-entropy loss over a maximum of 20 epochs, with a batch size of 64 or 128 (model-dependent) and early stopping (patience = 3, restoring best weights). The BC-ResNet model followed the training recipe from the original paper [6]: SGD optimizer with momentum 0.9, L2 weight decay 0.001, an initial learning rate of 0.1 with a 2-epoch warmup and cosine/stepwise decay, over 20 epochs with a batch size of 128.

The dataset was partitioned into a training subset (80%, 112,677 samples) and a test subset (20%, 28,169 samples) using a fixed random seed. The split was not explicitly speaker-independent. Five-fold cross-validation was applied on the training subset for model selection; final accuracy was evaluated on the shared test set.

Regularization was applied in the form of early stopping on validation loss (CNN, CRNN, DS-CNN) and L2 weight decay (BC-ResNet). Data augmentation in the form of white noise injection was applied to the training set only; additional augmentations (pitch shifting, time stretching, and noise) were provided by the dataset authors. All training was performed in TensorFlow/Keras (CNN, CRNN, DS-CNN) and PyTorch (BC-ResNet) on a single NVIDIA GeForce GTX 1050 Ti GPU.

The total number of parameters for each architecture is summarized in Table 1.

5. Results

5.1. Hardware Architecture

In order to investigate the performance of the proposed neural networks in a real-world scenario, a dedicated hardware platform was developed. The system architecture revolves around the Raspberry Pi Pico 2 development board, which features the RP2350 microcontroller (Figure 7). The RP2350 is a high-performance system-on-chip (SoC) that employs a unique dual-core, dual-architecture design, providing two Arm Cortex-M33 cores and two RISC-V Hazard3 cores, both operating at a nominal frequency of 150 MHz [21].

In this research, the Arm Cortex-M33 cores were selected due to support for TinyML workloads, such as CMSIS-DSP [22] and Tensorflow Lite for Microcontrollers [18]. The Cortex-M33 implements the Armv8-M architecture, which includes Digital Signal Processing (DSP) instructions and a Single-Precision Floating-Point Unit (FPU). These hardware features are critical for efficient Keyword Spotting (KWS), as they allow for the accelerated computation of Mel-Frequency Cepstral Coefficients (MFCC) and optimize the execution of quantized neural network kernels. The microcontroller is equipped with 520 KB of on-chip SRAM. The Pico 2 board also provides 4 MB of external QSPI Flash memory [21].

The hardware implementation includes a custom dual-layer Printed Circuit Board (PCB) designed and fabricated to interface the Raspberry Pi Pico 2 with an analog audio front-end. This front-end utilizes an electret microphone coupled with a low-noise pre-amplifier stage [23] to capture voice commands.

5.2. Testing on the Database

For testing the models, the dataset described in [14] was used. The database contains 1-second voice recordings of single words in 15 languages. All records have been augmented using time-shifting, noise injection, pitch variation, etc. [14]. For testing, only Polish words were selected. The models were trained to recognize 25 classes, which are shown in Table 2.

The overall performance and memory requirements of the evaluated neural network architectures were measured in their Float32 format and after integer quantization (INT8). Table 3 and Table 4 summarize the accuracy, F1-score, model size, and on-device inference time for the Float32 and INT8 variants, respectively. All reported F1-scores are weighted-averaged across classes (each class’s F1 weighted by its number of samples). Because the dataset is markedly imbalanced (e.g., no (nie) with 31,086 samples versus backward (wstecz) with 918), both the overall accuracy and the weighted F1-score are dominated by the most frequent classes; the per-class confusion-matrix analysis (Section 5, Confusion Matrix) is therefore included to give a more balanced view of per-keyword performance.

The highest accuracy in Float32 format was achieved by the BC-ResNet model (97.81%), followed closely by DS-CNN (97.06%) and CRNN (96.19%). The CNN architecture exhibited the lowest Float32 accuracy at 88.68%. After INT8 quantization, the CRNN model retained the highest accuracy (94.28%), while BC-ResNet experienced the largest absolute accuracy drop (5.08 percentage points). Quantization significantly reduced the model size for the CNN (from 300.64 KB to 79.44 KB) and DS-CNN (from 98.85 KB to 46.15 KB). The file sizes of the CRNN and BC-ResNet architectures remained largely unaffected by the quantization process. Inference time was measured directly on the target hardware platform, the Raspberry Pi Pico 2 microcontroller, as the mean over 100 consecutive inferences per model; all programs were compiled with Release optimization settings. The standard deviation did not exceed $0.5$ $\mathrm{m}$$\mathrm{s}$ for any configuration and is therefore omitted. The resulting on-device latencies are reported alongside the accuracy and memory metrics in Table 3 and Table 4.

The shortest mean inference time was recorded for the CNN model in INT8 format ( $107.5$ $\mathrm{m}$$\mathrm{s}$). The DS-CNN architecture exhibited the greatest relative speedup following INT8 quantization, with the mean inference time reduced from $1693.7$ $\mathrm{m}$$\mathrm{s}$ to $311.3$ $\mathrm{m}$$\mathrm{s}$ (approximately 5.4-fold). In contrast, the BC-ResNet architecture showed the smallest relative improvement after quantization, with execution time decreasing from $579.1$ $\mathrm{m}$$\mathrm{s}$ to $501.9$ $\mathrm{m}$$\mathrm{s}$. Relative to the one-second analysis window of the input frame, all INT8 models meet the real-time constraint, with inference well below 1 $\mathrm{s}$. In Float32, only the CNN and CRNN remain within this budget, whereas the DS-CNN ( $1693.7$ $\mathrm{m}$$\mathrm{s}$) exceeds it and is therefore unsuitable for continuous, always-on operation unless quantized.

5.3. Confusion Matrix

Confusion matrices were generated for all evaluated models to assess prediction stability across individual voice commands. In every matrix, rows correspond to the true class and columns to the predicted class, so a strong diagonal indicates correct predictions. The matrices for the BC-ResNet model, in both Float32 and INT8 formats, are shown in Figure 8; for conciseness, the corresponding matrices for the CNN, CRNN, and DS-CNN models are provided in Appendix A.

The BC-ResNet model demonstrated robust word recognition performance across the majority of classes in Float32 format. A notable exception was the keyword bird (ptak), which achieved 83.5% per-class accuracy and was most frequently misclassified as yes (tak) in 7.4% of cases and as two (dwa) in 4.9% of cases.

In the Float32 CNN model, the lowest classification accuracy was recorded for the command bird (ptak) at 70.8%, which was misclassified as yes (tak) in 16.9% of instances. A further notable error involved the keyword seven (siedem), which achieved only 72.7% accuracy and was most frequently confused with four (cztery) in 13.3% of cases.

The Float32 CRNN model exhibited generally strong per-class performance. The weakest classes were yes (tak) at 89.1%, one (jeden) at 91.7%, and go (iść) at 92.6%; the latter was occasionally misclassified as five (pięć) in 3.6% of cases.

In the Float32 DS-CNN model, the weakest class was go (iść) at 88.8%, which was most frequently misclassified as five (pięć) in 6.7% of instances. The remaining classes maintained uniformly high per-class accuracy.

Following INT8 quantization, the BC-ResNet model exhibited a substantial accuracy degradation for the keyword bird (ptak), which fell to 39.9%. This word was most frequently recognized as yes (tak) (24.3%), two (dwa) (16.9%), and four (cztery) (7.4%), representing the most pronounced per-class degradation observed across all quantized models.

In the quantized CNN model, the keyword bird (ptak) dropped to 61.7%, with yes (tak) accounting for 21.0% of misclassifications. The class seven (siedem) also declined to 68.7% accuracy, primarily due to confusion with four (cztery) in 14.7% of cases.

For the quantized CRNN architecture, the majority of classes maintained satisfactory accuracy. The weakest classes were yes (tak) at 85.9%, seven (siedem) at 87.7% (confused with one (jeden) in 4.1% of cases), and go (iść) at 87.8% (confused with five (pięć) in 5.9% of cases).

In the quantized DS-CNN model, the weakest class was go (iść) at 80.9%, most frequently misclassified as five (pięć) in 13.4% of instances. The class dog (pies) also declined to 82.6% accuracy, with the primary source of confusion being five (pięć) in 10.6% of cases.

6. Discussion

Experimental results demonstrate that deploying high-accuracy Keyword Spotting (KWS) on a resource-constrained microcontroller like the RP2350 requires navigating various trade-offs. No single model excelled across all metrics, which included full-precision accuracy, robustness to INT8 quantization, memory footprint, and inference speed. Instead, each architecture offers distinct advantages, meaning the best choice depends heavily on the specific constraints of the target application.

In the full-precision (Float32) tests, the BC-ResNet model achieved the highest accuracy at 97.81% while remaining highly parameter-efficient, utilizing only 13,450 parameters. The DS-CNN and CRNN followed closely with scores of 97.06% and 96.19%, respectively. Conversely, the standard CNN lagged significantly at 88.68%, despite containing a massive 75,982 parameters. This confirms that architectures specifically designed for the time and frequency structures of speech—such as the specialized features in DS-CNN [3] and BC-ResNet—capture [6] audio patterns far more effectively than generic convolutional layers.

When INT8 quantization was applied to compress the models, the robustness rankings inverted. The CRNN proved most resilient, losing only 1.91 percentage points (96.19% → 94.28%), making it the most accurate quantized model. The DS-CNN experienced a moderate drop (97.06% → 93.13%). The BC-ResNet, however, suffered the most significant decrease, losing 5.08 percentage points (97.81% → 92.73%). This fragility was particularly noticeable with phonetically similar keywords; for instance, the Polish command ptak (bird) dropped to a 39.9% accuracy rate, frequently being confused with tak (yes) and dwa (two) (see Figure 8b). This sensitivity is likely due to BC-ResNet’s reliance on precise mathematical mappings for frequency analysis [6], where the reduced dynamic range of 8-bit arithmetic erodes critical spectral details. In contrast, the CRNN focuses more on temporal changes, making it more tolerant of minor rounding errors.

The impact of quantization on memory footprint also varied by architecture. The CNN and DS-CNN compressed significantly, shrinking down to 79.44 KB and 46.15 KB, respectively, making the DS-CNN the smallest deployed model in the study. The CRNN compressed only modestly by 16.5% to 182.62 KB, remaining the largest quantized model, as a significant portion of its footprint is attributed to metadata and structural elements rather than core weights. Strikingly, the BC-ResNet barely compressed at all, moving from 104.98 KB to just 101.97 KB. Because it already relies on very few parameters, its overall size is dominated by structural overhead rather than weight storage. Furthermore, the memory saved by compressing these few weights to 8 bits is almost entirely offset by the additional quantization metadata required by framework, such as scale and zero-point parameters for each tensor. This demonstrates that quantization does not uniformly result in a fourfold size reduction; the actual savings depend heavily on the model’s architectural design.

Inference latency, measured directly on the RP2350 (Table 3 and Table 4), revealed further differences. The DS-CNN experienced the most significant speed improvement from quantization, dropping from $1693.7$ $\mathrm{m}$$\mathrm{s}$ to $311.3$ $\mathrm{m}$$\mathrm{s}$ (a 5.4× speedup). The standard CNN achieved the fastest quantized inference at $107.5$ $\mathrm{m}$$\mathrm{s}$; however, given its lower accuracy of 85.32%, it is better suited as a low-power trigger than as a primary recognizer. The CRNN provided a strong balance, combining the highest quantized accuracy with a competitive $150.3$ $\mathrm{m}$$\mathrm{s}$ latency. Conversely, the BC-ResNet gained minimal speed, shifting from $579.1$ $\mathrm{m}$$\mathrm{s}$ to $501.9$ $\mathrm{m}$$\mathrm{s}$, only 1.15×. Despite having the lowest parameter count, its specific operations do not map efficiently to the integer kernels of the runtime system, making the most parameter-lean architecture paradoxically one of the slowest.

An analysis of classification errors across all architectures revealed a tendency to confuse words with similar phonetic structures. In the Polish dataset, ptak (bird) and tak (yes) share near-identical vocalic nucleus and coda, while iść (go) was frequently confused with pięć (five). Such pairs become increasingly difficult to distinguish as the effective spectral resolution is lowered by quantization. This pattern suggests that while Post-Training Quantization is sufficient for more robust architectures, Quantization-Aware Training [7] would likely be necessary for sensitive models like the BC-ResNet to preserve the subtle acoustic cues needed to separate these similar words.

The successful implementation on the custom PCB validated the RP2350 as a robust platform for TinyML. The ARM Cortex-M33 cores provided sufficient computational power, in particular by exploiting the DSP extension instructions of the Armv8-M architecture, which accelerate both the MFCC feature extraction (via the CMSIS-DSP library) and the quantized neural-network kernels (via the CMSIS-NN backend used by TensorFlow Lite for Microcontrollers). Future research could explore utilizing the dual-core capability of the RP2350 to pipeline the MFCC extraction and neural network inference stages, potentially decreasing latency further.

A key limitation of this study is that all reported metrics were obtained on the pre-recorded, augmented evaluation corpus rather than on live audio captured through the on-board acquisition chain. Consequently, the accuracy and F1-scores characterize the models together with the INT8 quantization and on-device latency behavior, but not the complete microphone-to-decision pipeline. Preliminary tests using live input from the electret-microphone front-end exhibited a marked degradation in recognition accuracy relative to the dataset evaluation. We attribute this gap primarily to a domain mismatch between the crowd-sourced training corpus and the audio captured by the custom front-end rather than to the network architectures themselves, which performed consistently on in-domain data. Acoustic analysis of the raw recordings (Table 5) substantiates this attribution along two independent dimensions: SNR estimated from the lowest-energy decile of $20\mathrm{ms}$ frames (used as a noise-floor proxy in the absence of explicit silence segments) averaged $9.7\mathrm{dB}$ ($\sigma =1.7\mathrm{dB}$, range $6.3$–$11.8\mathrm{dB}$), well below the $20\mathrm{dB}$ threshold commonly required for reliable speech processing, and spectral analysis revealed a mean $-20\mathrm{dB}$ roll-off at $1.5\mathrm{kHz}$ ($\sigma =0.4\mathrm{kHz}$), far below the $4\mathrm{kHz}$ lower bound expected for narrowband-grade speech capture. RMS levels were consistent across recordings (range $4.9\mathrm{dB}$) and no clipping was detected, ruling out gain misconfiguration or front-end saturation as contributing factors. Closing this gap will require characterizing and calibrating the analog front-end, collecting an in-domain dataset recorded directly through the target hardware, and applying domain-adaptation techniques together with quantization-aware training; we regard this microphone-level validation as essential future work before the prototype can serve as a consumer-grade voice interface.

7. Conclusions

This work presented a complete, hardware-validated keyword-spotting solution for the Polish language on a severely resource-constrained microcontroller. Three compact architectures from the CNN, CRNN, and DS-CNN families were designed and benchmarked against the state-of-the-art BC-ResNet reference, both in full precision and after INT8 quantization, with latency measured directly on the Raspberry Pi Pico 2 (RP2350).

The results show that no single architecture is optimal across all deployment criteria. BC-ResNet achieved the highest full-precision accuracy (97.81%) but proved the most fragile under quantization, whereas the proposed CRNN was the most robust and the most accurate quantized model (94.28%), the DS-CNN yielded the smallest INT8 footprint (46.15 KB), and the CNN delivered the lowest latency ( $107.5$ $\mathrm{m}$$\mathrm{s}$). Notably, the accuracy ranking inverted after quantization, the memory savings were highly non-uniform across architectures, and all quantized models met the one-second real-time budget on the target device. Error analysis further revealed that the dominant failure mode is the confusion of phonetically similar Polish words (e.g., ptak/tak, iść/pięć), which is exacerbated by the reduced numerical precision of INT8 arithmetic.

These findings provide practical guidance for selecting and quantizing small-footprint KWS models for Polish and other consonant-rich, morphologically rich languages. The principal open challenge is bridging the gap between dataset-based evaluation and live microphone operation; addressing the acquisition-chain and domain-mismatch limitations discussed above, together with quantization-aware training, is the natural next step toward a deployable, always-on Polish voice interface.