# Real-Time Arabic Digit Spotting with TinyML-Optimized CNNs on Edge Devices

Yasmine Abu Adla, Mazen Saghir, Mariette Awad

► To cite this version:

Yasmine Abu Adla, Mazen Saghir, Mariette Awad. Real-Time Arabic Digit Spotting with TinyML-Optimized CNNs on Edge Devices. 19th IFIP International Conference on Artificial Intelligence Applications and Innovations (AIAI), Jun 2023, León, Spain. pp.527-538, 10.1007/978-3-031-34111-3_44. hal-05449812

HAL Id: hal-05449812

https://inria.hal.science/hal-05449812v1

Submitted on 9 Jan 2026

HAL is a multi-disciplinary open access
archive for the deposit and dissemination of sci-
entific research documents, whether they are pub-
lished or not. The documents may come from
teaching and research institutions in France or
abroad, or from public or private research centers.

L'archive ouverte pluridisciplinaire HAL, est
destinée au dépôt et à la diffusion de documents
scientifiques de niveau recherche, publiés ou non,
émanant des établissements d'enseignement et de
recherche français ou étrangers, des laboratoires
publics ou privés.

<figure><img src="image_1.png" /></figure>

Distributed under a Creative Commons CC BY 4.0 - Attribution - International License
<figure><img src="image_2.png" /></figure>

ifip

International Federation for Information Processing

This document is the original author manuscript of a paper submitted to an IFIP
conference proceedings or other IFIP publication by Springer Nature. As such, there
may be some differences in the official published version of the paper. Such
differences, if any, are usually due to reformatting during preparation for publication or
minor corrections made by the author(s) during final proofreading of the publication
manuscript.
<figure><img src="image_3.png" /></figure>

# Real-Time Arabic Digit Spotting with TinyML-Optimized CNNs on Edge Devices

Yasmine Abu Adla(✉), Mazen A. R. Saghir, and Mariette Awad

Department of Electrical and Computer Engineering,
American University of Beirut, Beirut, Lebanon
{yaa41,mazen,ma162}@aub.edu.lb

**Abstract.** TinyML is a rapidly evolving field at the intersection of machine learning and embedded systems. This paper describes and evaluates a TinyML-optimized convolutional neural network (CNN) for real-time digit spotting in the Arabic language when executed on three different computational platforms. The proposed system is designed to recognize a set of Arabic digits from a continuous audio stream in real-time, enabling the development of intelligent voice-activated applications on edge devices.

Our results show that our TinyML-optimized CNN model can achieve 90%-93% inference accuracy, within 0.06-38 ms, while occupying only 19-139 KB of memory. These results demonstrate the feasibility of deploying a CNN-based Arabic digit spotting system on resource-constrained edge devices. They also provide insights into the trade-offs between performance and resource utilization on different hardware platforms. This work has important implications for the development of intelligent voice-activated applications in the Arabic language on edge devices, which enables new opportunities for real-time speech processing at the edge.

**Keywords:** TinyML · Convolutional Neural Network · Real-time Digit Spotting · Model Compression · Edge Devices

## 1 Introduction

Voice assistants like Apple Siri, Google Assistant, and Amazon Alexa are widely used in smart phones and speakers to search for information, play media, and control home appliances [3]. Voice assistants rely on sophisticated machine learning (ML), deep learning, and natural language processing models to process and understand speech. The models are based on deep, complex, neural networks that require large data storage and intensive computations for both training and inference. And because smart phones and speakers have limited resources to store and run these models, speech queries are typically processed in cloud data centers. To operate reliably, these devices therefore require high-bandwidth access to the Internet. However, as more speech-enabled devices come online,
it will become harder to provide the necessary communication, storage, and
compute bandwidth to handle the increased speech traffic in cloud data centers.
To address this problem, researchers in industry and academia are developing
techniques to compress machine learning models so they can run on resource-
limited devices deployed closer to their data sources at the edge of the cloud [5].
For example, Google, who developed the popular TensorFlow machine learn-
ing framework, has also developed TensorFlow Lite (TFLite) to compress large
machine learning models and deploy them on smart phones and edge devices.
More recently, Google introduced Tensorflow Lite for Microcontrollers (TFLM)
to enable tiny machine learning (TinyML) models to run on inexpensive and
resource-constrained microcontrollers. TFLM applies a number of compression
techniques to compress TensorFlow Lite models, but little is known about how
best to apply these techniques or their actual impact on the size, accuracy, and
prediction time of compressed machine learning models.

