NanoEdge AI Studio

NanoEdgeAI logo rectangle.png

NanoEdge AI Studio is a free software provided by ST to easily add AI into to any embedded project running on any Arm © Cortex M MCU.

It empowers embedded engineers, even those unfamiliar with AI, to almost effortlessly find the optimal AI model for their requirements through straightforward processes.

Operated locally on a PC, the software takes input data and generates a NanoEdge AI library that incorporates the model, its preprocessing, and functions for easy integration into new or existing embedded projects.

The main strength of NanoEdge AI Studio is its benchmark which will explore thousands of combinations of preprocessing, models and parameters. This iterative process identifies the most suitable algorithm tailored to the user's needs based on their data.

1. Getting Started

1.1. What is NanoEdge AI Studio?

NanoEdge AI Studio is a software designed for embedded machine learning. It acts like a search engine, finding the best AI libraries for your project. It needs data from you to figure out the right mix of data processing, model structure, and settings.

Once it finds the best setup for your data, it creates AI libraries. These libraries make it easy to use the data processing and model in your C code.

1.1.1. NanoEdge AI Library

NanoEdge™ AI Libraries are the output of NanoEdge AI Studio. They are static library for embedded C software on Arm® Cortex® microcontrollers (MCUs). Packaged as a precompiled .a file, it provides building blocks to integrate smart features into C code without requiring expertise in Mathematics, Machine Learning, or data science.

When embedded on microcontrollers, the NanoEdge AI Library enables them to automatically "understand" sensor patterns. Each library contains an AI model with easily implementable functions for tasks like learning signal patterns, detecting anomalies, classifying signals, and extrapolating data.

Each kind of project in NanoEdge has it own kind of AI Library with their functions but they share the same characteristics:

  • Highly Optimized: Designed for MCUs (any Arm® Cortex®-M).
  • Memory Efficient: Requires only 1-20 Kbytes of RAM/flash memory.
  • Fast Inference: Executes in 1-20 ms on Cortex®-M4 at 80 MHz.
  • Cloud Independent: Runs directly within the microcontroller.
  • Easy Integration: Can be embedded into existing code/hardware.
  • Energy Efficient: Minimal power consumption.
  • Static Allocation: Preserves the stack.
  • Data Privacy: No data transmission or saving.
  • User-Friendly: No Machine Learning expertise required for deployment.

All NanoEdge AI Libraries are created using NanoEdge AI Studio.

1.1.2. NanoEdge AI Studio Capabilities

NanoEdge AI Studio can:

  • Search for optimal AI libraries (preprocessing + model) given user data.
  • Simplify the development of machine learning features for embedded developers.
  • Minimize the need for extensive machine learning and data science knowledge.
  • Utilize minimal input data compared to traditional approaches.

Using project parameters (MCU type, RAM, sensor type) and signal examples, the Studio outputs the most relevant NanoEdge AI Library. This library can be either untrained (learning post-embedding) or pre-trained. The library performs inference directly on the microcontroller, involving:

  • Signal preprocessing algorithms (e.g., FFT, PCA, normalization).
  • Machine learning models (e.g., kNN, SVM, neural networks, proprietary algorithms).
  • Optimal hyperparameter settings.

The process is iterative: import signals, run a benchmark, test the library, adjust data, and repeat to improve results.

1.1.3. NanoEdge AI Studio Limitations

NanoEdge AI Studio:

  • Requires user-provided input data (sensor signals) for satisfactory results.
  • Libraries' performances are heavily correlated to the quality of the data imported
  • Does not offer ready-to-use C code for final implementation. Users must write, compile, and integrate the code with the AI library.

In summary, NanoEdge AI Studio outputs a static library (.a file) based on user data, which must be linked and compiled with user-written C code for the target microcontroller.

1.2. License Activation


To use NanoEdge AI Studio, you need a license obtained during the software download at

Initial Setup:

  1. Enter your license key
  2. Set your proxy settings if you need
  3. Save Settings

IP Authorization You may need to authorize the following IP addresses:

ST API for library compilation: or via URL:

Port Configuration

By default, NanoEdge AI Studio uses port 5000. If this port is unavailable, the Studio will automatically search for an available port. To manually configure the port:

  1. Press windows key + R, type %appdata% and press Enter.
  2. Navigate to nanoedgeaistudio folder and open config.json
  3. Locate the line where the port is set, modify it, and save the file.

Project Storage Location You can change the location where projects are saved. Avoid selecting cloud-synced or shared folders for project storage.

1.2.1. Offline license activation


If you lack an Internet connection, you can activate your NanoEdge AI Studio license offline:

  1. Offline Activation: Click on "Offline Activation" and enter your license key.
  2. Copy the Activation String: A long string of characters will appear. Copy this string or click the provided link.
  3. Activate License: Paste the string if needed and click "Activate License".
  4. Receive Response String: You will receive a new string as a response. Copy this string.
  5. Finalize Activation: Return to NanoEdge AI Studio, paste the response string, and click "Activate".

1.3. Type of projects

The four different types of projects that can be created using the Studio, along with their characteristics, outputs, and possible use cases, are outlined below:


Anomaly detection differentiates normal behavior signals from abnormal ones.

  • User Input: Datasets containing signals for both normal and abnormal situations.
  • Studio Output: The optimal anomaly detection AI library, including preprocessing and the model identified during benchmarking.
  • Library Output: The library provides a similarity score (0-100%) indicating the resemblance between the training data and the new signal.
  • Retraining: This project type supports model retraining directly on the microcontroller.
  • C Library Functions: Includes initialization, learning, and detection functions. See AI:NanoEdge AI Library for anomaly detection (AD).
  • Use Case Example: For preventive maintenance of multiple machines, collect nominal data and simulate possible anomalies. Use NanoEdge AI Studio to create a library that can distinguish normal and abnormal behaviors. Deploy the same model on all machines and retrain it for each specific machine to enhance specialization for their environments.

Warning DB.png Important

Anomaly detection is the only project type that outputs a NanoEdge AI Library capable of learning signal examples in situ, after it is embedded into the microcontroller. All other library types only infer in the microcontroller.

This feature gives anomaly detection libraries great adaptability, since the same library, deployed on different devices (possibly monitoring slightly different machines, or machines that operate in different environmental conditions, or that are susceptible to perturbations) is able to train differently (learn different knowledge) to adapt itself to the specific behavior of its target machine.

This also means that anomaly detection libraries can learn incrementally on the go; knowledge can be erased, but it can also be enriched at any moment, simply by learning additional signal examples representing the new behaviors to learn (for instance signals representing new nominal regimes, possibly due to a change in operating conditions).


N-class classification assigns a signal to one of several predefined classes based on training data.

  • User Input: A dataset for each class to be detected.
  • Studio Output: The optimal N-class classification library, including preprocessing and the model identified during benchmarking.
  • Library Output: The library produces a probability vector corresponding to the number of classes, indicating the likelihood of the signal belonging to each class. It also directly identifies the class with the highest probability.
  • C Library Functions: Includes initialization and classification functions. See AI:NanoEdge AI Library for 1-class classification (1CC).
  • Use Case Example: For machines prone to various errors, use N-class classification to precisely identify the type of error occurring, rather than just detecting the presence of an issue.


