Arm ML-examples: A Reference Collection for Ethos-U, Corstone and KleidiAI Workflows

What Problem the Repository Actually Solves

Getting a quantized neural network onto an Arm microcontroller with an Ethos-U NPU is not a single-tool problem. You need a model conversion path, a compiler that understands the NPU's operator constraints, and a simulator or board to run the result on. The ML-examples repository is Arm's attempt to publish that whole chain as runnable code rather than as prose documentation. The README describes it as "source code for machine learning tutorials and examples" covering the Ethos NPU, Cortex-based platforms, Corstone reference platforms and KleidiAI. That framing matters: this is teaching material, not a product. Each of the six listed projects targets a different point in the Arm ML toolchain, and the repository is best understood as a set of independent demonstrations that happen to share a home. If you are evaluating whether to adopt it, the question is not whether the repository as a whole is good, but whether the one subdirectory matching your target hardware is complete enough to save you a week of setup.

The Six Projects and What Each One Targets

The README lists six entries. Ethos-U NPU on Corstone-300 covers the Cortex-M55 plus Ethos-U55 combination. Ethos-U NPU direct drive on Corstone-1000 covers a different pairing, Cortex-A320 with Ethos-U85, running on an FVP (Fixed Virtual Platform). KleidiAI examples demonstrate usage of the KleidiAI library, which is Arm's set of micro-kernels for CPU inference. Pruning and clustering in Ethos-U addresses model compression, with the README stating the goal is to "significantly reduce bits per weight when using the Ethos family of NPUs." PyTorch / ExecuTorch example of training Conformer trains a transformer-based speech recognition network and exports it to Ethos-U through ExecuTorch. RNN unrolling for .tflite format is a Jupyter notebook that trains an RNN in TensorFlow and then unrolls it before exporting to TensorFlow Lite. Two of these are about getting models onto NPUs, two are about model preparation techniques, one is about a CPU kernel library, and one is about a specific export transformation. There is no shared build system implied by the README, and no single entry point. Treat the list as a menu.

How the Pieces Fit Together Mechanically

The architecture visible in the material is a pipeline per project rather than a framework. For the Corstone-300 and Corstone-1000 examples, the flow runs from a trained model, through a converter, into a compiled artifact that executes on either an FVP or physical silicon. The Corstone-1000 entry is described as "direct drive," which distinguishes it from the Corstone-300 path where the NPU is driven through a host Cortex-M core. That distinction changes what your application code looks like: direct drive means the ML workload is dispatched without the same host-side orchestration layer. The Conformer project adds a training stage before export, using ExecuTorch as the bridge to Ethos-U. The RNN project adds a graph transformation (unrolling) between training and export, which the README frames as preparation for the .tflite format. The pruning and clustering project sits earlier still, operating on the model to reduce weight precision before any of the deployment paths run. So the repository covers three distinct stages: model preparation, model conversion, and deployment to a target. Which stage you need determines which subdirectory you open.

Getting an Example Running: What the Material Specifies

The root README does not contain install commands, configuration keys, or environment setup. It provides a project list and links into per-project README files, for example ethos-u-corstone-300/README.md, ethos-u-corstone-1000/README.md, kleidiai-examples/ and pruning-clustering-ethos-u/README.md. That is the extent of what can be confirmed from the supplied material. Anyone planning to run these examples should expect the actual prerequisites (Python version, TensorFlow or PyTorch version, the Arm FVP installation, the Ethos-U compiler version) to live in those subdirectory READMEs, not at the repository root. The homepage points to Arm's AI/ML developer space at developer.arm.com, which is where Arm hosts its broader ML documentation. If you need a concrete command to run, the honest answer is that it is not in the top-level README, and the subdirectory README is the file to read first. Do not assume the six projects share a virtual environment or a requirements.txt at the root; nothing in the material suggests they do.

Where This Collection Falls Short

The main limitation is structural. Six unrelated tutorials under one repository means there is no common abstraction, no shared utility layer, and no guarantee that a fix or version bump in one project propagates to the others. The release history supports that reading: the listed releases are identified only by numeric IDs with dates in 2024 and 2025, which tells you releases exist but not what changed or which subproject they touched. If you are building a product, you are not adopting a dependency here; you are copying reference code and owning it. A second limitation is hardware specificity. The Corstone-300 example is bound to Cortex-M55 with Ethos-U55, and the Corstone-1000 example to Cortex-A320 with Ethos-U85. Neither transfers to a different NPU configuration without rework. The KleidiAI examples sit in a different world entirely, CPU micro-kernels rather than NPU offload, so a reader looking for one coherent Arm ML story will not find it. Finally, the README does not state supported host operating systems, Python versions, or toolchain versions. That information may exist in the subdirectories, but it is not verifiable from the material supplied here, and that gap is itself a reason for caution.

Alternatives and the Difference in Approach

The closest alternative in spirit is the vendor-neutral model conversion path built around TensorFlow Lite and its own post-training quantization tooling, or the ONNX ecosystem with runtime-specific execution providers. The difference is one of assumption. A generic TFLite workflow assumes you will handle target-specific compilation yourself and gives you a converter plus a runtime. The Arm examples assume the opposite: they start from a named Arm target (Ethos-U55 on Corstone-300, Ethos-U85 on Corstone-1000) and work backwards, which means the code carries Arm-specific steps such as the NPU compiler invocation and FVP execution. That makes the Arm examples faster to start and narrower in reach. If your deployment target is not an Arm NPU, the conversion logic in these projects will not help you. If it is, a generic TFLite tutorial will leave you to discover the Ethos-U constraints on your own. There is also ExecuTorch, which appears here as the export mechanism for the Conformer example; using ExecuTorch directly without the Arm example means you supply your own understanding of the Ethos-U backend, which is precisely the knowledge the example encodes.

Maintenance, Licensing and What to Verify

The repository is licensed Apache-2.0 and is not archived, with a last push date in July 2026. Apache-2.0 permits commercial use and modification and includes a patent grant, which is a permissive arrangement for reference code you intend to adapt. Two caveats apply. First, the repository-level licence covers the code in the repository; it does not automatically extend to models, datasets or third-party binaries that an example downloads or expects you to obtain separately, and those may carry their own terms. Second, Apache-2.0 requires that you preserve notices and state significant changes when you redistribute, which matters if you fork an example into a product. On maintenance cost: with six independent projects and releases labelled only by numeric IDs, tracking upstream changes means watching each subdirectory individually. There is no changelog in the supplied material that maps a release to a specific project. If you depend on one example, pin it and diff it yourself rather than assuming a repository-level release note will tell you what moved. That is the practical cost of a curated collection over a versioned library.

Editorial conclusion

Adopt this repository if you are targeting Ethos-U55, Ethos-U85 or a Corstone reference platform and want a starting point that already reflects Arm's own tooling assumptions. Do not adopt it if you need a supported library with a stable API surface; this is a tutorial collection, and each subdirectory carries its own README and its own dependencies. Before committing, open the README inside the specific subdirectory you intend to use, confirm which FVP or hardware target it names, and check the licence header on any third-party model or dataset the example pulls in, because the repository-level Apache-2.0 notice does not automatically cover assets fetched at runtime.

Official sources

1. Arm-Examples/ML-examples on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases