Sensor-Level AI: A 380-Parameter Architecture Resistant to Drift and Noise

Much attention is currently focused on the size of neural networks and the gigawatts of power consumed by data centers. However, the future lies not only in giant clusters but also in tiny chips embedded directly into the sensing elements of hardware. When a neural network is placed directly inside a sensor chip, it must be exceptionally efficient.

Through experimentation, I have successfully built a neural network architecture with 380 parameters (with potential for further reduction), capable of operating in conditions considered unsuitable for conventional algorithms.

Technology Stack

The main feature of the architecture is the capability to be embedded directly into the sensor logic:

• Integer-only Nature: The algorithm is implemented entirely using addition, subtraction, and bitwise shifts (int-only). This allows for the deployment of AI into controllers lacking a Floating Point Unit (FPU).

• Minimal Resource Footprint: The Nano-class model utilizes 380 trainable parameters. This allows the neural network and its overhead to fit within a couple of kilobytes of memory.

• Linearity and Stability: Only linear calculations are used. The system is not prone to nonlinear artifacts, inference uncertainty, or exploding gradients. If the signal exceeds normal limits, the architecture maintains predictability due to rigid physical constraints embedded in the structure.

• Environmental Robustness: Built-in protection against baseline drift and automatic adaptation to the noise floor.

• High Fault Tolerance: High resilience to neuron loss; in scenarios where chips operate unstably or suffer partial failure, the sensor continues to function.

Experiments conducted on synthetic data are presented below.

Used Network Tiers

In all experiments, the name Goliath refers to a classic Convolutional Neural Network (CNN) with standard convolution and pooling layers, lacking specific signal cleaning mechanisms.

Experiment 1: Algorithm Testing Without Task-Specific Tuning

The same architecture can solve different tasks without code modification—basic training is sufficient. Simple tuning dramatically improves noise resilience without increasing the model size. I tested the vanilla version of the new architecture (David) on three signal types: heart (ECG), bearing vibration, and accelerometer data.

TASK: ECG Rhythm

• D = David

• G = Goliath (Standard Neural Network)

TASK: BEARING (Bearing Vibration)

The most stable task for David: even under noise, accuracy exceeds 80% on the Medium size, and drift is completely ignored.

TASK: Pedometer (Accelerometer)

Here, David Large achieves 91% accuracy under drift + noise conditions, whereas Goliath merely guesses at 50%.

• Drift Invariance: David demonstrates 100.0% stability under 50g drift across all tasks. Meanwhile, the classic CNN (Goliath) degrades to the level of random guessing (~50%). This is direct proof that the architecture successfully separates the AC component (variable) from the DC component (constant).

• Noise Barrier: The performance drop in the HEART task (D_Noise3x) confirms the need for task-specific tuning.

• Scaling Advantage: As the size increases from Nano to Large, David adapts significantly better to noise while maintaining drift stability.

The result of Goliath (CNN) under drift at the 50% level is the mathematical equivalent of coin flipping. This proves that standard neuron weights get lost in the baseline offset, while David is architecturally transparent to the constant component.

Universal Model Results:

• Drift 50g: 100% accuracy (architectural immunity).

• Noise (baseline): 85–90% accuracy.

• Fault Tolerance: Retains functionality with random damage (pruning) of up to 30% of model weights.

Even without fine-tuning, David outperforms classic convolutional networks of similar size, which are susceptible to signal offsets.

Experiment 2: Dropout

This table demonstrates how the Large-sized model handles random neuron deletion under ideal conditions versus extreme signal drift.

Experiment 3: Task-Specific Tuning

I selected heart rhythm recognition under conditions of extreme chaos. The noise level exceeds the useful signal by a factor of 3 (SNR < 0.5), combined with drift. The tuning did not alter the core algorithm; the code remained practically unchanged. Accuracy and Stability (Std Dev) were measured over 20 independent runs.

• Parametric Parity (Row 3): David (380 parameters) catches up to Goliath Large (40,000 parameters) under noisy conditions.

• CNN Blind Spot (Rows 2 and 4): Standard convolutions handle drift much worse. Even the large model (Goliath Large) shows 49.2%, which is essentially guessing. For the CNN, the baseline offset is noise that it cannot filter without external preprocessing.

• David's Stability: 100% accuracy on drift and 96.8% on "noise + drift" proves that the algorithm functions as a physical filter embedded within the neural network weights.

Example

The new architecture implemented in a 380-parameter micro-network for ECG analysis.

Task: Diagnosing ECG deviations from the norm. Datasets: 1. Normal rhythm, 2. Arrhythmia, 3. Tachycardia (Standard datasets for these tasks were used).

Model Output:

Technical Specifications

At the current stage of research, the architecture is optimized for 1D signals (time series). The Nano-class model (~380 parameters) is sensitive to high-frequency noise if it overlaps with the useful signal spectrum. In such cases, a transition to the Micro or Medium tier is required.

• David Nano: Occupies less than 2 KB of RAM and runs on the simplest controllers, such as the ARM Cortex-M0.

• Computations: Linear computations. Strictly integer-based operations (int-only). No need for a hardware Floating Point Unit (FPU).

• Training Efficiency: The model required only 300 iterations on 64 examples to reach a 96% accuracy plateau.

• Resilience: The sensor can operate under conditions of chip degradation.

Porting this new architecture directly into the sensor offers hardware manufacturers the following advantages:

• Cost Reduction: Enables the use of low-cost sensors.

• Energy Efficiency: Due to integer-only operations and a low parameter count, energy consumption is reduced by orders of magnitude compared to classic DSP algorithms.

• A New Class of Devices: The ability to create sensors that output high-quality analysis rather than just raw data.

This is extremely useful for deployment on the most constrained microcontrollers, wearable electronics, Industrial IoT (IIoT), and in harsh environments.

Collaboration

All experiments were conducted on synthetic data. If anyone has the opportunity to provide real sensor readings from similar domains for validation, I would be very grateful.

In general, I am actively looking for partners for further research and the implementation of this new architecture into real-world projects.

Kamil Gadeev Telegram

P.S. The article presents real experimental data based on synthetic datasets. The probability that real-world trials might reveal critical issues in the algorithm is non-zero. And that is exactly what makes it interesting.