Ethos-U deployment workflow

You will use this workflow:

1. Prepare MobileNetV2 weights, labels, sample image, and input specification.
2. Try FP32 Ethos-U lowering and explain why it does not delegate.
3. Calibrate, quantize, and lower MobileNetV2 to INT8 for Ethos-U.
4. Read the Vela compiler report and ExecuTorch delegation summary.
5. Insert an unsupported operator and compare delegation fragmentation.
6. Build and run the INT8 .pte artifact on the Corstone-320 FVP.
7. Decode raw output and check classification behavior.
8. Build a small classification application around the same .pte artifact.

Optional sections appear near the workflow step they extend. You can skip them on a first pass and still complete the module. Open them when you want to explore further.

You are recommended to either use a Linux development machine, or a Linux cloud instance over SSH. This will enable use of the Fixed Virtual Platform (FVP) for Ethos-U simulation. More details on this will be provided in the next section.

ExecuTorch Ethos-U workflow

The simplified flow is:

    

        
        
PyTorch model
  -> torch.export
  -> PT2E quantization with EthosUQuantizer
  -> TOSA lowering
  -> Vela compilation
  -> ExecuTorch `.pte` artifact
  -> executor runner
  -> Corstone-320 FVP

    

This follows a similar general workflow to Modules 1–3. The Ethos-U path adds two backend-specific steps: lowering supported graph regions to TOSA and compiling them with Vela.

TOSA (Tensor Operator Set Architecture) is a standardized intermediate representation used by the ExecuTorch Ethos-U backend to pass supported graph regions to Vela. Other backends, such as XNNPACK, lower regions into their own backend-specific representation and do not use TOSA.

Vela is Arm’s compiler for Ethos-U. It performs target-aware operator selection, scheduling, memory planning, and command-stream generation. ExecuTorch packages the resulting command stream and the rest of the program into the .pte artifact.

Python runs on the Linux host to load, calibrate, lower, and serialize the model. It is not part of the deployed application.

The Corstone-320 FVP runs the same kind of bare-metal C++ application used on a Cortex-M target. The executor runner links the ExecuTorch runtime, Ethos-U delegate and driver, memory allocators, and platform I/O into one ELF. At runtime, it loads the .pte artifact, supplies the input tensors, and invokes the model method.

The compile specification used throughout the module contains three important settings:

Script layout

The AOT steps run on a Linux machine, which also runs the FVP simulation of the target.

    

        
        
scripts/aot                preparation, FP32 lowering, calibration, INT8 quantization, and Ethos-U lowering
scripts/fvp                input tensor creation and output decoding
apps/fvp_image_classifier  application code for MobileNetV2 top-5 classification
artifacts                  generated weights, `.pte` artifacts, runners, and logs
results                    optional result summaries generated during the module

    

Development and target environments