In natural language processing, keyword spotting from an audio stream is
a challenging task in any language. But Arabic presents unique challenges com-
pared to other languages. A major challenge is the variability of Arabic dialects,
which can lead to differences in pronunciation that affect the acoustic signal.
Arabic has a rich and complex phonetic system, with many phonemes that are
not present in other languages. This makes it more difficult to develop a robust
acoustic model that can accurately recognize keywords in different dialects and
accents. In addition, the presence of diacritical marks in Arabic can further com-
plicate the recognition process, as these marks can change the sound of the letters
and affect the acoustic features of the signal. These factors, combined with the
scarcity of research in this area, make the development and evaluation of Ara-
bic keyword spotting systems more complex than in other languages. However,
addressing these challenges can lead to more accurate and reliable systems that
can improve the accessibility and usability of digital tools for Arabic speakers.

In this paper, we use TinyML optimizations to achieve real-time Arabic digit
spotting using convolutional neural networks running on edge devices. Our app-
roach is designed to recognize a set of Arabic digits from a continuous audio
stream in real-time, enabling the development of intelligent voice-activated appli-
cations on edge devices. We trained and optimized our CNN models using Ara-
bic speech datasets and deployed them on three different computational devices:
a commercial laptop computer, a Raspberry Pi single-board computer, and an
Arduino microcontroller. We compared the execution of our model on these
devices under different TinyML optimizations and evaluated its performance in
terms of accuracy and latency. Our results demonstrate the viability of deploying
a TinyML-optimized CNN-based Arabic digit spotting system on edge devices,
which reduces the dependence on cloud deployments. Our approach also pro-
vides insights into the trade-offs between performance and resource utilization
on different hardware platforms, which can inform the development of future
edge devices with optimized performance and power efficiency. The findings
of this research have important implications for the development of intelligent
voice-activated applications on edge devices, which can enhance the accessibility and convenience of smart systems for a wider range of users.

Our paper is organized into five sections. In Section II we provide an overview of TinyML. Then, in Section III, we present our CNN model, and in Section IV we present the impact of the different compression techniques on the size, accuracy, and prediction time of our model. Finally, in Section V we present our conclusions and describe future work.

## 2 Overview of TinyML

TinyML is a rapidly evolving field at the intersection of machine learning and embedded systems. It enables the processing of deep learning algorithms of high accuracy on microcontrollers (MCUs) in applications that require low latency or have limited communication bandwidth access. TinyML enables compressed ML models to be deployed on resource-constrained and communication-limited microcontrollers without compromising accuracy [8,14]. This offers several advantages over deploying ML models in the cloud, including:

1. **Lower Latency:** Deploying and running models locally eliminates the overhead of transferring data to, and results from, the cloud. It also eliminates the added latency of queueing and scheduling inference tasks in the cloud. In interactive or safety-critical applications, low-latency inference is a key advantage.

2. **Less Data Exchange:** By running inference locally, only results with high information content need be shared with higher-level functions in the cloud. This greatly reduces the volume of data that needs to be exchanged and saves communication bandwidth.

3. **Lower Cost and Energy Consumption:** Because they can run on inexpensive and low-power microcontrollers, TinyML models are more cost- and energy-efficient than their cloud counterparts. This enables them to run for months, and even years, using small batteries or energy harvesting circuits.

4. **Higher Privacy and Security:** For data-sensitive applications, processing data locally enhances its privacy. It also makes it easier to employ adequate measures to secure the data including running the models offline.

### 2.1 TinyML Frameworks

