Getting Hands-On with NXP eIQ: A “No Code” Starter Guide for Edge AI Developers
Introduction
In a world driven by AI and IoT, deploying machine learning at the edge has become essential. NXP’s eIQ™ Machine Learning Software simplifies this process by offering a powerful yet user-friendly platform to build, train, evaluate, and deploy ML models — even for those new to AI.
In this blog, we’ll walk you through how to get started with eIQ, explore its intuitive GUI, and deploy your first model on an i.MX93 processor.
What is NXP eIQ?
NXP’s eIQ (Edge Intelligence Environment) is a development environment that simplifies AI/ML on edge devices. It includes toolkits, libraries, and optimized runtimes, all designed to work with NXP’s application processors like the i.MX93 series.
eIQ Portal allows developers to train, evaluate, and deploy machine learning models without writing complex code.”
Downloading the EIQ Software...
You can download the NXP eIQ software from the official source using the link below:
Launching the eIQ Portal
Once installed, launch the eIQ Portal. The clean, modern GUI presents all essential components.
Here’s what each option means:
1) Top Menu Bar:
- Plug-ins: Manage and explore additional components that can enhance functionality.
- Remote Devices: Configure and connect to edge hardware (e.g., i.MX RT, i.MX 8M, etc.) to deploy models directly.
- Settings: General software preferences, paths, tools, and version setups.
- Marketplace: Access downloadable ML models, datasets, or plug-ins provided by NXP or the community.
- Help: Access documentation, tutorials, and support.
2) Main Action Buttons (Center):
Create Project: Start a new ML project from scratch
Open Project: Load an existing project
Model Tool: Train, evaluate, and convert models
Time Series: Work with sensor/temporal data
Vision Deployment: Optimize and deploy image-based models
Command Line: Advanced users can run automated workflows or batch tasks via CLI
Two Approaches to Building AI Models with eIQ
Before diving into the hands-on part, it’s important to understand that NXP’s eIQ Toolkit provides two distinct approaches for edge AI development:
1. Bring Your Own Data (BYOD)
This method is ideal for beginners and those who want to train a custom model from scratch. You start by importing a dataset, training a model, optimizing it for your target hardware (like the i.MX93), validating it, and finally deploying it.
✅ In this blog, we’ll follow this approach using a public dataset you can download from the internet.
2. Bring Your Own Model (BYOM)
This approach is for users who already have a trained machine learning model. You simply load and visualize the model, convert and optimize it using eIQ Portal or Model Tool, and deploy it to your target device.
Step 1: Create Your First Project
Click on the dropdown menu next to ‘CREATE PROJECT‘ and select the ‘Import Dataset‘ option.
Step 2: Importing Dataset
When importing a dataset in eIQ Portal, you are presented with three main options:
VOC Dataset: Typically used for object detection tasks. This requires a
.tarfile containing two subfolders —Annotations(with.xmlfiles) andJPEGImages(with.jpgfiles).Structured Folders: Designed for image classification tasks. This format requires a clearly defined folder structure with
trainandtestsubfolders. Each of these contains class-labeled subfolders, with each label folder holding the corresponding images.TensorFlow Datasets: Offers access to standard image classification and object detection datasets directly from TensorFlow’s dataset collection using a built-in interface.
For this guide, we’ll select the Structured Folders option because we are focusing on a basic image classification task. It’s the simplest and most intuitive format for beginners, especially when using a custom or readily available dataset from the internet.
Upload the Dataset: After selecting Structured Folders, a file browser will appear on the top-left side of the screen. Use it to upload the dataset you downloaded from the internet. Ensure it follows the required folder structure (i.e.,
trainandtestfolders with labeled subfolders).Import the Dataset: Once the dataset is selected, click on the Import button to begin uploading it to the system.
Wait for Completion: Note: The import process may take several minutes depending on the size of your dataset, so please be patient.
Step 3: Model Selection
Once your dataset is successfully imported, you’ll see all the images displayed on the screen, along with their corresponding labels listed on the top-left side.
Next, click on Select Model to proceed.
After clicking on Select Model, you’ll be presented with three model options:
🔹 Classification
What it does: Identifies the main object in an image (e.g., cat, dog, car).
When to use: Choose this when you want to assign a single label to the entire image based on its content.
🔹 Segmentation
What it does: Labels each pixel in the image to define different regions or objects.
When to use: Ideal for tasks like medical imaging, scene analysis, or road/lane detection where pixel-level accuracy is required.
🔹 Detection
What it does: Detects and localizes multiple objects within an image using bounding boxes, along with their labels.
When to use: Best suited for real-time object detection tasks such as identifying pedestrians, vehicles, or faces in a video feed.
👉 In this blog, we’ll choose Classification, since our goal is to perform image classification using the imported dataset.
Next, Choose Your Model’s Inference Mode
Once you’ve selected the Classification model, you’ll be prompted to choose one of three inference modes, each optimized for a different use case:
1) Performance Mode
Goal: Achieve the fastest inference speed (lowest latency).
Trade-off: May reduce overall accuracy.
Use when:
You’re working on microcontrollers or resource-constrained devices
Real-time responses are more important than perfect predictions
Speed > Accuracy
2) Balanced Mode (Recommended for this blog)
Goal: Provide a middle ground between speed and accuracy.
Use when:
You’re targeting embedded platforms (like i.MX93)
You want a good balance between model performance and prediction reliability
You don’t want to heavily favor either speed or accuracy
Why we chose Balanced mode ?:
Balanced mode is ideal for edge AI development where both inference speed and accuracy matter. Since we are building an image classification model for deployment on an NXP i.MX93, which is an embedded device with AI capabilities, Balanced mode gives us the best trade-off for real-world use without overloading the system or compromising too much on prediction quality.
3) Accuracy Mode
Goal: Maximize model accuracy.
Trade-off: Slower inference speed.
Use when:
Accuracy is mission-critical (e.g., healthcare, safety)
You’re okay with increased latency for better precision
By choosing Balanced, we ensure our model runs efficiently on the target hardware while maintaining acceptable accuracy for classification tasks.
Next we have hardware optimization targets:
MCU (Microcontroller Unit)
Description: Optimizes your model for ultra-low-power microcontrollers.
Key Features:
Smallest compute capability.
Best suited for quantized models (smaller, faster).
Also supports floating-point models (though less efficient).
Use case: Ideal for battery-operated devices like wearables or small IoT devices with limited memory and no OS.
CPU (Central Processing Unit)
Description: Optimizes for general-purpose CPUs.
Key Features:
Supports both floating-point and quantized models.
Quantized models run faster.
Use case: Best for applications running on edge devices or PCs with general-purpose CPUs.
GPU (Graphics Processing Unit)
Description: Optimizes for GPUs that accelerate large matrix operations.
Key Features:
Ideal for parallel processing.
Speeds up training and inference for large models.
Use case: Useful when real-time image processing or larger model inference is needed and a GPU is available.
NPU (Neural Processing Unit)
Description: Optimizes model inference for dedicated AI hardware accelerators.
Key Features:
Only supports quantized models.
Provides highest performance for AI workloads with lowest power consumption.
Use case: Perfect for edge AI tasks on platforms like the NXP i.MX93, which has an integrated NPU.
Why we use NPU: We choose NPU because:
Our target hardware (e.g., NXP i.MX93) features a built-in Neural Processing Unit.
It offers superior performance per watt compared to CPU or GPU.
It’s designed specifically for running AI models efficiently at the edge.
It enables real-time inference without offloading to cloud or using more power-hungry GPUs.
Step 4: Model Training
In this step, we will train our neural network model. On the left side of the window, you’ll find all the training parameters. Let’s go through each one and understand what they mean before starting the training process.
Input Size: 128, 128, 3
This defines the shape of the input images fed into the neural network.
128: Height of the image in pixels128: Width of the image in pixels3: Number of color channels (Red, Green, Blue)
Note: We’re using 128×128 pixel RGB images, which provide more detail compared to the standard 32×32 size. This helps the model learn more nuanced features, especially useful for tasks like object classification or detection.
Epochs to Train: 10 (or more)
An epoch refers to one complete pass through the entire training dataset.
Training for
10epochs means the model will see every image in the dataset 10 times.More epochs generally lead to better learning—but too many can cause overfitting.
Best Practice: Start with 10 epochs and adjust based on performance. More epochs allow the model to learn deeper patterns in the data.
Bonus Training Parameters
Other useful options available in the UI:
Learning Rate: Controls the size of updates during training.
A value like0.0001is a safe starting point.Batch Size: Determines how many images are processed before updating the model.
In our case, it is set to10.Enable QAT (Quantization-Aware Training):
This trains the model with quantization in mind, which helps it perform better when deployed on NPUs (like the one in i.MX93).Enable Pruning/Clustering:
These are optimization techniques to reduce the size and complexity of the model, which can improve inference speed and reduce memory usage.
Start Training
Once you’ve set:
Input Sizeto128, 128, 3Epochsto at least10
Click on Start Training.
Training Time: It will take several minutes depending on your dataset size and system configuration.
Step 4: Model Validation
Next, click on Validate to evaluate the model.
Validation helps assess the model’s accuracy and performance to ensure it has been trained and optimized effectively.
Once validation is complete, you will see the confusion matrix displayed on the screen.
What is a Confusion Matrix?
A confusion matrix is a table used to evaluate the performance of a classification model. It shows how well the model’s predictions match the actual labels from the dataset.
Structure of a Confusion Matrix (for 2 classes):
| Predicted: Positive | Predicted: Negative | |
|---|---|---|
| Actual: Positive | True Positive (TP) | False Negative (FN) |
| Actual: Negative | False Positive (FP) | True Negative (TN) |
What Each Term Means:
True Positive (TP): The model correctly predicted the positive class.
True Negative (TN): The model correctly predicted the negative class.
False Positive (FP): The model incorrectly predicted the positive class (Type I error).
False Negative (FN): The model incorrectly predicted the negative class (Type II error).
Why It’s Useful:
The confusion matrix gives a more detailed view of model performance beyond just overall accuracy. It allows you to calculate important evaluation metrics:
Precision = TP / (TP + FP)
Recall = TP / (TP + FN)
F1 Score = 2 × (Precision × Recall) / (Precision + Recall)
These metrics help you better understand how your model performs on imbalanced datasets or in critical applications where false positives or false negatives have different consequences.
Next to the confusion matrix, you’ll find the Per Class Metrics section, which shows the accuracy of each individual class.
This helps you understand how well the model is performing for each specific category in your dataset — especially useful if your dataset is imbalanced or contains multiple classes.
After this click on deploy model.
Step 5: Model Deployment
When you click on Model Deploy, you’ll be presented with two options:
Deploy Directly – Flash the trained model directly to your target device (e.g., i.MX93) from your PC using the tool.
Export Model Files – Save the model files locally, transfer them to an SD card, and then insert the SD card into your microprocessor for deployment.
That’s it! Your model has now been successfully created using the NXP eIQ software and is ready for deployment.
For a more detailed walkthrough, feel free to check out our YouTube video where we explain the NXP eIQ software step by step.
👉 Click here for youtube link
