NanoEdge AI Studio ¶

NanoEdge AI Studio is ST’s embedded AutoML tool for STM32.

NanoEdge AI Studio in a nutshell ¶

No AI expertise needed: just import your own sensor data and let the benchmark explore thousands of preprocessing, model, and hyperparameter combinations to produce an optimized, ready-to-integrate C library. It covers anomaly detection, classification, outlier detection, and regression, and adds on-device learning for adaptive anomaly detection, synthetic data generation to ease abnormal-data collection, and tools that simplify sensor data extraction.

Resources ¶

Expanding NanoEdge AI: Bringing LSTM and CNN to the Edge ¶

Where NanoEdge AI Stands Today ¶

NanoEdge AI already offers a rich and proven catalog of classification and regression models, covering all the major machine-learning families our users rely on every day:

Linear models: Ridge and Kernel Ridge regression, together with maximum-margin hyperplane separators such as Support Vector Machines (SVM), ideal when speed, footprint, and interpretability matter most.
Ensemble methods: Random Forest and XGBoost, the go-to choice for capturing complex, non-linear relationships through powerful tree-based structures.
Neural networks: Multi-Layer Perceptrons (MLP), perfect for modeling rich non-linear interactions between variables.
Pairwise linear classifier, SEFR: a multi-class classifier designed for ultra-light footprints, combining one linear separator per class pair with elegant softmax voting.

For regression, our quadratic expansion preprocessing step unlocks even more value from linear models: by enriching the feature space with quadratic terms and feature interactions, it lets a simple linear model capture non-linear behavior, keeping inference fast and memory-friendly. And these models are widely used in practice, NanoEdge AI compilation statistics show how often each one is selected as the best fit across real user projects.

Classification

Model	Share — since 2025
Random Forest	██████████████████ 33%
MLP	█████████████████████ 39%
SVM	█████ 10%
SEFR	███ 6%
XGBoost	██████ 12%

Regression

Model	Share — since 2025
Ridge	██████████████████████ 41%
Random Forest	█████████ 17%
MLP	██████████ 20%
XGBoost	████████████ 22%
Kernel Ridge¹	— (recently introduced)

¹ Kernel Ridge is a very recent addition, no significant compilation data yet.

A few trends jump out from the 2025 snapshot:

MLP is now the #1 classifier (39%), a sign that users increasingly trust neural approaches at the edge.
XGBoost is the fastest-growing model, confirming the appetite for high-accuracy ensemble methods.
Ridge remains the regression workhorse, proof that lightweight linear models still win a huge share of edge use cases.

This evolution is exactly the context in which LSTM and 1D CNN join the catalog: users are clearly ready to adopt richer model families when they bring real value at the edge.

These models share one common assumption: they treat each input as an independent, static observation. That works extremely well in many edge scenarios, but leaves an exciting opportunity on the table when data comes with time, structure, or local patterns.

That’s exactly the gap our new LSTM and 1D CNN models are designed to fill.

A Quick Look at the Expanded Catalog ¶

             NanoEdge AI Models
│
├── Static models
│   ├── Linear          ── Ridge · Kernel Ridge · SVM · SEFR
│   ├── Ensemble        ── Random Forest · XGBoost
│   └── Feed-forward NN ── MLP
│
└── Sequential / structured models (new)
    ├── Recurrent        ── LSTM
    └── Convolutional 1D ── CNN

            

A note on hyperparameters

Throughout this document we describe the levers that shape each model (hidden size, number of filters, kernel size, activation, etc.). In NanoEdge AI, these hyperparameters are tuned automatically for you by the engine, which searches the combination of model and preprocessing that best fits your data and target device. The descriptions below explain what the engine is optimizing on your behalf, not knobs you need to turn yourself.

LSTM: Bringing Memory and Time Awareness to the Edge ¶

Long Short-Term Memory (LSTM) networks are a natural next step for NanoEdge AI users who work with time-dependent signals. Built as recurrent neural networks, LSTMs maintain an internal memory state that lets them remember and exploit information from previous time steps, capturing both short- and long-term dependencies, as well as rich temporal dynamics.

With LSTM, NanoEdge AI pipelines gain a brand-new family of sequential models that perfectly complement our existing static approaches. The result: unlocking use cases where the history of the signal is as important as its current value, predictive maintenance, behavioral patterns, and any scenario where “what happened just before” really matters.

How It Works — In Plain Words ¶

At the heart of an LSTM lies a memory cell coupled with three smart gates:

An input gate decides what new information is worth remembering.
A forget gate decides what is no longer relevant and should be discarded.
An output gate decides what part of the memory should influence the current prediction.

Together, these gates let the network learn what to remember and what to forget, all by itself, turning a stream of incoming samples into a meaningful, evolving understanding of the signal’s history.

Visually, a single LSTM cell can be sketched like this:

                            ┌───────────────────────── cell state ─────────────────────────┐
C(t-1) ───────►│   ✗ forget          +  add new           ▶  updated memory   │──────► C(t)
               │   ▲                 ▲                                        │
               │   │ f_t             │ i_t · g_t                              │
               │ ┌─┴─┐             ┌─┴─┐   ┌────┐                             │
               │ │ σ │             │ σ │   │tanh│ candidate g_t               │
               │ └─┬─┘             └─┬─┘   └─┬──┘                             │
h(t-1) ──┐     │   │                 │       │                                │
         ├────►│───┼─────────────────┼───────┼─────────────────────┐          │
x(t) ────┘     │   │                 │       │                     │          │
               │   shared input: [ h(t-1), x(t) ]                  ▼          │
               │                                                 ┌───┐        │
               │                                                 │ σ │        │
               │                                                 └─┬─┘  o_t   │
               │                                   tanh(C(t)) ───► ✗  ────────┼──► h(t)
               └──────────────────────────────────────────────────────────────┘


Gates and candidate (all computed from [ h(t-1), x(t) ])
f_t  : forget-gate activation   — σ → decides what to erase from C(t-1)
i_t  : input-gate activation    — σ → decides how much of the candidate to write
g_t  : candidate cell update    — tanh → new content proposed for the memory
o_t  : output-gate activation   — σ → decides what part of C(t) becomes h(t)

            

The same cell is unrolled over time, passing its memory forward at each step:

               x(1)        x(2)        x(3)               x(T)
   │           │           │                  │
   ▼           ▼           ▼                  ▼
┌─────┐     ┌─────┐     ┌─────┐            ┌─────┐
│LSTM │ ──► │LSTM │ ──► │LSTM │ ──► ... ──►│LSTM │ ──► h(T) ──► Dense ──► prediction
└─────┘     └─────┘     └─────┘            └─────┘
   │           │           │                  │
C(1),h(1)  C(2),h(2)  C(3),h(3)           C(T),h(T)

            

In NanoEdge AI, the LSTM architecture is intentionally compact and automatically dimensioned: stacked LSTM layers (their number chosen by the engine) followed by a final dense layer that uses the last time step of the sequence to produce the prediction. This keeps the model embedded-friendly while preserving the full benefit of the gated memory mechanism.

Why It Matters at the Edge ¶

Many edge signals are not just a snapshot, they tell a story over time. Traditional models look at each input in isolation and miss that story; LSTMs read it. Concretely, this means:

Detecting trends before they become obvious, anticipating a drift, a degradation, or an anomaly that only makes sense in context.
Distinguishing similar instantaneous values that mean very different things depending on what came before.
Smoothing out noisy or intermittent inputs by relying on a learned notion of continuity.

Where LSTM Shines ¶

A few representative scenarios where LSTM brings clear added value:

Predictive maintenance on motors, pumps, or bearings by capturing slow degradation patterns over time.
Behavioral classification from IMU data by distinguishing activities whose signature unfolds over several seconds.
Energy and power-consumption forecasting by learning daily, weekly, or cyclic patterns.
Process monitoring by flagging deviations in long, structured sequences where the past strongly conditions the present.

Designed for Real-World Embedded Deployment ¶

LSTMs are powerful and NanoEdge AI makes sure they deploy responsibly on constrained devices. Under the hood, the engine automatically tunes the key architectural parameters to fit the target:

Hidden size is selected to balance modeling capacity against footprint and inference time.
Number of LSTM layers is chosen to provide enough representational depth without exceeding the memory budget.
Sequence length is determined by the preprocessing pipeline (windowing, STFT, or feature grouping). Model and preprocessing are searched together so the LSTM sees just the right amount of history.
Sequential inference cost is taken into account during the search: longer sequences yield richer context but higher latency, and NanoEdge AI finds the sweet spot for you.

One thing to plan on your side: LSTMs typically benefit from more training data than linear or tree-based models, so a richer dataset will help the engine find the best configuration.

1D CNN: Detecting Local Patterns, Automatically ¶

The 1D Convolutional Neural Network (1D CNN) is the second exciting addition to NanoEdge AI. CNNs apply convolutional filters to the input signal, automatically detecting local patterns without any manual feature engineering. They excel at spotting characteristic motifs and local correlations across variables or across time.

By adding 1D CNNs, NanoEdge AI pipelines gain a new family of convolutional models that learn the right features for you, perfectly complementing both our static models and the new LSTM family. They shine on signals and time series with recognizable local patterns like vibration signatures, audio events, transients that are hard to capture with classical models.

How It Works — In Plain Words ¶