One-class classification distinguishes normal behavior from abnormalities without needing abnormal examples, detecting outliers instead.

  • User Input: A dataset containing only nominal (normal) examples.
  • Studio Output: The optimal one-class classification library, including preprocessing and the model identified during benchmarking.
  • Library Output: The library returns 0 for nominal signals and 1 for outliers.
  • C Library Functions: Includes initialization and detection functions. See AI:NanoEdge AI Library for n-class classification (nCC).
  • Use Case Example: For predictive maintenance when abnormal data is unavailable, one-class classification can identify outliers. However, for better performance, using anomaly detection is recommended.


Extrapolation predicts discrete values, commonly known as regression.

  • User Input: A dataset containing pairs of target values to predict and corresponding signals. Data format differs from other projects in NanoEdge. [See here for details].
  • Studio Output: The optimal extrapolation library, including preprocessing and the model identified during benchmarking.
  • Library Output: The library predicts the target value based on the input signal.
  • C Library Functions: Includes initialization and prediction functions. See AI:NanoEdge AI Library for extrapolation (E).
  • Use Case Example: When monitoring a machine with multiple sensors, use extrapolation to predict the value of one sensor using data from other sensors. Create a dataset with signals representing the data evolution from the sensor to be kept and associate it with the values from the sensor to be replaced.

1.4. Data format

NanoEdge AI Studio and its output NanoEdge AI Libraries are compatible with any sensor type: NanoEdge is sensor-agnostic. NanoEdge tries to extract the information in the data being vibrations, current, sound or anything else.

In NanoEdge AI Studio, sensors are divided in 2 distinct groups based on the format of data that you will use: Time series sensors or Cross sectional sensors.

1.4.1. Time series versus Cross sectional

Time series refers to data that contains information of multiple points in time.

Cross sectional refers to data that contain information at a single point in time.

AI:neai time series cross sectional.png

In an embedded environment, In general, you want to work with time series data. Information about a motor at a single point in time is, most of the time, useless. Most of the useful information is contained in the evolution in time of the data, not in a single observation. On the opposite side, if you want to predict the price of a house based on a lot of its caracteristics (size, number of room etc). You don't necessarily need an evolution of these parameter as much of them are fixed.

Here is another example:

Time of flight can be selected in both time series or cross sectional to solve different use cases:

  • Time series: you want to recognize a gesture, you will use consecutive matrix from the time of flight to solve the use case
  • Cross sectional: you want to recognize a sign. you don't need temporal information, a single matrix contains the sign.

1.4.2. Defining important concepts

Here are some clarifications regarding important terms that are used in this document and in NanoEdge:

In NanoEdge AI Studio, the axis/axes are the total number of variables outputted by the sensor used for a project. For example, a 3-axes accelerometer outputs a 3-variables sample (x,y,z) corresponding to the instantaneous acceleration measured in the 3 spatial directions.

In case of using multiple sensors, the number of axes is the total number of axes of all sensors. For example, if using a 3-axes accelerometer and a 3-axes gyroscope, the number of axes is 6.

A signal is the continuous representation in time of a physical phenomenon. We are sampling a signal with a sensor to collect samples (discrete values). Example: vibration, current, sound.

This refers to the instantaneous output of a sensor, and contains as many numerical values as the sensor has axes. For example, a 3-axis accelerometer outputs 3 numerical values per sample, while a current sensor (1-axis) outputs only 1 numerical value per sample.

Data rate:
The data rate is the frequency at which we capture signal values ​​(samples). The data rate must be chosen according to the phenomenon studied. You must also pay attention to having a consistent data rate and number of samples to have buffers that represent a meaningful time frame.

A buffer is a concatenation of consecutive samples collected by a sensor. A dataset contains multiples buffers, the term Line is also used when talking about buffers of a dataset. Buffers are the input for NanoEdge, being in the Studio or in the microcontroller.

1.4.3. Time Series

When selecting Time Series in the first step of a project in NanoEdge AI Studio, you have multiples sensors as options:

  • Accelerometer: 1, 2 or 3 axes
  • Current: 1 axis
  • Hall effect: 1, 2 or 3 axes
  • Microphone: 1 axis
  • Time of Flight: 4x4 or 8x8 matrix
  • Generic: As much axis as you are using (example: current and accelerometer 3 axes = 4axes)

Because Time series involves multiple sample in time, the data imported are expected to contain multiple sample of the number of axis selected. Work with temporal buffers

NanoEdge AI Studio expects buffers and not just samples of data.

AI:neai sample vs buffer.png

Buffer = sensor' number of axes * number of sample taken at a fixed data rate (Hz)
It's crucial to maintain a consistent sampling frequency and buffer size.

Why are buffers more useful than samples?

In machine learning, you want to work on buffer as they contains information on the evolution of the phenomenon studied. Samples are just a single point in time representing the phenomenon. It is easier to distinguish pattern in buffers than in simple values

Lets consider a simple example were we collect 2 signal being the same but one in temporal order (t0 to tn), and the other being the opposite (tn to t0). We consider these two signals being two classes and we want to classify a new signal into one of these two classes (here if it is equal to one of them).


  • Left plot: Samples independently
  • Right plot: Samples as temporal buffers

We collect a new signal that is for sure from one of the two classes and want to know which one:

  • If we look at the samples (left approach), it is impossible as all the values are in the 2 classes. A single sample doesn't contains the information for it to be classified.
  • On the other hand, if we use the temporal buffer, we directly see which one it is equal to. General rules

The Studio requires:

  • Each line in a dataset must represent a single, independent signal example composed of multiple samples.
  • The buffer size to be a power of two and remain constant throughout the project.
  • The sampling frequency to remain constant throughout the project.
  • All signal examples for a specific "class" to be grouped in the same input file (e.g., all "nominal" regimes in one file and all "abnormal" regimes in another for anomaly detection).

General considerations for input file format:

  • .txt / .csv files
  • Numerical values only, no headers
  • Uniform separators (single space, tab, comma, or semicolon)
  • Decimal values formatted with a period (.)
  • Fewer than 16,384 values per line
  • Consistent number of numerical values on each line
  • Minimum of 20 lines per sensor axis
  • Fewer than ~100,000 total lines
  • File size less than ~1 Gbit

Specific formatting rules:

  • Anomaly detection, 1-class classification, and n-class classification projects share general rules.
  • Extrapolation projects require target values for extrapolation. Basic Format

Following the rules from the previous part, the format for anomaly detection (AD), N-class classification (NCC) or 1-class classification (1CC) is the same and is describe in the example below:

You want to collect 3-axes accelerometer data to monitor a motor. You estimate the highest-frequency component of this vibration to be below 500 Hz, therefore choose a sampling frequency of 1000 Hz for the sensor. You want to get signals that represent 250ms which mean that you will collect buffer of 256 samples as 256/1000 (nb sample / data rate) = 256 ms.

NanoEdgeAI input example.png

In this example all the parameters considered are:

  • Number of axis: 3 axes
  • Number of sample: 256samples
  • Buffer size: 3*256 = 768
  • Data rate: 1000Hz
  • Temporal length: 256ms

All these parameters hold a major importance in the result that you will get in NanoEdge AI Studio. Find more on how to select them here. Variant Format: Extrapolation projects

In Extrapolation (or Regression) the file format is slightly different.

The goal of extrapolation models is to predict a numerical value, called Target in NanoEdge based on an input buffer. To train such models, you need a dataset with a large variety of Target and the corresponding buffer.

When trained, you will then give a buffer as input to the model that will output the target that you are trying to predict.

Lets say that you want to predict the speed of a motor based on its vibration. Here your target is a speed corresponding to vibration, which is 3 axis accelerometer data. In this case, you will collect buffers of accelerometer data and for each buffer, associate the corresponding speed (the speed at the start of the acquisition, the end or an average depending on your use case):

NanoEdgeAI extrapolation format.png

The format is the same as in other project but with one more column that must be the first one.

This time, the buffer size in the dataset used by NanoEdge is: number of axes * number of sample + Target.

Warning DB.png Important

Here, the buffer refers to the combination of all known parameters or features associated to a target value. The target value refers to the variable or feature that the user is trying to extrapolate / infer / evaluate / predict. This target value is known during training (hence provided in the input files provided in the Studio), but unknown during inference (hence absent from the input files used later on to test the extrapolation library obtained).

1.4.4. Cross Sectional

When selecting Cross Sectional in the first step of a project in NanoEdge AI Studio, you have two sensors as options: Time of Flight (8x8 or 4x4) or Multi-sensor.

Time of Flight
If you select Time of Flight, each line in the dataset represents an 8x8 or 4x4 matrix. This means each buffer contains a single sample of either 16 or 64 values.

If you select Multi-sensor, you can choose the number of sensors and create buffers with any combination of sensor data. You need to enter the total number of 'dimensions' which is the sum of axes of all your sensors.

In Cross Sectional projects, there is no temporal link within or between buffers. Each buffer represents the state of the environment at a single point in time. For example, the second buffer might be collected 2 seconds after the first, and the third buffer might be collected 10 minutes after the second. This timing does not affect the project. Basic Format

For anomaly detection (AD), N-class classification (NCC), or 1-class classification (1CC) in Cross Sectional projects, the formats are as follow:

Time of flight:

As said above, you either have buffer of size 16 (4x4 matrix) or size 64 (8x8).


Each buffer can include data from various sensors. For instance, a buffer might contain:

  • Temperature
  • Humidity
  • Current
  • Pressure

Each buffer captures the state of the studied environment at a specific point in time and is independent of other buffers. There is no temporal link between them.

AI:neai cross sectional basic format.png

If you want to include more data in each buffer, such as additional accelerometer measurements (first, average, max), you can do so along with other sensor data. Extrapolation Projects

For Extrapolation projects, the format is similar to that of time series projects but with a key difference: each buffer contains a single sample associated with a target value. Using the previous example:

AI:neai cross sectional extrapolation.png

1.4.5. Designing a relevant sampling methodology

Compared to traditional machine learning approaches that might need hundreds of thousands of signal examples, NanoEdge AI Studio requires significantly less data—typically around 100-1000 buffers per class, depending on the use case.

However, the data must be qualified, containing relevant information about the physical phenomena to be monitored. Designing a proper sampling methodology is crucial to ensure all desired characteristics of the physical phenomena are accurately captured and translated into meaningful data.

Key Considerations:

  • Study the Right Physical Phenomenon: Ensure the data captures the correct physical events.
  • Define the Environment: Match the data collection environment to the real deployment environment.
  • Work with Buffers, Not Samples: Buffers provide more context and patterns than individual samples.
  • Work with Raw Data: Use unprocessed data for better accuracy.
  • Choose a Relevant Sampling Rate and Buffer Size: Ensure these settings capture the necessary details.
  • Use a Temporal Window That Makes Sense: Select a time frame that covers the relevant events.
  • Start Small and Iterate: Begin with a small dataset and refine as needed.

These aspects are essential and greatly impact the results.

For more details, refer to the AI:Datalogging guidelines for a successful NanoEdge AI project

2. Using NanoEdge AI Studio

2.1. Studio home screen

NEAI Main screen.png

The Studio main (home) screen has four main elements:

1. Project Creation Bar (top):
Create new projects (anomaly detection, 1-class classification, n-class classification, or extrapolation), and access the datalogger and data manipulation screens.

2. Existing Projects List (left side):
Load, import/export, or search existing NanoEdge AI projects.

3. Useful Links and Inspiration (right side):
Access resources like MOOC, documentation, and links to the Use Case Explorer data portal for downloadable datasets and performance summaries.

4. Toolbar (left extremity) provides quick access to:

  • Datalogger
  • Data manipulation
  • Sampling finder
  • Studio settings (port, workspace folder path, license information, and proxy settings)
  • NanoEdge AI documentation
  • NanoEdge AI license agreement
  • CLI (command line interface client) download
  • Studio log files (for troubleshooting)
  • Studio workspace folder

2.1.1. Project Creation

AI:neai create project.png

To get started with NanoEdge AI Studio, you need to either create a project or download one of our example project.

Create project

To create a new project, simply click on one of the four types of projects available in NanoEdge AI Studio:

  • Anomaly detection
  • 1-class classification
  • N-class classification*
  • Extrapolation


Demo project

Five Demo project are available in NanoEdge AI Studio:

  • Arc fault classification
  • Rock Paper Scissors classification
  • Motor vibration anomaly detection
  • Motor current anomaly detection
  • Pump vibration anomaly detection

All projects contains a description about the use case and the collected data.

To download these example projects, you can do it directly on the Home page if you don't have a project yet (see previous screenshot). Else you need to open the import menu:

AI:neai import menu.png

2.1.2. Project Steps

NEAI project steps.png

Each project is divided into 5 successive steps:

  1. Project settings, to set the global project parameters
  2. Signals, to import signal examples that are used for library selection.
    Note: this step is divided in 2 substeps in anomaly detection projects (Regular signals / Abnormal signals)
  3. Optimize & benchmark, where the best NanoEdge AI Library is automatically selected and optimized
  4. Validation to validate the library selected by testing through files or serial, one or multiple libraries
  5. Deployment, to compile and download the best library and its associated header files, ready to be linked to any C code.

A helper tool providing tips is available on the bottom right corner of the screen when in a project. We highly recommend to complete the tasks given and read the documentation highlighted by it!

2.2. Project settings


The first step in any project is Project settings.

Here, the following parameters parameters are set:

  • Project name
  • Description (optional)
  • Max RAM: this is the maximum amount of RAM memory to be allocated to the AI library. It does not take into consideration the space taken by the sensor buffers.
  • Limit Flash / No Flash limit: this is the maximum amount of flash memory to be allocated to the AI library.
  • Sensor type: the type of sensor used to gather data in the project, the type of data and their dimension (number of axes)
  • Target: this is the type of board or microcontroller on which the final NanoEdge AI Library is deployed.

Warning white.png Warning

Restricting the amount of RAM/flash memory available restricts the search space during benchmark', which causes potentially better, more memory-hungry libraries, to be ignored.

2.2.1. Target selection

NEAI target selection.png

NanoEdge AI Studio allows compilation on a large variety of targets. These target are separated in three tabs:

Development boards: 140+ targets,
Greats for education or proof of concepts as development board generally embed sensors.

Microcontrollers: 550+ targets

  • Any STM32 Arm © Cortex M MCU: All STM32 families with a Arm © Cortex M MCU can be selected as target.
  • A large variety of non ST Arm © Cortex M MCUs for development purposes only.

Arduino Boards: 19 targets
Arduino Boards with Arm © Cortex M MCUs for development purposes only.

For non-ST target and production purposes, please contact ST.

It is possible to add a board as favorite by clicking on the star. Then, the board will always be displayed on the left.

Warning DB.png Important

