On-Device Preprocessing

Digital filtering (e.g., Butterworth, Chebyshev) removes noise and isolates frequency bands of interest from raw sensor streams. Windowing functions (e.g., Hamming, Hann) are applied to finite data segments before spectral analysis to minimize spectral leakage in the Fast Fourier Transform (FFT). This is foundational for audio, vibration, and biomedical signal processing on devices like microphones and accelerometers.

• Example: Applying a 50Hz notch filter to remove power line interference from an ECG signal before feature extraction.

This involves calculating statistical features (mean, variance, skewness) and domain-specific features (Zero-Crossing Rate, Spectral Centroid, Mel-Frequency Cepstral Coefficients) from preprocessed data. Dimensionality reduction techniques like Principal Component Analysis (PCA) project high-dimensional features into a lower-dimensional space, preserving essential information while drastically reducing the input size for the downstream model. This step converts raw signals into a compact, informative representation suitable for inference.

• Example: Extracting 13 MFCCs from a 1-second audio frame to represent speech for a keyword spotting model.

These are scaling techniques applied per sensor channel to ensure stable and efficient model training/inference. Normalization rescales data to a fixed range, typically [0, 1] or [-1, 1]. Standardization transforms data to have zero mean and unit variance. On-device, scaling parameters (min/max or mean/std) are calculated from a calibration dataset and stored as fixed constants in the firmware. This corrects for sensor gain drift and environmental variations.

• Example: Standardizing accelerometer readings (x, y, z) using pre-computed mean and standard deviation values stored in Flash memory.

To run efficiently on microcontrollers without Floating-Point Units (FPUs), preprocessing algorithms are implemented using fixed-point arithmetic. This represents numbers using integers with an implicit scaling factor (the binary point). It requires careful management of bit precision, overflow, and rounding to maintain numerical stability. Libraries like CMSIS-DSP provide optimized fixed-point FFT and filter functions for Arm Cortex-M processors.

• Example: A 256-point FFT implemented using Q15 (1.15) fixed-point format on a Cortex-M4, using saturating arithmetic to prevent overflow.

For continuous sensor streams, preprocessing operates on a sliding window of the most recent samples. This requires a circular buffer in memory that efficiently overwrites old data with new samples. The algorithm processes the window at a fixed interval (e.g., every 100ms) or when the buffer is full. This design minimizes memory copies and ensures low-latency, continuous feature generation for real-time applications like gesture recognition or anomaly detection.

• Example: A 1-second audio buffer (16 kHz sampling rate) slides by 0.5 seconds, triggering MFCC extraction every 500ms.

In multi-modal systems, data from different sensors (e.g., IMU, microphone, camera) must be fused. This involves temporal alignment (synchronizing timestamps), spatial alignment (transforming coordinates to a common frame), and algorithmic fusion (e.g., Kalman Filtering, Complementary Filters). On-device, this creates a unified, robust representation from heterogeneous, noisy inputs, which is critical for applications like inertial navigation or context-aware sensing.

• Example: Fusing accelerometer and gyroscope data with a complementary filter to estimate stable device orientation.

This is the most direct application. Transmitting raw, high-frequency sensor data (e.g., audio waveforms, accelerometer streams) is often infeasible or prohibitively expensive. On-device preprocessing extracts only the relevant features, drastically reducing payload size.

• Example: A vibration sensor sampling at 4 kHz generates ~32 kbps of raw data. Applying a Fast Fourier Transform (FFT) on-device and transmitting only 10 dominant frequency bins reduces data by over 99%.
• This enables viable operation over low-power wide-area networks (LPWAN) like LoRaWAN or NB-IoT, where bandwidth is scarce and power for radio transmission is the primary battery drain.

Preprocessing acts as a first line of privacy defense. By converting sensitive raw data into anonymized features on the device, the risk of exposing personal or proprietary information is minimized.

• Critical for Federated Learning: In a federated edge learning system, devices share model updates, not raw data. On-device preprocessing ensures that even the intermediate data used for local training never leaves the device.
• Example: A smartwatch converts raw PPG (photoplethysmogram) signals into heart rate variability features on-device. Only these abstract features are used for local model personalization, never the raw blood volume pulse data.

For applications requiring immediate action, sending data to the cloud for processing introduces unacceptable latency. On-device preprocessing enables sub-second, deterministic response times.

