Bringing Visual Graph Debugging to Custom Edge Compilers with Model

On October 20, 2026, Eric Yang, a software engineer, and Alan Ma, a staff software engineer, described Arm's use of Google AI Edge Model Explorer beyond high-level model graphs. Google Developers Blog's report covers open-source TOSA, VGF, and PTE adapters on Model Explorer's hierarchical graph visualization and plugin architecture. The models run on low-power edge devices, gaming graphics, and physical AI systems.

This piece is for engineers compiling PyTorch, LiteRT, or ExecuTorch models on Arm backends. It covers three checks along quantization, graph lowering, operator fusion, and hardware delegation: unintended operators in the export, NPU or GPU delegation versus CPU fallback, and cycle-level bottlenecks on the graph.

Bringing Visual Graph Debugging to Custom: what actually changed

A framework change or an operator constraint can alter the exported execution graph. Reading raw flatbuffers or text logs is slow for large language models and neural networks, and Arm needed a visual tool for Arm-specific intermediate representations and hardware profiling traces. Arm built open-source TOSA, VGF, and PTE adapters on Model Explorer's plugin architecture. Teams use them to validate exported pipelines, verify accelerator delegation, and mark cycle-level bottlenecks on the graph. The post is filed under Mobile, AI, Case Studies, Learn, and Explore.

The VGF case is a PyTorch-trained Neural Super Sampling model, NSS, exported through the ExecuTorch Arm backend for Vulkan ML Extensions. The overview shows the graph partition and its connections to the model inputs and outputs. Inspection found unintended TRANSPOSE operators introduced by a change in the ExecuTorch Arm backend. The rescale node shows that operator's attributes and its SPIR-V input and output tensor connections. Arm used the node view to identify and resolve the regression without manually analyzing raw log files.

Bringing Visual Graph Debugging to Custom: how it works

The posted steps are to install Google AI Edge Model Explorer, install the adapter for the format, and launch Model Explorer locally. Built-in adapters cover LiteRT, PyTorch, and Hugging Face Transformers. Arm plugins cover TOSA, VGF, and PTE. The user guide's major features are graph navigation and split view side by side. Navigation opens a node and its attributes. In the NSS VGF graph, the rescale node shows attributes and SPIR-V input and output connections. The VGF adapter loads that ExecuTorch Arm backend file.

Split-pane view places two graphs side by side. On the Arm Ethos-U85 NPU, Arm compared an Ultralytics YOLO CPU graph with the NPU-delegated graph. The CPU graph displays each layer. The NPU graph groups the network into one EthosUBackend block between quantize and dequantize nodes. Partial LiteRT or ExecuTorch support shows un-delegated operators and split subgraphs there. On the Ethos-U, Arm used the Fixed Virtual Platform simulator and the node data plugin to overlay cycle-accurate traces, and the heatmap marked one TRANSPOSE node as the latency bottleneck.

Bringing Visual Graph Debugging to Custom: why it matters now

Three questions follow when an exported edge graph changes. Structural integrity asks whether graph lowering introduced unintended operators such as extra layout transposes. Hardware delegation asks whether the model is fully delegated to the NPU or GPU, or has unsupported subgraphs falling back to the CPU. Cycle-level bottlenecks ask which lowered nodes take the most compute cycles. Raw flatbuffers and text logs answer slowly for large language models and neural networks. Quantization, graph lowering, operator fusion, and hardware delegation are the compilation steps edge hardware requires.

Each Arm walkthrough answers one question. The NSS VGF export for Vulkan ML Extensions held TRANSPOSE operators from an ExecuTorch Arm backend change, and the rescale node's SPIR-V connections helped resolve them. Ultralytics YOLO on the Ethos-U85 shows every layer on the CPU and one EthosUBackend block between quantize and dequantize on the NPU. Operators left outside that block are the partial LiteRT or ExecuTorch case. On the Ethos-U, Fixed Virtual Platform traces and the node data plugin marked one TRANSPOSE node as the latency bottleneck.

Bringing Visual Graph Debugging to Custom: who is affected

The adapters serve teams optimizing on-device models locally. PyTorch developers exporting through the ExecuTorch Arm backend can open a VGF file such as Neural Super Sampling for Vulkan ML Extensions and inspect partitions, inputs, outputs, rescale, and TRANSPOSE. Vision developers can compare an Ultralytics YOLO CPU graph with the delegated graph on the Arm Ethos-U85 NPU. Ethos-U cycle counts come from the Fixed Virtual Platform. LiteRT and ExecuTorch developers with partial operator support use the split view to find un-delegated operators and split subgraphs.

Acknowledgements list Arm engineers Narumol Prangnawarat, Joshua Slater, Stefana Simion, Adam Hodson, Alona Enraght-Moony, Áron Virginás-Tar, Carey Williams, Gleb Vinnychenko, Hamza Arslan, Marco Domingo, Matthew Sloyan, Michael Mc Curtin, Mitch Bailey, Richard Burton, Robert Hughes, Robert Taylor, and Tomás Agustín González Orlando. Google engineers: Alan Ma, Eric Yang, Jing Jin, and Na Li. Product managers: Charlie Stokes (Arm) and Derek Bekebrede. Designers: Ami Kubota, Ioannis Politis (Arm), Kathleen Low, and Philip Watson (Arm). Senior sponsors: Bala Gattu (Arm), Cormac Brick, Joe Alderson (Arm), Matthias Grundmann, and Sharbani Roy (Arm).

Bringing Visual Graph Debugging to Custom: what to watch

Google AI Edge Model Explorer and Arm's open-source adapters are available today via PyPI or GitHub for local inspection and optimization. The path is to install Model Explorer, install the matching adapter, and launch it for that format. Built-in adapters are LiteRT, PyTorch, and Hugging Face Transformers. Arm plugins are TOSA, VGF, and PTE. The user guide features graph navigation and split view side by side. Extra TRANSPOSE operators are what an ExecuTorch Arm backend change left in the NSS VGF export.

On the Ethos-U85, a delegated network shows up as one EthosUBackend block between quantize and dequantize nodes, while the CPU graph still lists each layer. Separate layers in a LiteRT or ExecuTorch export are un-delegated operators and split subgraphs. On the Ethos-U, a Fixed Virtual Platform run supplies cycle-accurate traces, and the node data plugin draws them as a color-coded heatmap. Arm's overlay put the main latency bottleneck on a single TRANSPOSE node. Teams apply this to their own on-device models.