It is possible to change the target at any moment in a project in progress. It only affect the compilation step. It allow an easy transition from a development board to a production board for example. Just make sure that the new selected target has enough RAM and Flash compared to the library selected.

2.2.2. Types of sensors in NanoEdge AI Studio

NanoEdge AI Studio and its output NanoEdge AI Libraries are compatible with any sensor type: NanoEdge is sensor-agnostic. NanoEdge tries to extract the information in the data being vibrations, current, sound or anything else.As explained in Data Format, sensors are divided in 2 distinct groups based on the format of data:

Time series refers to data that contains information of multiple points in time. The available sensors are:

  • Accelerometer
  • Current
  • Hall effect
  • Microphone
  • Time of Flight
  • Generic

Cross sectional refers to data that contain information at a single point in time. The available sensor are:

  • Time of Flight
  • Multi-sensor

For more information on Time series or Cross Sectional, please check the part of the documentation about Data Format. Generic and multi-sensor

Generic and multi-sensor are useful if you want to use multiple sensors data. Generic is for the time series case and multi sensor if for the cross sectional case.

Generic (time series):

Generic sensor is useful you want to work with data representing the evolution in time of a sensor that is not listed in NanoEdge or that is the combination of multiple sensors.

If you work with a 3-axes accelerometer and a current sensor, for example, you can tell NanoEdge to use the data as a "4 axes generic sensor" being the 3 axes from the accelerometer and the 1 axes current. You need to set the same data rate on both sensors in order to always have 4 values samples in your temporal buffers.

Multi-sensor (cross sectional):

Multi-sensor is the equivalent of generic but if working with cross sectional data. At a single point in time, you want to get the values from all the sensors. You are not interested in the evolution of the values of each sensor.

Lets say that you have a lot of sensor in a car and you want to predict the temperature of the motor. You found that the evolution of the parameters is irrelevant to you. Then multi sensor is your way to go, you will at some point in time, collect all the sensor's data and make the prediction of the temperature.

The example of the home price is also a good example if you consider each characteristic of the house as different sensors values.

2.3. Signals

2.3.1. How to import signals

The input files, containing all the signal examples to be used by the Studio to select the best possible AI library, can be imported from three sources:

  1. From a file (in .txt / .csv format)
  2. From the serial port (USB) of a live datalogger
  3. From the FP-SNS-Datalog

NanoEdgeAI import-signal.png

1. From file:

  • Click SELECT FILES, and select the input file to import.
  • Rename the input file if needed.
  • Repeat the operation to import more files.
  • Click CONTINUE.

NanoEdgeAI signals by file.png

2. From serial port:

  • Select the COM Port where your datalogger is connected, and select the correct Baudrate.
  • If needed, tick the checkbox enter a maximum number of lines to be imported.
  • Click START/STOP to record the desired number of signal examples from your datalogger.
  • Rename your input file if needed.
  • Click CONTINUE.

NanoEdgeAI signals by serial.png

Info white.png Information
  • A USB data logger is required for this. It must be able to log data and output it to serial port in real time.
  • See the Datalogger section to create automatically data loggers.

3. From Function pack (.dat):

To import .dat files from the ST function pack, the user needs to convert them to .csv and then use the From file option to import them in NanoEdge AI Studio.

  • To import .dat file from FP-SNS-DATALOG to the NanoEdge AI Studio, refer to hsdatalog_to_nanoedge Python® script in FP-SNS-DATALOG/Utilities/Python_SDK to convert it into a .csv file.
  • To import .dat file from FP-AI-PDMWBSOC to the NanoEdge AI Studio, refer to hsdatalog_to_nanoedge Python® script in FP-AI-PDMWBSOC/Utilities/HS_Datalog_BLE_FUOTA/Python_SDK to convert it into a .csv file.

2.3.2. Which signals to import

1. Anomaly detection:

In anomaly detection, you need to collect two types of data: regular (nominal) data and abnormal data:

  • Regular Data: Represents normal states of a machine (e.g., different operating regimes of a normally functioning motor).
  • Abnormal Data: Represents abnormal states of a machine (e.g., motor misalignment, pump clogging).

When logging data, ensure the setup closely matches the real deployment environment. Collect a wide variety of data. If the library performs poorly under specific conditions, log new data, add it to the training set, and rerun the benchmark. This is an iterative process.


To detect anomalies in a 3-speed fan using an accelerometer to monitor vibration patterns, I recorded signals for various behaviors:

Nominal Examples:

  • 30 for "Speed 1"
  • 25 for "Speed 2"
  • 35 for "Speed 3"
  • 30 for "Fan turned off"

Some signals include "transients" like fan speeding up or slowing down.

Abnormal Examples:

  • 30 for "Fan airflow obstructed at speed 1"
  • 35 for "Fan orientation tilted by 90 degrees"
  • 25 for "Tapping on the fan with my finger"
  • 25 for "Touching the rotating fan with my finger"

2. 1-class Classification:

For 1-class classification, all the imported data needs to be regular (nominal) data representing all the situations considered normal. The benchmark will then used these data to try to define what is the normality and its limit.

3. n-class classification:

For n-class classification, all signal examples corresponding to one given class must be gathered into the same input file.

N-class classification benchmarks are started using one input file per class.

Example: For the identification of types of failures on a motor, five classes can be considered, each corresponding to a behavior, such as:

  • Normal behavior
  • Misalignment
  • Imbalance
  • Bearing failure
  • Excessive vibration

This results in the creation of five distinct classes (import one .txt / .csv file for each), each containing a minimum of 20-50 signal examples of said behavior.

4. Extrapolation:

For extrapolation, all signal examples must be gathered into the same input file.
This file contains all target values to be used for learning, along with their associated buffers of data (representing the known parameters).

2.3.3. Signal summary screen

The Signals screen contains a summary of all information related to the imported signals:

  1. List of imported input files
  2. Information about the input file selected, and basic checks
  3. Optional: frequency filtering for the signals
  4. Signal preview graphs

NanoEdgeAI signals nb.png

Imported files [1]:
In this example (n-class classification project) a total of 7 input files are imported, each corresponding to one of the 7 classes to distinguish on the system (here, a multispeed USB fan).

File information [2]:
The selected file ("speed_1") contains 100 lines (or signal examples), each composed of 768 numerical values.

  • The Check for RAM and the next 5 checks are blocking, meaning that any error in the input file must be fixed before proceeding further.
    Here, all checks were successfully passed (green icon). However, if a check returns an error, a red icon is displayed.
  • Click "Run optional checks" to scan your input file and run additional checks (search for duplicate signals, equal consecutive values, random values, outliers, or others).
    Failing these additional checks gives warnings that suggest possible modifications on your input files. Click any warning for more information and suggestions.

Signal previews [4]:
These graphs show a summary of the data contained in each signal example within the input file. There are as many graphs as sensor axes.

  • The graph x-axis corresponds to the columns' in the input file.
  • The y-values contain an indication of the mean value of each column (across all lines, or signals), their min-max values, and standard deviation.
  • Optionally, FFT (Fast Fourier Transform) plots can be displayed to transpose each signal from time domain to frequency domain.

Frequency filtering [3]:
This is used to alter the imported signals by filtering out unwanted frequencies.

  • Click FILTER SETTINGS above the signal preview plots
  • Toggle "filter activated / deactivated" as required
  • Input the sampling frequency (output data rate) used on the sensor used for signal acquisition.
  • Select the low and high cutoff frequencies you wish to use for the signals (maximum: half the sampling frequency).
    Within the input signals, only the frequencies that fall between these two boundaries are kept; all frequencies outside the window are ignored.
  • In the example below (sampling rate: 1024 Hz) the decision is to cut off all the low frequencies under 100 Hz.