Several Integrated Development Environments (IDEs) are available for generating TinyML models. These include Edge Impulse, Microsoft's Embedded Learning Library (ELL), ST Microelectronics' STM32Cube.AI, and ARM's ARM-NN SDK [4, 10, 15]. These IDEs generate TinyML models developed using common ML frameworks like Keras, ONNX, or TensorFlow into quantized and machine optimized models expressed in a high-level language. IDEs for STM and ARM microcontrollers are designed to generate optimized models for specific microcontroller families, and are therefore unable to support other hardware platforms.
On the other hand, TFLM and Edge Impulse support a wide range of devices, which is why we decided to use these two IDEs to develop and optimize our models and deploy them on different computational devices.

**Google TensorFlow Lite for Microcontrollers.** Google's TFLM is a platform for generating TinyML models. It consists of a *converter* that transforms Tensorflow Lite models into serialized FlatBuffer models [1]. The FlatBuffers serialization library uses schemas to transform hierarchical data structures into flat binary buffers implemented as C++ arrays. The buffers are smaller than the original data structures, and they can be accessed without the need to parse or unpack data. This makes them especially well suited for use in bare metal embedded systems. TFLM also includes an *interpreter*, which is a lightweight runtime engine that runs the TFLite model on the device and uses code generated from the FlatBuffers schema to access data efficiently. The TFLite interpreter executes a series of pre-compiled operations that make up the TFLite model. Each operation corresponds to a mathematical operation or transformation, such as convolution or activation, that is applied to the model's input data. The interpreter uses optimized algorithms and data structures to perform these operations efficiently on the device. It also abstracts the underlying hardware, making it easy to port a TinyML model to different microcontrollers and apply hardware-independent optimizations to a model.

**Edge Impulse.** Edge Impulse (EI) is a comprehensive platform for building, testing, and deploying machine learning models on edge devices. It provides a web-based interface that allows users to easily upload and label their own data, train machine learning models, and deploy them to edge devices. Once the models are trained, EI provides optimized libraries for running them on a variety of edge devices, including microcontrollers, embedded processors, and smartphones. The libraries are optimized for memory and processing efficiency, allowing models to run in real-time on resource-constrained devices. One of the key features of EI is its ability to generate optimized C code from machine learning models trained on the platform. This allows users to deploy their models directly to edge devices, without the need for additional libraries or runtime environments. To generate C code from a machine learning model, EI uses a tool called the Enterprise Objects Framework (EON) Compiler. The EON Compiler takes a trained model and generates C code that implements the model's inference algorithm. The generated code is optimized for memory and processing efficiency, and is designed to run on a specific hardware platform.

## 2.2 Techniques for Model Compression

One of the most challenging aspects of deploying ML algorithms, such as Neural Networks, are satisfying their software and hardware requirements. When running complex ML algorithms on embedded devices, it is necessary to consider the small memory size and limited computational power of MCUs. In fact, the ML
model, with all its parameters, weights, and connections, must be small enough
to fit on MCUs that have constrained on-chip SRAM memory (192–512 KB) and
flash memory (256 KB–2 MB).

To overcome the main challenges and limitations that of running TinyML
on embedded platforms, EI and TensorFlow Lite use a variety of techniques to
compress machine learning models. Specifically, for speech recognition applica-
tions, the optimizations are applied to sequence models such as CNNs, Recurrent
Neural Networks (RNNs), or Long Short-Term Memory (LSTM) networks. This
section provides an overview of the common techniques used by EI and TFLite
for compressing ML models.

**Quantization.** Quantization is a technique that significantly reduces the memory footprint of a deep neural network without compromising the model's accuracy [11]. It is based on reducing the number of bits used to represent a model's parameters. Quantization usually replaces 32-bit floating-point values produced during training with 16-bit floating-point or 8-bit fixed-point values that are used during inference. In addition to reducing the amount of memory needed to store a model, quantized models can usually run faster because they use simpler integer arithmetic units to operate on data.

There are two main approaches to quantization. In *quantization-aware training* [7], expected quantization errors due to inference are used during training to learn quantized model parameter values. This technique is time consuming, but it reduces the size of a model and enhances its accuracy at the same time [11]. In *post-training quantization*, model parameter values are quantized after a model has been trained. This approach generates quantized models more quickly but generally achieves lower model accuracy. However, in some cases, higher quantization errors can help a model generalize better, which increases model accuracy over new data [11]. In this study, we explore three forms of post-training quantization:

