NanoEdge AI Studio

This message will disappear after all relevant tasks have been resolved.

Semantic MediaWiki

There are 1 incomplete or pending task to finish installation of Semantic MediaWiki. An administrator or user with sufficient rights can complete it. This should be done before adding new data to avoid inconsistencies.

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 stm32ai.st.com.

Initial Setup

Enter your license key
Set your proxy settings if you need
Save Settings

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

ST API for library compilation:	52.178.13.227	or via URL: https://api.nanoedgeaistudio.net

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:

Press windows key + R, type %appdata% and press Enter.
Navigate to nanoedgeaistudio folder and open config.json
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:

Offline Activation: Click on "Offline Activation" and enter your license key.
Copy the Activation String: A long string of characters will appear. Copy this string or click the provided link.
Activate License: Paste the string if needed and click "Activate License".
Receive Response String: You will receive a new string as a response. Copy this string.
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. [More information here].
C Library Functions: Includes initialization, learning, and detection functions. [More details here].
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.

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. [More details here].
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. [More details here].
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. [More details here].
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.

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:

Axis/Axes:
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.

Signal:
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.

Sample:
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.

Buffer:
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.

1.4.3.1. Work with temporal buffers

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

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.

1.4.3.2. 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.

1.4.3.3. 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.

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.

1.4.3.4. 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):

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.

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 Multisensor.

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, structured as a matrix.

Multisensor:
If you select Multisensor, you can choose the number of sensors and create buffers with any combination of sensor data.

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.

1.4.4.1. Basic Format

For anomaly detection (AD), N-class classification (NCC), or 1-class classification (1CC) in Cross Sectional projects, the format is as follow: Each buffer can include data from various sensors. For instance, a buffer might contain:

Accelerometer data
Hall effect data
Current data
Time of Flight matrix (as a vector)
Sound sample

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.

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.

1.4.4.2. 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.

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

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.2. Project Steps

On the main screen, select your desired project type on the project creation bar, and click CREATE NEW PROJECT.

Each project is divided into 5 successive steps:

Project settings, to set the global project parameters
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)
Optimize & benchmark, where the best NanoEdge AI Library is automatically selected and optimized
Emulator, to test the candidate libraries before embedding them into the microcontroller
Validation to have a summary of the project benchmarks (data, performance, flows)
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.1. 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, and the number of axes / variables when using a "Generic" sensor or "Multi-sensor".
Target: this is the type of board or microcontroller on which the final NanoEdge AI Library is deployed.

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.1. Target selection

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.

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.

In NanoEdge AI Studio, sensors are divided in 2 distinct groups based on the format of data that you will use:

Time series sensors: Accelerometer, Current, Hall effect, Microphone, Time of Flight or Generic.
Cross sectional sensors:Time of Flight or Multi-sensor

2.2.2.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.

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.

2.2.2.2. Generic and multi-sensor

Generic and multi-sensor are useful if you want to use multiple sensors data. Generic is for the time serie 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):

Muti-sensor is the equivalent of generic buf 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 predic 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 caracteristic of the house as different sensors values.

2.2.3. Signals

2.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:

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

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.

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.

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.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.

Example:

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.2.3.3. Signal summary screen

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

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

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.

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

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.

2.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.

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

NEW BENCHMARK button, and list of benchmarks
Benchmark results graph
Search information window
Benchmark PAUSE / STOP buttons
Performance evolution graph

To start a benchmark:

Click RUN NEW BENCHMARK
Select which input files (signal examples) to use
Optional: change the number of CPU cores to use
Click START.

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.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:

divides all the imported signals into random subsets (same data, cut in different ways),
uses these smaller random datasets to train, cross-validate, and test one single candidate library many times,
takes the worst results obtained obtained from step #2 to rank this candidate library, then moves on to the next one,
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).

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.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

Extrapolation:

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 "R²" 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.
R² (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.

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.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:

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.

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.2.4.4. Benchmark results

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

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).

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:

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

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.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).

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.2.5. Emulator

The NanoEdge AI Emulator is a tool intended to test NanoEdge AI Libraries, as if it they were already embedded, without having to compile them, link them to some code, or program them to their target microcontroller. Each library, among hundreds of thousands of possibilities, comes with its own emulator: it is a clone that makes testing libraries quick and easy, and guarantees the same behavior and performance.

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.

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:

The Emulator screen contains the following information:

Select which benchmark to use, to load the associated emulator
Click INITIALIZE EMULATOR when ready to start testing
Download the emulator in its CLI version (command line interface), and check its documentation
Check the information summary for the benchmark selected (progress, performance, input files used)

Important