NanoEdgeAI filter settings.png

Warning DB.png Important
  • It is only possible to filter out the frequencies lower than half the sampling frequency used to acquire input signals.
  • Activating the filter does not mean that the library forces FFT as a pre-processing step. The input signal, even filtered, might stay in the temporal domain; this is for the library to decide, depending on which approach yields the best results.

Warning white.png Warning

Once frequency filtering is activated in a project, it automatically applies to all signals within the current project.
This option is taken into account during benchmarking, and needs to be disabled manually. Signal step for Time of Flight
AI:neai signal tof.png

If Time of Flight was selected as sensor for the project, the signal step display changes. Instead of plotting a signal and FFT for each axis, it instead display the Time of Flight result matrix.

It is possible to display the matrix corresponding to any line (buffer) in the dataset.

Additionally, if in the Project settings, the Time of flight sensor was selected as Time series (not Cross sectional), then it is possible to play an animation displaying the consecutive matrix collected.

2.4. Benchmark

During the benchmarking process, NanoEdge AI Studio uses the signal examples imported in the previous step to automatically search for the best possible NanoEdge AI Library.

NanoEdgeAI bench screen.png

The benchmark screen, summarizing the benchmark process, contain the following sections:

  1. NEW BENCHMARK button, and list of benchmarks
  2. Benchmark results graph
  3. Search information window
  4. Benchmark PAUSE / STOP buttons
  5. Performance evolution graph

To start a benchmark:

  2. Select which input files (signal examples) to use
  3. Optional: change the number of CPU cores to use
  4. Click START.

Info white.png Information
  • Benchmarks might take a long time (several hours) to complete and find a fully optimized library. However, the bulk of the optimization process is typically carried out within the first 30-60 minutes. Therefore, it is recommended, when doing exploratory work or running quick tests, to start testing your candidate libraries (Emulator) without waiting several hours for full completion (unless trying to refine previous results).
  • Benchmarks can be paused / resumed, or stopped at any time, without cancelling the process (the best library found is not lost).
  • Useful information can be found in the project bar at the top (under the button for Benchmark), such as:
    • Total number of benchmarks run in the current project.
    • Number of libraries tested in total for the current benchmark.
    • Time elapsed for the current benchmark.
  • Benchmark progress in % is displayed on the left side of the screen, next to the name / ID of the benchmark, in the benchmark list under the RUN NEW BENCHMARK button.

2.4.1. Benchmarking process

Each candidate library is composed of a signal preprocessing algorithm, a machine learning model, and some hyperparameters. Each of these three elements can come in many different forms, and use different methods or mathematical tools, depending on the use case. This results in a very large number of possible libraries (many hundreds of thousands), which need to be tested, to find the most relevant one (the one that gives the best results) given the signal examples provided by the user.

In a nutshell, the Studio automatically:

  1. divides all the imported signals into random subsets (same data, cut in different ways),
  2. uses these smaller random datasets to train, cross-validate, and test one single candidate library many times,
  3. takes the worst results obtained obtained from step #2 to rank this candidate library, then moves on to the next one,
  4. repeats the whole process until convergence (when no better candidate library can be found).

Therefore, at any point during benchmark, only the performance of the best candidate library found so far are displayed (and for a given library, the score shown is the worst result obtained on the randomized input data).

Warning DB.png Important

Remember that, while classification and extrapolation models are trained (and their knowledge learned) in the Studio during this process, the anomaly detection libraries are not.
During benchmark, the best anomaly detection library is selected, but it is untrained. Training only happens later on, inside the microcontroller, when the user runs iterations of the learn() function.

2.4.2. Performance indicators

During benchmark, all libraries are ranked based on one primary performance indicator called "Score", which is itself based on several secondary indicators. Which secondary indicators are used depends on the type of project created. Below is the list of secondary indicators involved in the calculation of the "Score" (more information about available here).

Anomaly Detection:

  • Balanced Accuracy (BA)
  • Functional Margin
  • RAM & flash memory requirements

N-class Classification:

  • Balanced Accuracy (BA)
  • Accuracy
  • F1-score
  • Matthews Correlation Coefficient (MCC)
  • A custom measurement which estimates the degree of certainty of a classification inference
  • RAM & flash memory requirements

1-class Classification:

  • Recall
  • A custom measurement which takes into account the radius of the hypersphere containing nominal signals, and the Recall obtained on the training dataset
  • RAM & flash memory requirements


  • R² (R-squared)
  • SMAPE (Symmetric Mean Absolute Percentage Error)
  • RAM & flash memory requirements

The main secondary indicators are "Balanced Accuracy" for Anomaly Detection and n-class Classification, "Recall" for 1-class Classification, and "" for Extrapolation. Like the Score, these metrics are constantly being optimized during benchmark, and are displayed for information.

  • Balanced accuracy (anomaly detection, classification) is the library's ability to correctly attribute each input signal to the correct class. It is the percentage of signals that have been correctly identified.
  • Recall (1-class classification) quantifies the number of correct positives predictions made, out of all possible positive predictions.
  • (extrapolation) is the coefficient of determination, which provides a measurement of how well the observed outcomes are replicated by the model, based on the proportion of total variation of outcomes explained by the model.

Info white.png Information

Balanced Accuracy and Recall come with a confidence interval, displayed in brackets (for instance: [X% - Y%]). This means that given the input signals provided, there is a 95% chance that the true accuracy/recall of the library falls within the range between brackets (here between X% and Y%).

Additional metrics related to memory footprints:

  • RAM (all projects) is the maximum amount of RAM memory used by the library when it is integrated into the target microcontroller.
  • Flash (all projects) is the maximum amount of flash memory used by the library when it is integrated into the target microcontroller.

2.4.3. Benchmark progress

Benchmark graph:

Along with the four performance indicators, a graph shows the position in real time of signal examples (data points) imported.
The type of graph depends on the type of project:

NanoEdgeAI AD graph.png
NanoEdgeAI nCC graph.png

The anomaly detection plot (left side) shown similarity score (%) vs. the signal number. The threshold (decision boundary between the two classes, "nominal" and "anomaly") set at 90% similarity, is shown as a gray dashed line.

The n-class classification plot (right side) shows probability percentage of the signal (the % certainty associated to the class detected) vs. the signal number.

NanoEdgeAI 1CC graph.png
NanoEdgeAI EX graph.png

The 1-class classification plot (left side) shows a 2D projection of the decision boundary separating regular signals from outliers. The outliers are the few (~3-5%) signals examples, among all the signals imported as "regular" which appear to be most different from the rest (~95-97%) of the others.

The extrapolation plot (right side) shows the extrapolated value (estimated target) vs. the real value which was provided in the input files.

Information window:

When a benchmark is running, this window (top right side of the screen) displays additional information about the process, such as:

  • Threads started / stopped
  • New best libraries found, and their scored
  • Search speed (evaluations per second for each thread)

Performance evolution plot:

This plot, located at the bottom right side of the screen, shows the time-evolution of the four performance indicators that are optimized during benchmark. Every time a new best library is found, this plot shows which metric has been improved, and by how much.

Some secondary performance indicators (confidence / R², RAM, Flash) might deteriorate over time, only when it is to the benefit of one of the main indicators (accuracy / recall / R²).