- **Float16 Quantization:** A model's 32-bit floating-point weights and activations are converted to 16-bit, half-precision, IEEE floating-point values [1].

- **Dynamic Range Quantization:** A model's weights are converted from 32-bit floating-point to 8-bit fixed-point, but activations are stored as 32-bit floating point values. During inference, activations are quantized dynamically to 8-bit fixed-point values based on their dynamic ranges. This helps reduce model execution latency [6].

- **Integer Quantization:** A model's weights and activations are converted to the nearest 8-bit fixed-point values. To guide quantization, representative data sets are used to drive the TensorFlow Lite converter and provide information about the dynamic ranges of different model parameters [6].
# 3 TinyML-Based CNNs for Real-Time Arabic Digit Spotting

Developing a TinyML model begins by developing a regular ML model and optimizing it to meet desired size and performance objectives. In this section we detail the steps we followed to develop a TinyML model for real-time Arabic Keyword spotting. We first describe the dataset used and the steps we followed to pre-process and clean the data. We then explain how we chose our ML model and discuss the experimental methods we followed to conduct our study.

## 3.1 Dataset

Our dataset consists of isolated single Arabic words spoken in the *Khaleejí* dialect<fnref n="1" /> [2]. The words consisted of Arabic digits (0–9) spoken by 50 middle-aged men. Each subject recorded each digit ten times in a noise-free environment. Although this dataset may result in a model biased toward male speakers and the *Khaleejí* dialect, our focus in this study was to evaluate the impact of compression techniques on the size and performance of a suitable TinyML model. An expanded data set that includes samples from mixed-gender speakers in a variety of dialects can reduce or eliminate these biases.

## 3.2 Data Pre-processing and Cleaning

Before using the dataset to develop and train a suitable ML model, we pre-processed and cleaned the data by extracting its Mel-frequency cepstral coefficients (MFCCs) and normalizing the results, respectively. Extracting MFCCs is a common approach to pre-processing speech samples. The Mel frequency cepstrum is a method for capturing a speech sample's short-term power spectrum. MFCCs provide information about the spectral characteristics of the speech sample, enabling them to be used as input features to an ML model [13].

The MFCC values for a given speech sample are expressed as a matrix with 12 columns corresponding to the calculated cepstral values and a number of rows corresponding to the duration of a sample. Because there are variations in the time is taken to utter different digits, the number of rows for MFCC matrices can vary. To ensure that the ML model will process all speech samples uniformly, we used the maximum number of rows to express all MFCC matrices, and we set to zero any unused rows associated with a speech sample. We also verified that setting unused rows in an MFCC matrix to zero did not change or corrupt the corresponding speech samples when transformed back to the time domain.

## 3.3 Automatic Speech Recognition Models

For this study, we evaluated the performance of CNNs and LSTM networks for keyword spotting in Arabic speech. While LSTMs have been shown to achieve

<footnote n="1">¹ The dialect spoken in Arab states around the Persian Gulf.</footnote>
high accuracy on a variety of speech recognition tasks, they generally have a larger memory footprint compared to CNNs. For our dataset, the CNN-based model achieved an accuracy of 93% with a memory footprint of 139 KB, while the LSTM model achieved an accuracy of 95% with a memory footprint of 10,365 KB. Given the comparable accuracy and significantly smaller memory footprint of the CNN-based model, we decided to use it for our system. This decision allowed us to deploy our model on a range of computational devices with varying levels of memory and processing power.

We developed the CNN-based model for Arabic keyword spotting using the Keras Tuner with Bayesian Optimization [9]. We assessed over 20 design iterations using the TensorFlow framework to build the optimal model architecture. Figure 1 shows the final structure of our CNN model. The model consists of two Convolutional Neural Network (CNN) layers with 8 and 16 filters, respectively, and a kernel size of 3. The ReLU activation function is used for both layers, and a dropout rate of 0.25 is applied after each pooling layer to prevent overfitting. The max-pooling layer with a pool size of 2 and stride of 2 is applied after each convolutional layer. The output from the second pooling layer is flattened, and a softmax activation function is applied to the final dense layer with the number of neurons equal to the number of classes (i.e., 10 for digit recognition).

