Single Blog

The i.MX93 is an edge AI-enabled MPU from NXP with:

• Arm Cortex-A55 (Dual-core)

  • Runs Linux (Yocto) OS

  • Handles AI workloads, networking, file systems

• Arm Ethos-U65 NPU

  • Specialized Neural Processing Unit

  • Accelerates INT8 AI inference at the edge

• Arm Cortex-M33 MCU

  • Dedicated real-time controller

  • Runs bare-metal or RTOS (FreeRTOS, Zephyr)

  • Handles deterministic tasks like sensor sampling, GPIO control, motor control, or low-latency signal processing

• Supports TensorFlow Lite, ONNX, and eIQ Toolkit

• Runs Yocto Linux (custom embedded OS)
  
  
  

There are two primary deployment methods:

Method 1: Using TensorFlow → TensorFlow Lite

This method is framework-agnostic and lets you use open-source tools.

 Steps:

1. Train the model on PC (e.g., detect helmet):

   • Use TensorFlow/Keras

   • Save model in .h5 or .pb format

2. Convert to TensorFlow Lite:

   • Use TFLiteConverter to convert to .tflite

   • Apply post-training quantization to reduce size:

     python

     CopyEdit

     converter.optimizations = [tf.lite.Optimize.DEFAULT] tflite_model = converter.convert()

3. Transfer to i.MX93:

   • Via SD card or SCP

   • Place .tflite model in a known directory

4. Write inference script on i.MX93:

   • Use tflite-runtime or TensorFlow Lite Interpreter

   • Process camera frames

   • Run inference

   • Control GPIOs (like buzzers) via Linux

5. Install Dependencies:

   • Manually install:

     • tflite-runtime

     • opencv-python

     • numpy

Pros and Cons

 Method 2: Using NXP’s eIQ Toolkit (Recommended for i.MX)

This is NXP’s official AI deployment framework for i.MX devices. It simplifies optimization and deployment by leveraging hardware-aware tools.

 Steps:

1. Train your model:

   • Model was trained using NXP’s eIQ Toolkit, which provides:

     • GUI- and CLI-based model training and management

     • Support for importing custom datasets

     • Built-in training pipelines using TensorFlow backend

   • You can also use:

     • Pre-trained models

     • Import models in formats like .tflite, .onnx, or .pb directly into eIQ

2. Import into eIQ Toolkit (GUI or CLI):

   Once training is complete, optimize the model specifically for the Ethos-U65 NPU in i.MX93:

   • Apply INT8 quantization (reduces model size and speeds up inference)

   • Perform compiler optimizations for the NPU

   • Run model validation within eIQ to verify accuracy and compatibility

3. Deploy to i.MX93:

   Once your model is optimized using eIQ Toolkit, you have two deployment options:

   ---

   🔹 Method 1: Direct Deployment via eIQ Toolkit

   • Use NXP’s Yocto Linux image with eIQ SDK pre-installed

   • Transfer the optimized .eiq model file to the i.MX93 using:

     • SCP (Secure Copy Protocol over SSH), or

     • USB connection / Ethernet, depending on setup

   • This is a faster and more integrated method, requiring no intermediate storage like SD cards

   ---

   🔹 Method 2: TFLite Export & SD Card Transfer

   • Export your trained model in TensorFlow Lite (.tflite) format

   • Store the .tflite file onto an SD card

   • Insert the SD card into the i.MX93’s SD card reader

   • From there, you can load and run the model using TensorFlow Lite interpreter or convert it inside the device

4. • Capture real-time images from a USB or MIPI camera

   • Run inference on the Ethos-U65 NPU

   • Trigger GPIO outputs (buzzer, LEDs, etc.) using built-in libraries

     Run Inference with eIQ Runtime:

     Use eIQ Runtime APIs (C++ or Python) on the i.MX93 to:

      

This gives flexibility based on development preference:

• Use Method 1 for seamless integration with the eIQ flow

• Use Method 2 if you’re working in a TensorFlow-first environment or prototyping offline

Pros and Cons

Summary Table: TF Lite vs. eIQ Toolkit on i.MX93

If you’re deploying specifically on NXP i.MX93, using eIQ Toolkit is the faster, more efficient, and production-ready option — especially when targeting real-time inference on low power.