# 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  |
| [GitHub](https://github.com/tgonzalezorlandoarm) |
| [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?
Upon completion of this Learning Path, you will be able to:
- 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 will need the following:
- 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

<details>
<summary>How do I confirm the FRDM i.MX 93 target is ready before deploying?</summary>
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.
</details>

<details>
<summary>Which components run on Cortex-A and Cortex-M33, and how do they communicate?</summary>
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.
</details>

<details>
<summary>What should I expect after deploying the Topo Project?</summary>
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.
</details>

<details>
<summary>What are the key steps to turn the two base projects into a Topo Project?</summary>
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.
</details>

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