We trained our CNN model on data from 35 speakers (70%), out of which 10% was used for validation, and tested them on the remaining 15 speakers (30%). We also used an Adam optimizer, a categorical cross entropy loss function, and optimized for accuracy. During training we used a batch size of 32 on 100 epochs.

## 3.4 Choice of Computational Platform

The choice of computational platform plays a significant role in determining the overall performance of an edge AI application. In our study, we evaluated the performance of our spoken digit recognition model on three different platforms: a laptop computer, Raspberry Pi SBC, and Arduino Nano BLE microcontroller. The laptop computer is a powerful device capable of running complex machine learning models with ease, but it requires a significant amount of power and is not suitable for battery-powered applications. The Raspberry Pi is a popular choice for edge AI applications as it offers a balance between performance and power consumption. It has a relatively low cost and can be used for a wide range of applications. The Arduino Nano 33 BLE, on the other hand, is a microcontroller that is suitable for low-power applications. While it may not have the processing power of the Raspberry Pi or the laptop computer, it can still perform basic machine learning tasks well, and is ideal for battery-powered applications.

Table 1 compares the technical specifications of three devices that can be used for model deployment: laptop computer, Raspberry Pi 4 Model B, and Arduino Nano 33 BLE Sense [12].
<figure><img src="image_4.png" /><figcaption>Fig. 1. Our CNN Model</figcaption></figure>

<table><caption>Table 1. Computational Platforms</caption><thead><tr><td>Platform</td><td>Processor</td><td>Cores</td><td>Frequency</td><td>Memory (RAM)</td><td>Memory (Flash)</td><td>Price</td></tr></thead><tbody><tr><td>Dell Latitude 5410 Laptop Computer</td><td>64-bit Intel Core i5-10210U</td><td>4</td><td>1.6 GHz</td><td>16 GB</td><td>1 TB</td><td>$1000.00</td></tr><tr><td>Raspberry Pi 4 Model B</td><td>64-bit ARM Cortex-A72</td><td>4</td><td>1.4 GHz</td><td>2 GB, 4 GB, or 8 GB</td><td>32 GB</td><td>$30.00</td></tr><tr><td>Arduino Nano 33 BLE Sense</td><td>32-bit ARM Cortex-M4</td><td>1</td><td></td><td>256 KB</td><td>1 MB</td><td>$32.00</td></tr></tbody></table>

## 4 Impact of Model Compression

In our study, we evaluated the performance of the machine learning models on three different computational platforms. For the laptop computer and Raspberry Pi, we used TensorFlow Lite (TFLite) to deploy the models, while for the Arduino microcontroller, we used Edge Impulse's EON compiler. We chose TFLite for the laptop and Raspberry Pi due to its compatibility with a wide range of devices and its support for optimized inference on mobile and
embedded devices. On the other hand, we chose EON for the Arduino Nano since it provides a seamless integration of machine learning models with low-powered microcontrollers.

In this section we present the results of applying different compression techniques to our TensorFlow baseline model when converting our model to TFLite or to C code using the EON compiler provided by EI. We then evaluate the performance of the models in terms of accuracy and latency when deploying them on a Laptop, Raspberry Pi, and Arduino Nano MCU.

## 4.1 Impact on Parameter and Model Size

We measured the memory footprint of the ML models on each platform, including the RAM and flash memory usage. On the Arduino Nano, we measured only the flash and random access memory (RAM) memory usage, while on the Raspberry Pi and laptop, we measured the RAM usage. This information was crucial in selecting the appropriate platform and model compression techniques to ensure that the models can satisfy the memory constraints of each platform while maintaining the desired accuracy.

Our baseline CNN model uses 8,151 parameters and requires 139 KB of storage. On the other hand, all compressed models use 3,597 parameters. This corresponds to a 56% reduction, but it is noteworthy that beyond the optimizations of the TFLite model, the different compression optimizations do not seem to impact the number of model parameters.