A 1D CNN slides small learnable filters across the input signal. Each filter acts like a mini pattern detector, lighting up whenever it recognizes its favorite local shape, a peak, a transient, a frequency signature, a slope.

Three properties make CNNs particularly attractive:

Automatic feature learning: no need to hand-craft features; the network discovers them from the data.
Weight sharing: the same filter is reused across the whole signal, keeping the model compact.
Translation invariance: a pattern is recognized regardless of when it appears in the signal, which is a huge advantage for real-world data.

In NanoEdge AI, the 1D CNN architecture is deliberately compact and embedded-first: a convolutional stage with built-in same padding is followed by a global average pooling over time and a final dense layer. NanoEdge AI sizes this pipeline automatically for the target, preserving the core benefits of convolutional feature learning while keeping the model lean and predictable for MCU deployment. This first CNN generation focuses on the architectures that bring the best accuracy / footprint ratio for current MCU targets, and will continue to evolve as new use cases emerge.

Why It Matters at the Edge ¶

Many edge signals carry their information in short, characteristic moments rather than in their global shape. 1D CNNs are tailor-made for that:

Replacing hand-crafted feature engineering: let the network learn the right filters instead of designing them manually.
Robust pattern recognition: the same motif is detected even if it shifts in time or appears multiple times.
Compact yet expressive: weight sharing keeps the footprint low, even when the model captures rich patterns.

Where 1D CNN Shines ¶

A few representative scenarios where 1D CNN brings clear added value:

Vibration analysis, detecting fault signatures in bearings, gears, or rotating machinery.
Audio event detection, glass break, engine sounds, acoustic anomalies.
Biomedical signals,heartbeat or arrhythmia detection on ECG, respiration patterns.
Current / voltage transients, identifying short, characteristic electrical events in power signals.
Gesture recognition from accelerometer or gyroscope streams.

Designed for Real-World Embedded Deployment ¶

NanoEdge AI takes care of building a 1D CNN that runs smoothly on MCUs by automatically configuring the architecture for the target. Under the hood, the engine explores and selects:

The number of filters, balancing pattern-detection capacity against footprint.
The kernel size, which defines the model’s receptive field — chosen to match the signal sampling frequency and the typical size of the patterns to detect.
The activation function (ReLU, Leaky ReLU, Tanh, Sigmoid, GELU, SiLU), picked to suit the dynamics of the signal and the desired accuracy / compute trade-off.

Other architectural choices: same padding and global average pooling are built in and embedded-friendly by design, so the engine can focus its search on the parameters that truly shape performance, without you having to think about them.

Model Comparison at a Glance ¶

To make model selection easy, here’s a two-view comparison: one focused on what each model can capture, and one focused on how it deploys.

Table 1 — Modeling Capabilities ¶

Model	Family	Linearity	Captures Temporal Dependencies	Captures Local Patterns
Ridge	Linear	Linear (non-linear via quadratic exp.)	No	No
Kernel Ridge	Linear (kernelized)	Non-linear (via kernel)	No	No
SVM	Maximum-margin / kernel	Linear or non-linear (kernel)	No	No
SEFR	Pairwise linear	Linear (per pair) + softmax voting	No	No
Random Forest	Tree ensemble	Non-linear	No	No
XGBoost	Boosted tree ensemble	Non-linear	No	No
MLP	Feed-forward NN	Non-linear	No (each sample independent)	No
LSTM (new)	Recurrent NN	Non-linear	Yes (short & long term)	Indirect (via sequential state)
1D CNN (new)	Convolutional NN	Non-linear	Local (within receptive field)	Yes (via convolutional filters)

Table 2 — Deployment, Data, and Trade-offs ¶

Model	Embedded Footprint¹	Training Data Needs	Strengths	What the Engine Tunes for You
Ridge	Very low	Very low	Lightning-fast inference, tiny footprint, easy to deploy	Regularization strength
Kernel Ridge	Medium	Low to medium	Captures non-linear patterns via the kernel trick	Kernel and regularization
SVM	Low to medium	Low to medium	Robust margins, strong performance in high-dimensional spaces	Kernel and margin parameters
SEFR	Very low	Very low	Ultra-lightweight, blazing-fast training and inference	Pairwise model setup
Random Forest	Low to high	Low to medium	Captures complex non-linear behavior, very robust to noise	`n_estimators` and `max_depth`
XGBoost	Medium to high	Medium	Top-tier accuracy on heterogeneous tabular data	Boosting hyperparameters
MLP	Low to medium	Medium	Flexible non-linear modeling between variables	Layer sizes and training parameters
LSTM (new)	Medium to high	Medium to high	Models temporal dynamics and history-dependent effects	Hidden size and number of layers; sequence length is set jointly with the preprocessing
1D CNN (new)	Medium	Medium to high	Automatic local-feature extraction, weight sharing, translation invariance	Number of filters, kernel size, and activation — within a compact Conv1D architecture optimized for MCU constraints