2.4.4. Benchmark results

When the benchmark is complete, the a summary of the benchmark information appears:

NanoEdgeAI bench info.png

Only the best library is shown. However, several other candidate libraries are saved for each benchmark.
Any candidate library may be selected by clicking "N libraries" (see above, "11 libraries"), and selecting the desired library by clicking the crown icon.
This feature is useful to select a library that has better performance in terms of a secondary indicator (for instance to prioritize libraries that have a very low RAM or flash memory footprint).

NanoEdgeAI candidate libs.png

Here, information about the family of machine learning model contained in the candidate libraries is also displayed. For example, in the list displayed above, there are libraries based on the SVM model, and others based on SEFR.

[Anomaly detection only]: After the benchmark is complete, a plot of the library learning behavior is shown:

NanoEdgeAI bench info AD.png

This graph shows the number of learning iterations needed to obtain optimal performance from the library, when it is embedded in your final hardware application. In this particular example, NanoEdge AI Studio recommended that the learn() is called 30 times, at the very minimum.

Warning white.png Warning
  • Never use fewer iterations than the recommended number, but feel free to use more (for example 3 to 10 times more).
  • This iteration number corresponds to the number of lines to use in your input file, as a bare minimum.
  • These iterations must include the whole range of all kinds of nominal behaviors that you want to consider on your machine.

2.4.5. Possible cause for poor benchmark results

If you keep getting poor benchmark results, try the following:

  • Increase the "Max RAM" or "Max Flash"" parameters (such as 32 Kbytes or more).
  • Adjust your sampling frequency; make sure it is coherent with the phenomenon you want to capture.
  • Change your buffer size (and hence, signal length); make sure it is coherent with the phenomenon to sample.
  • Make sure your buffer size (number of values per line) is a power of two (exception: Multi-sensor).
  • If using a multi-axis sensor, treat each axis individually by running several benchmarks with a single-axis sensor.
  • Increase (or decrease, more is not always better) the number of signal examples (lines) in your input files.
  • Check the quality of your signal examples; make sure they contain the relevant features / characteristics.
  • Check that your input files do not contain (too many) parasite signals (for instance no abnormal signals in the nominal file, for anomaly detection, and no signals belonging to another class, for classification).
  • Increase (or decrease) the variety of signal examples in your input files (number of different regimes, classes, signal variations, or others).
  • Check that the sampling methodology and sensor parameters are kept constant throughout the project for all signal examples recorded.
  • Check that your signals are not too noisy, too low intensity, too similar, or lack repeatability.
  • Remember that microcontrollers are resource-constrained (audio/video, image and voice recognition might be problematic).

You may also take a look at guidelines for a successful NanoEdge AI project

Low confidence scores are not necessarily an indication or poor benchmark performance, if the main benchmark metric (Accuracy, Recall, R²) is sufficiently high (> 80-90%).
Always use the associated Emulator to determine the performance of a library, preferably using data that has not been used before (for the benchmark).

Warning DB.png Important

Signal confirmation procedure:

Even with lower accuracy scores, inference results can often be greatly improved by implementing a simple confirmation mechanism in the final algorithm / C code. This approach proves extremely useful, depending on the use case, to limit the number of false positives (or false negatives).

In practice, it consists in validating inference results before raising alerts, instead of taking the outputs of the NanoEdge AI functions directly.
For example, in anomaly detection, anomalies might be counted as "true anomalies" only after N successive validations using consecutive (distinct) data buffers. The same approach can of course be used to confirm "nominal" signals. Validations can be made using counters, or any statistical tool such as means, modes, or others.

The same approach can be used in any project type, to confirm that:

  • a signal belongs to the correct dataset
  • or that a signal is indeed an outlier
  • or that an extrapolated value falls within the expected range, and so on.

2.5. Validation

neai validation.png

In the validation step, you can compare the behavior of all the libraries saved during the benchmark on new dataset. The goal of this step is to make sure that the best library given by NanoEdge is indeed the best among all the other, but also to see if the libraries behave as they should.

The most important features of this steps are:

  • Experiment: select multiple libraries to compare them using the same test files
  • Serial emulator: test a specific library using serial
  • Execution time: get an estimation of the library's execution time
  • Report: get a report containing all the information of the selected library

2.5.1. Experiment

The goal of experiments is to compare libraries between each other to select the one that correspond best to your needs.

In the page is the list of all the libraries found during the benchmark.

  1. Select several libraries
  2. Click 'new experience'
  3. Import test datasets (preferably dataset not used in the benchmark)

Each time a new experiment is done, an id will be associated. It permits the user to create multiples experiences, with different files and libraries and keep track, thanks to the ids, of the results of all those experiences.

You can filter the results of an experience by clicking the eye icon next to an experience id.

Warning DB.png Important

When doing an experiment, multiple outcomes are possible:

  1. The first library works the best and works well even on new dataset. Which is the ideal scenario.
  2. The first library is not the library that work the best, but another library works well. In this case, select the library that works the best.
  3. No library seems to work well on new datasets.

These behavior may come from various reasons:

  • If the datasets used in the benchmark contains too few data, the benchmark can find a library too specialized on these data. Try adding more signal in the datasets.
  • Maybe, the datasets used in the benchmark and the datasets used in the validation are too different (the setup slightly change for example). The libraries will not work well on these new testing data. Try launching a new benchmark with all the data. You can concatenate the two datasets (from the benchmark and for the validation step), shuffle the new dataset and re split it into train and test datasets. Doing so will make the library see a bigger variety of signals. Do not hesitate to do these steps multiple times.

2.5.2. Serial emulator

The serial emulator is made to specifically test a library and its behavior using serial. Each project type has his own emulator (see below) but they share some common aspect:

  • COM Port: You need to select the right COM Port. (left)
  • Serial result: You can download afterward the data logged used for the test. (right)
  • Executables: You can download Windows or Linux .exe emulators. (right)

The Emulator can be used within the Studio interface, or downloaded as a standalone .exe (Windows®) or .deb (Linux®) to be used in the terminal through the command line interface. This is especially useful for automation or scripting purposes.

Info white.png Information

The emulator comes in four different flavors, one for each project type. Refer to their respective documentations:

To learn more about the NanoEdge AI functions to be emulated, refer also to the corresponding library documentations:

Anomaly detection:

AI:neai emulator learning.png

Anomaly detection models are made in a way to be retrainable directly in microcontrollers. To do so, they are trained using only the nominal and tested on nominal and abnormal data.

To use the emulator, you need to first retrain the model logging nominal data. A minimum number of learning is display and correspond to the minimum number of learning computed during the benchmark to ensure the same level of performance displayed in the benchmark. Once finished, click on Go To Detection.

AI:neai emulator ad.png

In detection is displayed:

  • The last inference similarity: The similarity score is a value between 0 and 100% representing the percentage of chance for the signal to be nominal. Generally, we set a threshold at 90% where below we consider the signal being abnormal.
  • The Similarity plot: a plot to represent the similarity score of all the signal of the current simulation. It is possible to change the threshold to distinguish nominal from abnormal.
  • The total repartition pie chart: Another plot to display the repartition of nominal and abnormal detection based on the set threshold.

1-Class Classification:

AI:neai emulator one class.png

The emulator in 1-Class classification is displayed if the signal is a regular signal (nominal) or an outlier (abnormal).

N-Class Classification:

AI:neai emulator n class.png