• Key Applications: Keyword spotting for voice assistants, anomaly detection in industrial machinery, and gesture recognition for controllers.
• The pipeline involves streaming data through fixed, efficient algorithms (e.g., Mel-Frequency Cepstral Coefficients (MFCCs) for audio, digital filters for noise reduction) to create a continuous feature stream for the model, enabling real-time inference loops.

Edge devices often operate in environments with unreliable or non-existent network links. On-device preprocessing allows the device to function intelligently regardless of connection state.

• Data can be preprocessed and stored in a compact feature buffer locally, ready for transmission when a connection is restored.
• For on-device training, the preprocessed feature dataset is available continuously, allowing the local model to learn from new experiences even during extended offline periods, syncing only the model updates later.

Contrary to intuition, preprocessing on a microcontroller can be more energy-efficient than transmitting raw data. Radio transmission is often the most power-hungry operation on an IoT device.

• Trade-off Analysis: The energy cost of running a fixed-function DSP (Digital Signal Processing) routine or a small neural network feature extractor is frequently far lower than the energy required to power the radio and transmit the equivalent raw data volume.
• This optimization is central to extending the battery life of deployed sensors from days to years.

Sensor characteristics vary between hardware units and environments. On-device preprocessing standardizes the input, making the downstream model more robust and portable.

• Common Techniques: Sensor calibration, dynamic range adjustment, and per-channel normalization (e.g., subtracting mean, dividing by standard deviation computed over a local window).
• This is essential for heterogeneous clients in federated learning, as it helps align the data distribution across different device models and environments before local training, improving global model convergence.

Tiny Machine Learning (TinyML) is the subfield focused on developing and deploying ultra-low-power, memory-efficient models capable of running inference and training directly on microcontroller units (MCUs). It is the primary deployment target for federated edge learning systems. Key constraints include:

• Memory Footprint: Total RAM/Flash consumed by model parameters and runtime buffers.
• Compute Constraint: Limited processing power, measured in operations per second (OPS).
• Energy Budget: The total electrical energy allocated for computational tasks, dictating device lifetime.

On-device training is the process of updating a machine learning model's parameters directly on an edge device using locally generated data. This is a step beyond simple inference and is critical for:

• Enabling continual learning from local data streams.
• Facilitating personalized federated learning where models adapt to individual client distributions.
• Ensuring raw sensor data never leaves the device, aligning with the core privacy promise of federated learning. It operates under severe memory, compute, and energy constraints.

A suite of techniques essential for fitting models into TinyML constraints, directly impacting preprocessing efficiency. Core methods include:

• Quantization: Reducing numerical precision of weights/activations (e.g., 32-bit float to 8-bit int). Quantization-Aware Training (QAT) simulates this during training; Post-Training Quantization (PTQ) applies it after.
• Weight Pruning: Removing less important parameters (unstructured) or entire structures like channels (structured).
• Model Sparsification: Inducing sparsity in weights or gradients, enabling sparse updates for efficient federated communication. These techniques reduce the computational load of both the model and any integrated preprocessing steps.

A lightweight software library deployed on a microcontroller that manages the local client protocol for federated learning. For on-device preprocessing, this runtime is responsible for:

• Orchestrating the local training loop using the on-device dataset.
• Managing resource-constrained execution, potentially handling thermal throttling and battery drain.
• Integrating with preprocessing pipelines (e.g., applying a Fast Fourier Transform to sensor data) before the data is fed to the model.
• Enabling secure communication for sending model updates, not raw data.

An embedded system (e.g., microcontroller-based sensor) with severe limitations that define the TinyML challenge space. These constraints directly shape preprocessing design:

• Memory: Limits the size of preprocessing buffers and code (e.g., for filtering algorithms).
• Compute: Restricts the complexity of transformations (e.g., full video encoding vs. simple frame differencing).
• Energy: Dictates how often and how long preprocessing and training can run.
• Bandwidth: The need for preprocessing is driven by this constraint; transforming data locally reduces volume for transmission. Heterogeneous clients have varying levels of these constraints.

The continuous, real-time sequence of measurements (e.g., acceleration, temperature, audio) generated by an embedded sensor. This is the raw input for on-device preprocessing. Characteristics include:

• High Volume: Can quickly overwhelm storage and transmission budgets.
• Temporal Nature: Often requires windowing or buffering for transformations.
• Noisy: Preprocessing acts to clean and extract salient features (e.g., noise filtering, normalization).
• The On-Device Dataset is built from this stream. Effective preprocessing tailors this stream into the feature space expected by the TinyML model, maximizing information density for local training.