¹ Embedded footprint is indicative and depends on the configuration chosen by the engine and on the preprocessing pipeline. Tree-based models in particular can end up either ultra-light or richer depending on the target.

Designed to Work Hand-in-Hand With Preprocessing ¶

NanoEdge AI’s modular preprocessing pipeline (normalization, detrending, pooling, STFT/FFT, feature extraction, PCA, filtering) pairs naturally with each model family:

Normalization: strongly recommended for neural and kernel-based models (MLP, SVM, Kernel Ridge, LSTM, 1D CNN). Less critical for tree-based models.
Quadratic expansion: a great accelerator for Ridge in regression, unlocking non-linear behavior while staying in the linear family.
FFT / STFT: a natural fit upstream of static models (MLP, XGBoost, Random Forest) to surface spectral content. Optional in front of a 1D CNN, which can learn time-domain filters directly, but still valuable when the signal is genuinely spectral by nature.
Pooling / windowing: essential for sequential models (LSTM, 1D CNN), to keep input buffers within the embedded memory budget. For LSTM in particular, windowing directly sets the sequence length the model sees.
PCA / feature extraction: a strong ally for high-dimensional static pipelines; less needed in front of CNN/LSTM, which learn their own representations.

Choosing the Right Model ¶

A practical guide to pick the right family for the job:

Static tabular data, very tight memory budget → Ridge, SEFR
Static tabular data, accuracy-first → XGBoost, Random Forest
Non-linear regression with a small number of features → Kernel Ridge, MLP, or Ridge + quadratic expansion
Multi-class classification with ultra-low footprint → SEFR
Time series with long-range temporal dependencies → LSTM
Signals with characteristic local motifs (vibration, audio, ECG, current/voltage transients…) → 1D CNN
Time series that combine local patterns and longer context → a CNN front-end followed by an LSTM (future work)

NanoEdge AI in Action ¶

Here is how the expanded model catalog maps to real-world STM32 and edge scenarios:

Use Case	Recommended Model Families
Vibration analysis (machine health)	1D CNN, MLP + FFT features
Predictive maintenance on time series	LSTM, 1D CNN
Sensor fusion classification (IMU, env.)	MLP, XGBoost, Random Forest
Audio event detection	1D CNN
Lightweight on-MCU regression	Ridge, Kernel Ridge
Multi-class classification with few labels	SEFR, SVM

Don’t Stop at the Obvious Choice ¶

The decision guide above is a great starting point, but it’s not the end of the story. One of NanoEdge AI’s biggest strengths is the freedom to let the engine explore any model with any preprocessing pipeline, and these combinations often deliver surprising results.

The selection stats at the top of this document show which models the engine most often lands on, but a model that looks a priori less suited to a use case can outperform the “textbook” choice once paired with the right preprocessing. For example:

A simple Ridge + quadratic expansion can rival much heavier models on some non-linear regression problems.
An MLP fed with FFT features can match a 1D CNN on certain vibration tasks, with a smaller footprint.
A Random Forest on STFT bins can outperform a sequential model when the temporal signature is captured by the spectrogram itself.

The takeaway: don’t restrict yourself to the model family that seems most natural. Letting NanoEdge AI explore several model + preprocessing combinations is fast, easy, and often the most rewarding strategy.

Key Takeaways ¶

NanoEdge AI’s current catalog: linear, kernel-based, ensemble (tree-based), and feed-forward neural approaches — already covers a wide range of edge use cases on static data.
LSTM opens the door to sequential intelligence, perfect for use cases where temporal structure or history-dependent behavior drive the prediction.
1D CNN brings automatic local-pattern detection to the edge, making it ideal for signals and time series rich in characteristic motifs.
Mix and match freely preprocessing and model choice work together as a single pipeline. A model that seems a priori less suited to a use case can deliver surprising results once paired with the right preprocessing steps. The most natural choice isn’t always the best one and letting NanoEdge AI explore combinations is part of what makes the platform powerful.
All new models are designed with embedded reality in mind: NanoEdge AI automatically tunes the key hyperparameters, hidden size and number of layers for LSTM, number of filters, kernel size and activation for 1D CNN, together with the preprocessing pipeline. The final model fits the device while preserving the benefits of temporal and local feature modeling.

Looking Ahead ¶

LSTM and 1D CNN mark the first step in NanoEdge AI’s journey toward sequential and structured modeling. Both families will continue to grow as new architectures, use cases, and target devices unlock new opportunities at the edge.