# Deploy a machine learning application to the Arm Ethos-U65 NPU on NXP FRDM i.MX 93 with Topo

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/deploy-ml-model-to-npu-with-topo/)
- [Understand the architecture of the machine learning application](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/deploy-ml-model-to-npu-with-topo/overview/)
- [Understand the toolchains used in the Topo Project](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/deploy-ml-model-to-npu-with-topo/what-are-the-toolchains/)
- [Build the Topo Project from scratch](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/deploy-ml-model-to-npu-with-topo/build-the-project/)
- [Clone and deploy the application with Topo](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/deploy-ml-model-to-npu-with-topo/deploy/)
- [Next Steps](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/deploy-ml-model-to-npu-with-topo/_next-steps/)

## About this Learning Path

|  |  |
| --- | --- |
| Skill level: | Introductory |
| Reading time: | 1 hr |
| Last updated: | 15 Jul 2026 |

|  |  |
| --- | --- |
| Author: | Tomas Agustin Gonzalez Orlando , Arm<br>[GitHub](https://github.com/tgonzalezorlandoarm)<br>[LinkedIn](https://linkedin.com/in/tgorlando) |
| Arm IP: | [Cortex-A](https://support.arm.com/?tab=compute-ip&Product%20Type=Application%20Processors) [Cortex-M](https://support.arm.com/?tab=compute-ip&Product%20Type=Microcontrollers) [Ethos-U](https://support.arm.com/?tab=compute-ip&Product%20Type=Neural%20Processing%20Units) |
| Tags: | [Containers and Virtualization](https://learn.arm.com/tag/containers-and-virtualization) [Linux](https://learn.arm.com/tag/linux) [macOS](https://learn.arm.com/tag/macos) [Windows](https://learn.arm.com/tag/windows) [Topo](https://learn.arm.com/tag/topo) [Docker](https://learn.arm.com/tag/docker) [SSH](https://learn.arm.com/tag/ssh) [ExecuTorch](https://learn.arm.com/tag/executorch) [remoteproc-runtime](https://learn.arm.com/tag/remoteproc-runtime) |

### Who is this for?
This is an introductory topic for embedded/edge software developers who want to deploy machine learning workloads to heterogeneous Arm-based Linux targets using Topo, including leveraging Arm Ethos-U NPUs.

### What will you learn?
After completing this Learning Path, you'll be able to perform the following tasks:
- Explain how Topo deploys an application that spans Cortex-A, Cortex-M, and Ethos-U
- Deploy the topo-imx93-npu-deployment Topo Project, which operates across Cortex-A, Cortex-M, and Ethos-U, to perform image classification using an ExecuTorch MobileNetV2 model
- Describe how the project is bootstrapped from Compose services, Remoteproc Runtime metadata, and Topo parameters and follow this process yourself
- Understand how to take similar projects and create Topo Projects, including using Agent Skills

### Prerequisites
Before starting, you'll need the following prerequisites:
- A host machine (x86 or Arm) with Linux, macOS, or Windows
- An NXP FRDM i.MX 93 target board with Linux setup, accessible over SSH with root access. To do this, see [Use Linux on the NXP FRDM i.MX 93 board](https://learn.arm.com/learning-paths/embedded-and-microcontrollers/linux-nxp-board/).
- Docker installed on the host and target. For installation steps, see [Install Docker](https://learn.arm.com/install-guides/docker/).
- At least 25 GB of free disk space on the host if you’re building without cache images.
- The Device Tree Compiler (`dtc`) installed on the host.
- lscpu installed on the target (pre-installed on most Linux distributions)
- Topo installed on the host. For installation steps, see [Deploy containerized workloads to Arm-based Linux targets with Topo](https://learn.arm.com/learning-paths/cross-platform/deploy-containerized-workloads-with-topo/).
- Basic familiarity with containers, SSH, and CLI tools
- (Optional) Access to an agent, such as Codex or Claude Code

### Summary
You’ll build and deploy a heterogeneous image classification application to an NXP FRDM i.MX 93 board using Topo. First, you’ll assemble a Topo Project from two base projects: a Cortex-A web application and a Cortex-M33 ExecuTorch runner, then convert the combined sources into a Compose project with Topo metadata and Remoteproc Runtime services. The application preprocesses images on Cortex-A, shares model and tensor data through shared memory, and issues RPMsg commands to Cortex-M33 firmware that delegates inference to the Arm Ethos-U65 NPU via the ExecuTorch backend. After validating target readiness with `topo health` and deploying, containers run on the board, and you’ll be able to access a browser-based MobileNetV2 classifier.

### Frequently asked questions

**How do I confirm the FRDM i.MX 93 target is ready before deploying?**

Run `topo health --target <user>@<target-ip>`. The host and target sections should show successful checks for SSH and the container engine, and the target should also report Remoteproc Runtime and Remoteproc as healthy.

**Which components run on Cortex-A and Cortex-M33, and how do they communicate?**

The Cortex-A side runs the web application that prepares images, writes model and tensor data into shared memory, and sends inference commands. The Cortex-M33 runs the ExecuTorch firmware and receives commands over RPMsg.

**What should I expect after deploying the Topo Project?**

Topo builds images on the host, transfers them to the target, and starts services on the board. Remoteproc Runtime starts the Cortex-M firmware, and the browser-based MobileNetV2 classifier becomes available.

**What are the key steps to turn the two base projects into a Topo Project?**

Combine the Cortex-A web app and the Cortex-M33 ExecuTorch firmware sources into a single repository, make it a normal Compose project, then add Topo metadata and Remoteproc Runtime services. The Topo Project is bootstrapped from Compose services, Remoteproc Runtime metadata, and Topo parameters.

<summary>What should I check if `topo health` reports a failure?</summary>
Resolve the specific errors shown by `topo health` before continuing. Confirm SSH access to the target, verify the container engine is available on both host and target, and ensure Remoteproc Runtime is present on the target.