In N-Class classification is displayed:

  • The detected class: The class with the highest probability.
  • The probability percentage repartition: A plot displaying the probability of being of each class. It gives more details than just the class, you can see if the model is sure about its decision or if it is hesitating between two classes or more.
  • The total repartition pie chart: Another plot to display the total number of detection of each class during the current emulation.


AI:neai emulator extrapolation.png

The emulator in Extrapolation display the current predicted value and plot all the predicted value below.

2.5.3. Possible causes of poor emulator results

Here are possible reasons for poor anomaly detection or classification results:

  • The data used for library selection (benchmark) is not coherent with the one you are using for testing via Emulator/Library. The signals imported in the Studio must correspond to the same machine behaviors, regimes, and physical phenomena as the ones used for testing.
  • Your main benchmark metric was well below 90% or your confidence score was too low to provide sufficient data separation.
  • The sampling method is inadequate for the physical phenomena studied, in terms of frequency, buffer size, or duration for instance.
  • The sampling method has changed between Benchmark and Emulator tests. The same parameters (frequency, signal lengths, buffer sizes) must be kept constant throughout the whole project.
  • The machine status or working conditions might have drifted between Benchmark and Emulator tests. In that case, update the imported input files, and start a new benchmark.
  • [Anomaly detection]: you have not run enough learning iterations (your Machine Learning model is not rich enough), or this data is not representative of the signal examples used for benchmark. Do not hesitate to run several learning cycles, as long as they all use nominal data as input (only normal, expected behavior must be learned).

2.5.4. Execution time

NanoEdge AI Studio allows for the estimation of execution time for any library encountered during the benchmark with the STM32F411 simulator provided by ARM, utilizing a hardware floating-point unit.

The estimation is an average of multiple calls to the NanoEdge AI library functions tested. The tool doesn't use directly the user data but data of a similar range to make the estimation.

It's important to note that while this estimation mimics real hardware conditions, it should be treated as such, and variations in the exact signal may impact execution time. Keep in mind that using another hardware can lead to significant changes in execution time.

2.5.5. Validation report

For each library displayed, the user can click on the blank sheet of paper to open the validation report.

NEAI Validation Summary.png

The validation report contains information about:

  • The data:
    • the name of each file used for the benchmark
    • the data sensor type: sound, vibration, and others
    • the signal length (with the total signal length and the signal length per axis)
    • number of signals in each file
    • the data repartition score (goes up to five stars)

Info white.png Information
  • The data repartition score indicates whether the data is balanced, (whether there are approximately the same number of signals for each class). The score is obtained by comparing the sizes of the class datasets (smallest class dataset/largest class dataset).
  • Here, each file contains 200 signals, so the repartition between the classes is perfect.

The performance:

  • The main metrics: Score, balanced accuracy, RAM and flash memory usage
  • More specific metrics: Accuracy, f1 score, ROC AUC Score, Precision, MCC
  • The recall per class: To know which class perform well, which class perform badly
  • The nested cross validation results (10 test): Show how the model performed on 10 test datasets (to monitor overfitting)

An algorithm flowchart:

  • The entry data shape
  • The preprocessing applied to the data
  • The model architecture name

The user can export the summary page as a PDF using the top right red pdf button.

2.6. Deployment

Here the NanoEdge AI library is compiled and downloaded, ready to be deployed to the target microcontroller to build the embedded application.

NanoEdgeAI deploy screen nb.png

The Deployment screen is intended for four main purposes:

  1. Select a benchmark, and compile the associated library by clicking the COMPILE LIBRARY button.
  2. Optional: select Multi-library, in order to deploy multiple libraries to the same MCU. More information below.
  3. Optional: select compilations flags to be taken into account during library compilation.
  4. Optional: copy a "Hello, World!" code example, to be used for inspiration.

if the target selected at the beginning of the project is a production ready board, you will need to agree to the license agreement:

NEAI validation compilation.png

After clicking Compile and selecting your library type, a .zip file is downloaded to your computer.

NanoEdgeAI 6 zip file.png

It contains:

  • the static precompiled NanoEdge AI library file libneai.a
  • the NanoEdge AI header file NanoEdgeAI.h
  • the knowledge header file knowledge.h (classification and extrapolation projects only)
  • the NanoEdge AI Emulators (both Windows® and Linux® versions)
  • some library metadata information in metadata.json

2.6.1. Arduino target compilation

If an Arduino board was selected in project settings, the .zip obtained in compilation will contains an additional arduino folder. This folder contains another .zip that can be imported directly in Arduino IDE to use Nanoedge.

In Arduino IDE:

  • Click Sketch > Include library > Add .zip library...
  • Select the .zip in the arduino folder

If you already used a NanoEdge AI library in the past, you might get an error saying that you already have a library with the same name. To solve it, go to Document/arduino/libraries and delete the nanoedge folder. Try importing your llibrary again in Arduino IDE.

2.6.2. Multi-library

The Multi-library feature can be activated on the Deployment screen just before compiling a library.

It is used to integrate multiple libraries into the same device / code, when there is a need to:

  • monitor several signal sources coming from different sensor types, concurrently, independently,
  • train Machine Learning models and gather knowledge from these different input sources,
  • make decisions based on the outputs of the Machine Learning algorithms for each signal type.

For instance, one library can be created for 3-axis vibration analysis, and suffixed vibration:

NanoEdgeAI suffix vibration.png

Later on, a second library can be created later on, for 1-axis electric current analysis, and suffixed current:

NanoEdgeAI suffix current.png

All the NanoEdge AI functions in the corresponding libraries (as well as the header files, variables, and knowledge files if any) is suffixed appropriately, and is usable independently in your code. See below the header files and the suffixed functions and variables corresponding to this example:

NanoEdgeAI multilib vibration.png

NanoEdgeAI multilib current.png

Congratulations! You can now use your NanoEdge AI Library!
It is ready to be linked to your C code using your favorite IDE, and embedded in your microcontroller.

Info white.png Information

To learn more about the NanoEdge AI libraries, refer to their documentations:

3. Integrated NanoEdge AI Studio tools

This section presents the tools integrated in NanoEdge AI Studio to help the realization of a project. They are:

  • The Datalogger generator, to create code to collect data on development board in few clicks
  • The Sampling finder, to estimate the data rate and signal length to use for a project in few seconds
  • The data manipulation tool, to reshape dataset easily

NEAI tools.png

These tools can be accessed:

  1. In the main NanoEdge AI Studio screen
  2. At any time, in the left vertical bar.

3.1. Datalogger

Importing signals from Serial (usb) is available when creating a project in the NanoEdge AI Studio provided the user has created a datalogger in the code beforehand (specific to the board and the sensor used).

The datalogger screen automatically generates that part for the user. The user only needs to select a board among the ones available and choose which sensor to use and its parameters.

This is the datalogger screen. It contains all the compatible boards that the Studio can generate a datalogger for:

NEAI datalogger.png

Click on a board to access the page to choose a sensor and its parameters.

NEAI Datalogger param.png

The parametrization screen contains:

  1. The selected board
  2. The list of sensors available on the board
  3. The list of parameters specific to the sensor selected
  4. A button to generate the datalogger

The user must select the options corresponding to the data to be used in a project and click generate datalogger. The Studio generates a zip file containing a binary file. The user only needs to load the binary file on the microcontroller to be able to import signals for a project directly from Serial (usb).

3.1.1. Continuous datalogger

For some sensors on some development boards, the "continuous" option is available as a parameter for the data rate (Hz). If selected, the datalogger will record data continuously at the maximum data rate available on the sensor.

When the continuous data rate is selected, the "sampling size per axis" parameter disappears, as the new signal size is simply the number of axes. For example, if you have a 3-axis accelerometer, each line of your file will contain 3 values.

For speed reasons, continuous data loggers use CDC USB instead of UART. In practice, this means that we use the board's USB port to send data to the PC instead of using the ST-Link port. So make sure you connect the card to the PC using its USB port, otherwise you won't get any data from the datalogger. This also means that once you've flashed the datalogger, you no longer need the ST-Link to record data.

Warning white.png Warning

Currently, it is not possible to log data continuously directly in NanoEdge AI Studio. Please use tools like Putty or Tera Term.

3.1.2. Arduino data logger

NanoEdge Data logger also allow to generate code for Arduino boards. Because of how Arduino works, we don't need to select a specific board. Only the sensor that we want to use.

To be able to use the code generated, here are the steps to follow:

  • Select Arduino in the data logger generator
  • Select the sensor and set its parameters
  • click Generate and get the .zip containing the code from NanoEdge
  • Extract the .ino file from the Nanoedge's .zip
  • Open it with Arduino IDE
  • Select the board that you are using: Tools > board
  • Include all the libraries called in the C code (generally the sensor and wire.h): Sketch > Include Library > manage Library...
  • Flash the code

You are now ready to log data via serial.

3.2. Sampling finder

The sampling rate and sampling size are two parameters that have a considerable impact on the final results given by NanoEdge. A wrong choice can lead to very poor results, and it is difficult to know which sampling rate and sampling size to use.

The tool is designed to help users make informed decisions regarding the sampling rate and data length, leading to accurate and efficient analysis of time-series signals in IoT applications.

How does the sampling finder works:

The Sampling Finder needs continuous datasets logged with the highest data rate possible. The signals in a dataset need to have only one sample per line, meaning for example, 3 values per line if working with a 3 axes accelerometer.

neai sampling finder data shape.png

The tool reshape these data to create buffers of multiple sizes (from 16 to 4096 values per axis).

When creating the buffers, the Sampling Finder also skips values to simulate data logged with a lower sampling rate. The range of frequencies tested goes from the base frequency to the frequency divided by 32. For example, to create a buffer with halve the initial data rate, the sampling finder only use one value every two values.

With the all the combinations of sampling sizes and sampling rates, the tool then apply features extraction algorithms to extract the most meaningful information from the buffers. Working with features instead of the whole buffers permit to be much faster.

The tool try to distinguish all the imported files using fast machine learning algorithms and estimate a score. The final recommend combination is the one that worked best, with both a good score and a small sampling duration.

Warning white.png Warning

It is important to bear in mind that this is only an estimate and does not provide a measure of the accuracy of a mature machine learning model provided in NanoEdge AI Studio.

How to use the Sampling Finder:

To use the sampling finder tool, first import continuous datasets with the highest data rate possible (see the file format above):

  • If working with Anomaly detection, import one file of nominal signals and one file of abnormal signals.
  • If working with N-class classification, import one file of each class.

The steps to use the sampling finder are the following:

  1. Import the files to distinguish
  2. Enter the number of axis in the files
  3. Enter the sampling frequency used
  4. Choose the minimum frequency to test (the maximum number of subdivision of the base sampling frequency)
  5. Start the research

The sampling finder will fill the matrix with the results, giving an estimation for each combination of sampling rate and sampling size and make a recommendation.

After that, the next step is to log data at the sampling rate and sampling size - recommended by the tool and create a new project in NanoEdge using these data.

Warning DB.png Important

The recommended configuration is a compromise between distinction percentage, sampling rate, sampling size but also sampling duration. Depending on which parameter is more important for your use case, a different configuration may be more appropriate.

neai sampling finder matrix.png

3.3. Data manipulation

NEAI datamanip Main.png

NanoEdge AI Studio provides the user a screen to manipulate data. This page is composed of:

  1. The file section: this part is used to manage your import.
  2. The actions section: this part is used to choose a modification to apply on your imported files.
  3. The result section: in this column are displayed your files after being modified.

File Section:

The File section contains all the imported files displayed in this column:

  • A button Drop files or click to import to import one or multiple files at once.
  • All the imported files displayed in column. The name of the file and the number of lines and columns are displayed by default. Additionally, you can preview your entire file by clicking the arrow in the right down corner.

Concatenate: if you import multiple files, a concatenate option appears on top of the file column. You can concatenate files two ways:

  • Row-Wise: if you have a file A with 100 lines and a file B with 50 lines, the concatenate file has 150 lines. You must have the same number of columns.
  • Column-Wise: if you have a file A with 30 columns and a file B with 50 columns, the concatenate file has 80 columns. If you don't have the same number of lines, it will concatenate what it can, meaning that you risk to have lines of different column sizes.

To concatenate, you need to run an action with the concatenate option active. It is recommended to use the Extract lines action to just do the concatenate.

Action Section:

NEAI DataManip ActionColumn.png

The Action section contains all the action to modify your file,the following actions are available:

  • Extract lines: Truncate lines at the beginning and at the end of a files. Enter in the fields, or by using the blue bar, the lines to extract.

NEAI DataManip ExtractLines.png

  • Remove column(s): Delete the selected columns. Select a single column, a range of columns (example 10-20) or multiple columns (example 10,23,32) to delete them.

NEAI DataManip RemoveCol.png


  • Remove axes: Enter the file number of axis, select the axes to delete. You can enter an offset (optional).

AI:neai datamanipulation remove axes.png

The difference between Remove columns and Remove axes is that with remove axes you could easily delete the third axis of a 3-axes accelerometer data just by entering 3 as the number of axes and check the third case. Do to the same with Remove columns, you need to manually check every columns corresponding to the third axis.

  • Change columns number: Reshape (change) the size of the signals in a file (the buffer size). Enter a signals length for the data to be reshaped as.

NEAI DataManip reshape.png

For example, the user can modify signals of size 4096 to smaller signals of size 1024. After applying the data manipulation, all signals of size 4096 are divided into four signals of size 1024 (meaning that the user has four times more signals of size 1024 than of size 4096 previously).

  • Shuffle: Randomly mix all the lines of the imported file(s), just click on Run.

NEAI DataManip Shuffle.png

Warning DB.png Important
  • An action is always performed on all the imported files at once.
  • The imported files are never modified. New files are generated after applying an action

Result Section:

NEAI DataManip ResultColumn.png

The result section contains files that went through a data manipulation. For each imported file, a new result file is generated after performing any action. All the generated result files are displayed in column:

  1. For each result file, a name containing information about the action performed is generated. There is also between parenthesis the name of the original file. The number of lines and columns are also displayed. You can click the arrow in the down left corner to show more information about the file.
  2. You can save any file in the result column by clicking the Save as button. Additionally, you can choose to perform new actions on a result file by clicking the Run new action button. This results in moving the file from the result column to the file column (the imported files).
  3. Save all files appears if there is at least two result files. The user can use it to save all the result files at once.

Info white.png Information

You cannot delete a result file, but you can ignore it and perform other manipulations that replace it.

4. Resources

Recommended: NanoEdge AI Datalogging MOOC.

All NanoEdge AI Studio documentation is available here.

Step-by-step tutorials to use NanoEdge AI Studio to build a smart device from A to Z.