Table 2 shows the impact of these optimizations on the number of model parameters and size for the CNN model. In terms of model size, the TFLite model requires 19 KB of storage on both the laptop computer and Raspberry Pi. This corresponds to a 86% size reduction compared to the baseline model and is likely due to the use of Flat Buffers.

Applying integer quantization optimization to the TFLite model further reduces its size to 10 KB. Applying the EON framework on the float32 model gave us a model that required 8.4 KB of RAM usage and 27.8 KB of flash usage. On the other hand, using the EON framework to quantize the model to 8-bit integer format changed the memory footprint to 5.1 KB of RAM and 29.1 KB of flash. It is worth noting that the increase in flash memory usage from 27.8 KB to 29.1 KB when changing from Float32 to Int8 can be attributed to several factors. First, the EON compression algorithm may not perform as well on integer data compared to floating-point data. This is because the compression algorithm is optimized for floating-point numbers and may not be as effective when applied to integer data. Additionally, the overhead of the compression algorithm (such as storing the compression dictionary) may become more significant when the data size is smaller, which can also contribute to the increase in file size.
<table><caption>**Table 2.** Impact of Compression Optimizations on CNN Model Characteristics</caption><thead><tr><th>CNN Model</th><th>TensorFlow</th><th colspan="2">TensorFlow Compression</th><th colspan="2">EON Compression</th></tr><tr><th>Characteristics</th><th>Baseline</th><th>TFLite</th><th>Integer Quantization</th><th>Float32</th><th>Integer Quantization</th></tr></thead><tbody><tr><td>Number of Parameters</td><td>8,151</td><td colspan="2">3,597</td><td></td><td></td></tr><tr><td>Size (KB)</td><td>139</td><td>19</td><td>10</td><td colspan="2">RAM: 8.4 - Flash: 27.8 | RAM: 5.1 - Flash: 29.1</td></tr></tbody></table>

## 4.2 Impact on Model Accuracy

The accuracy of the CNN model refers to its ability to correctly classify its speech inputs. Figure 2 shows the accuracy of our spoken Arabic digit recognition models when executed on different computational platforms.

Both the TensorFlow baseline and TFLite models achieve comparable accuracies of 93% and 90%, respectively. This is likely due to the model structure not changing fundamentally beyond the more memory-efficient implementation of the TFLite model. Similarly, applying the quantization optimizations to the float32 model also achieves comparable accuracies of 90%. This again is likely due to quantization not changing model structures fundamentally.

Additionally, we found that our models achieved high accuracy on all platforms, with the highest accuracy achieved on the laptop platform. Specifically, the laptop achieved an accuracy of 93%, the Raspberry Pi achieved an accuracy of 92%, and the Arduino achieved an accuracy of 90%. These results demonstrate the effectiveness of our approach in achieving high accuracy on resource-constrained edge devices. We also note that the differences in accuracy between the three platforms are relatively small, indicating that our models are robust to variations in hardware and can perform well on a range of devices.

<figure><img src="image_5.png" /><figcaption>**Fig. 2.** Accuracy for Different Platforms and Compressions</figcaption></figure>
## 4.3 Impact on Inference Time

Fast inference is a critical aspect of deep learning models, especially in applications where real-time operation is necessary. Deep learning models have demonstrated remarkable performance in various domains, such as computer vision, speech recognition, and natural language processing. However, the high computational cost associated with these models can pose a challenge in real-world deployment, particularly in edge computing environments. Fast inference is essential for enabling real-time response to input data, which is especially important in time-sensitive applications. In addition, fast inference is essential for enabling the deployment of deep learning models on resource-constrained devices such as smartphones and embedded systems. Therefore, optimizing deep learning models for fast prediction is critical for their successful deployment in real-world applications.

In general, reducing the size of a ML model reduces its inference time. This is due to the corresponding reduction in the number of operations that need to be executed and, in the case of TFLite, faster access to model parameters using efficient data structures like Flat Buffers. We observed this after converting our baseline TensorFlow model to a TFLite model, which reduced inference time from 38 ms to 11 ms and 0.057 ms, when running it on the laptop computer (baseline and TFLite) and the Raspberry Pi (TFLite), respectively. On the other hand, when we applied the TFLite quantization optimizations we observed different results. When deploying the CNN on the laptop computer or the Raspberry Pi, integer quantization achieved an inference time of 0.9 ms and 0.15 ms, respectively.