Using the emulator is very straightforward, since it mostly consists of importing signals in order to run the inference functions.
However, anomaly detection is an exception. Since anomaly detection libraries come untrained, the emulator must be used to learn some signal examples before running the inference, as outlined below.

2.2.5.1. Learning signals (anomaly detection only)

After initializing the anomaly detection emulator, no knowledge base exists yet. It needs to be acquired in-situ, using real signals.
Note: only "regular signals" (translating the normal / nominal behavior of the target machine) can be used for learning. More generally, only learn what is considered as the norm on your system.

The "regular signals" imported previously (for benchmark) can be reused, but you can also use entirely new signal examples (feel free to test different things!).
Signals can also be imported from a live data logger (serial port).

Anomaly detection emulator workflow: initialization, learning, detection.
Select a file to import, or import data directly from serial (USB).
Optionally, define a custom number of lines to learn.
Then, click LEARN THIS FILE and repeat the operation is needed.
Click GO TO DETECTION to move on to the inference step.
Check the emulator function outputs (same responses as for CLI version of the emulator)

Warning

A learning phase corresponds to several iterations of the learn() function. You must use at least the minimum number of iterations recommended at the end of the benchmark process.
Check the indication N signals learned (see [2] on the screen above) to know how many iterations have been performed.

2.2.5.2. Running inference (detection)

To run inference, in any project type, simply import some data, either from file or from serial port (live data logger).
The detection / classification / extrapolation is automatically run using the signal examples provided, and the results displayed on a graph.
For more details, the raw inference outputs in text format are also available on the Emulator function outputs window (see [4] on the image above) on the right side of the screen.

To restrict the inference to a selected number of lines within the input file, just tick the Define lines box, input the first and last lines to consider, and click the DETECT button.

Warning

In extrapolation projects, the input files must not contain any target value (they are unknown during inference), only the data buffers (known parameters) are required.
See this section for more information.

2.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.2.6. Validation

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.

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

Select several libraries
Click 'new experience'
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.

Important

When using the validation tool, multiple outcomes are possible:

The first library works the best and works well even on new dataset. Which is the ideal scenario.
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.
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.2.6.1. 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.2.6.2. Validation report

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

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)

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.2.7. Deployment

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

The Deployment screen is intended for four main purposes:

Select a benchmark, and compile the associated library by clicking the COMPILE LIBRARY button.
Optional: select Multi-library, in order to deploy multiple libraries to the same MCU. More information below.
Optional: select compilations flags to be taken into account during library compilation.
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:

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

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.2.7.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.2.7.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:

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

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:

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.

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

These tools can be accessed:

In the main NanoEdge AI Studio screen
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:

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

The parametrization screen contains:

The selected board
The list of sensors available on the board
The list of parameters specific to the sensor selected
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

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.

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

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:

Import the files to distinguish
Enter the number of axis in the files
Enter the sampling frequency used
Choose the minimum frequency to test (the maximum number of subdivision of the base sampling frequency)
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.

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.

3.3. Data manipulation

NanoEdge AI Studio provides the user a screen to manipulate data:

This page is composed of:

The button to access the data manipulation screen.
The file column: this part is used to manage your import.
The actions column: this part is used to choose a modification to apply on your imported files.
The result column: In this column are displayed your files after being modified.

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.
A concatenate option is proposed if at least two files are imported. If you use the concatenation option, all the imported files are combined into one single file.

The Action section contains all the action to modify your file are displayed in this column:

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

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 then click Run.

Remove column(s): Enter the number of a single or multiple columns to delete (separated by commas) then click Run.

The user can enter columns to delete one by one separated by commas or directly enter range of columns to delete using dashes (example 10-20 deletes the columns from 10 to 20). The user can delete both single column and range at the same time as in the example.

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 then click Run.

The user can enter the size desired (the number of columns) to reshape the data. 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 thans of size 4096 previously).

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

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:

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.
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).
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.

Information

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

3.3.1. Advanced manipulation (combination)

By repeating the same action many times or combining different actions, the user can perform other manipulations:

Create sub datasets: The user can use the Extract lines action several times to split a dataset for example (extract the first half lines, save it, then extract the second half and save it). The user can also create a sub dataset by extracting 10 lines at a time for example and have multiples subsets.
Remove an axis: By combining Create buffer and Remove column(s), the user can delete an axis in the signals. For example, if the user has 3 axis signals and wants to delete one of them, the user can reshape the signals to a size of 3, then remove the axis wanted using the remove columns action, and then reshape the data back to the original size.

4. Resources

Recommended: NanoEdge AI Datalogging MOOC.

Documentation
All NanoEdge AI Studio documentation is available here.

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