When running the uncompressed float32 digit spotting model on the Arduino Nano microcontroller, we observed a relatively high latency of 113 ms. This is likely due to the limited computational power and memory resources of the device, which result in longer processing times for the model. However, when we applied the EON integer 8 quantization technique we were able to reduce inference time on the Arduino Nano microcontroller from 113 ms (float32) to 5 ms (int8), respectively. These results demonstrate the viability of using TinyML optimization methods to achieve fast inference times for real-time speech processing applications.

# 5 Conclusions and Future Work

In this paper we explored the performance, latency and memory footprint of a real-time Arabic digit spotting model on different computational platforms. Our results demonstrate that the choice of platform can have a significant impact on both the latency and accuracy of a model. Specifically, we found that the Arduino Nano microcontroller, while having limited computational power, was still able to run a model with acceptable accuracy and latency. On the other hand, the Raspberry Pi and laptop computer were able to run the model with higher accuracy and lower latency due to their higher computational performance.
Future work in this area could focus on optimizing the ML model for specific platforms, as well as exploring additional compression techniques to further reduce the memory footprint. Given the rapidly evolving field of edge computing, continued research in this area is important to ensure that ML workloads can be effectively deployed on a variety of edge computing devices.

## References

1. TensorFlow Lite for Microcontrollers. https://www.tensorflow.org/lite/microcontrollers

2. Alalshekmubarak, A., Smith, L.S.: On Improving the Classification Capability of Reservoir Computing for Arabic Speech Recognition. In: Wermter, S., et al. (eds.) ICANN 2014. LNCS, vol. 8681, pp. 225–232. Springer, Cham (2014). https://doi.org/10.1007/978-3-319-11179-7_29

3. Ammari, T., Kaye, J., Tsai, J.Y., Bentley, F.: Music, search, and IoT: How people (really) use voice assistants. ACM Trans. Comput. Hum. Interact. 26(3) (2019). https://doi.org/10.1145/3311956

4. ARM: ARM NN SDK. https://www.arm.com/products/silicon-ip-cpu/ethos/armnn

5. Cao, K., Liu, Y., Meng, G., Sun, Q.: An overview on edge computing research. IEEE Access 8, 85714–85728 (2020). https://doi.org/10.1109/ACCESS.2020.2991734

6. Amir, G., et al.: A survey of quantization methods for efficient neural network inference. arXiv preprint arXiv:2103.13630 (2021)

7. Benoit, J., et al.: Quantization and training of neural networks for efficient integer- arithmetic-only inference. In: Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2704–2713 (2018)

8. Reddi, J., et al.: Widening Access to Applied Machine Learning With TinyML. Harvard Data Sci. Rev. 4 (2022)

9. Keras: Bayesian Optimization Tuner

10. Microsoft: Embedded Learning Library (2020). https://microsoft.github.io/ELL/

11. Novac, P.-E., et al.: Quantization and deployment of deep neural networks on microcontrollers. Sensors 21(9), 2984 (2021). https://doi.org/10.3390/s21092984. https://arxiv.org/abs/2105.13331

12. Saha, S.S., Sandha, S.S., Srivastava, M.: Machine learning for microcontroller-class hardware: A review. IEEE Sens. J. 22(22), 21362–21390 (2022). https://doi.org/10.1109/jsen.2022.3210773

13. Sithara, A., Thomas, A., Mathew, D.: Study of MFCC and IHC feature extraction methods with probabilistic acoustic models for speaker biometric applications. Proc. Comput. Sci. 143, 267–276 (2018)

14. Soro, S.: TinyML for Ubiquitous Edge AI (2021). arXiv preprint arxiv.org/2102.01255 https://doi.org/10.48550/ARXIV.2102.01255

15. STMicroelectronics: Artificial Intelligence Ecosystem for STM32. https://www.st.com/content/stcom/en/ecosystems/artificial-intelligence-ecosystem-stm32.html