Extension updates

Author: matt-cossins

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/1-what-is-model-explorer.md

@@ -7,11 +7,11 @@ weight: 2
 layout: "learningpathall"
 ---
 
-## Model Explorer and Arm Adapters
+## Model Explorer and Arm extensions
 
 [Model Explorer](https://ai.google.dev/edge/model-explorer) is an open-source, web-based graph visualizer and debugger from Google AI Edge. It provides a hierarchical view of model graphs, lets you expand and collapse layers, search for nodes, inspect metadata, highlight inputs and outputs, compare models, and add overlays to graph nodes. The default version, [contained in this repository](https://github.com/google-ai-edge/model-explorer/) supports TFLite, TF, TFJS, MLIR, and PyTorch (Exported Program) formats.
 
-Model Explorer uses adapters and data providers to load formats beyond the built-in model types. The Arm adapters used in this Learning Path transform `.pte`, `.tosa`, `.vgf`, and `.etrecord` files into graph data that Model Explorer can display. In the final section, you also add `.etdp` runtime trace data as an overlay on top of the exported graph.
+Model Explorer uses adapters and data providers to load formats beyond the built-in model types. The [ExecuTorch extension for Model Explorer](https://github.com/arm/executorch-extension-model-explorer) combines support for `.pte`, `.etrecord`, and `.etdp` files. Standalone `.tosa` and `.vgf` files use separate TOSA and VGF adapters. You install all three packages together in the next section.
 
 ## What you will do
 
@@ -21,13 +21,13 @@ The artifacts covered in this learning path are:
 
 | Artifact | Model Explorer support | Workflow layer | Use it to inspect |
 | --- | --- | --- | --- |
-| `.pte` | `pte-adapter-model-explorer` | ExecuTorch program | Delegate regions, backend partitioning, work outside delegates, and the deployed ExecuTorch graph |
-| `.tosa` | `tosa-adapter-model-explorer` | Compiler/backend intermediate representation | Lowered operators, tensor shapes, quantized types, graph splits, and missed optimization opportunities |
-| `.vgf` | `vgf-adapter-model-explorer` | Vulkan ML graph artifact | Inputs, outputs, constants, tensor metadata, graph connectivity, and SPIR-V graph modules |
-| `.etrecord` | ExecuTorch ETRecord adapter | Export-time profiling context | Graph structure, debug handles, operator names, and delegate metadata used to map runtime events back to graph nodes |
-| `.etdp` | ExecuTorch ETDump data provider | Runtime trace overlay | Timing data from a specific execution |
+| `.pte` | PTE adapter in the ExecuTorch extension | ExecuTorch program | Delegate regions, backend partitioning, work outside delegates, and the deployed ExecuTorch graph |
+| `.tosa` | Separate TOSA adapter | Compiler/backend intermediate representation | Lowered operators, tensor shapes, quantized types, graph splits, and missed optimization opportunities |
+| `.vgf` | Separate VGF adapter | Vulkan ML graph artifact | Inputs, outputs, constants, tensor metadata, graph connectivity, and SPIR-V graph modules |
+| `.etrecord` | ETRecord adapter in the ExecuTorch extension | Export-time profiling context | Graph structure, debug handles, operator names, and delegate metadata used to map runtime events back to graph nodes |
+| `.etdp` | ETDump data provider in the ExecuTorch extension | Runtime trace overlay | Timing data from a specific execution |
 
-This learning path focusses on Arm adapters and extensions for Modle Explorer, but the repository of artifacts we use also includes some `.tflite` and `.pt2` files. You can optionally try these out as well, and they are natively supported by Model Explorer.
+This Learning Path focuses on Arm adapters and extensions for Model Explorer, but the artifacts repository also includes `.tflite` and `.pt2` files. You can optionally try these files because Model Explorer supports them without an additional adapter.
 
 {{% notice Note %}}
 Model Explorer visualizes the specific artifact you generated or received. Small differences in the target the model has been delegated to, could result in a very different model graph. For example, delegating the same model to an Ethos-U55, may produce a very different model graph from delegating to an Ethos-U85.
@@ -80,10 +80,10 @@ For VGF, the ExecuTorch Arm VGF backend uses the [Arm ML SDK Model Converter](ht
 
 When ExecuTorch is used for VGF, a `.pte` is emitted as well. Use that VGF-backend `.pte` when you want to run through ExecuTorch. Use the standalone `.vgf` when you want to inspect or integrate the Vulkan ML artifact directly, such as in a neural graphics workflow. 
 
-ETRecord and ETDump sit alongside these artifact views rather than replacing them. ETRecord is generated at export time and preserves the graph context needed for profiling attribution. ETDump is generated at runtime and records what actually happened when a `.pte` ran. Together, they let Model Explorer move from static inspection to runtime overlays: you can connect the graph structures you saw in the `.pte`, `.tosa`, and `.vgf` sections to operator and delegate events measured during execution.
-
 If you have used the [Arm Neural Graphics Model Gym](https://github.com/arm/neural-graphics-model-gym), then under the hood you have been using ExecuTorch to export your neural graphics model to VGF. If you are interested in learning more, try out the [Fine-tune neural graphics using Model Gym](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/model-training-gym/#:~:text=Upon%20completion%20of%20this%20Learning,and%20train%20neural%20graphics%20models) learning path, which briefly introduces Model Explorer.
 
+ETRecord and ETDump are additional, ExecuTorch-specific, artifacts. ETRecord is generated at export time and preserves the graph context needed for profiling attribution. ETDump is generated at runtime and records what actually happened when a `.pte` ran. Together, they let Model Explorer move from static inspection to runtime overlays: you can connect the graph structures you saw in the `.pte`, `.tosa`, and `.vgf` sections to operator and delegate events measured during execution.
+
 ## Terminology
 
 A helpful glossary of different terms is provided below:
@@ -112,24 +112,14 @@ The hands-on sections will use a variety of pre-provided model artifacts. These
 
 ```output
 ml-model-artifacts/
-├── README.md
-├── LICENSE.md
 ├── pte/
 │   ├── mv2_cortex_m.pte
 │   ├── opt125m_cortex_a_portable.pte
 │   ├── opt125m_cortex_a_xnnpack.pte
 │   ├── mv2_fp32_ethos_u85.pte
 │   ├── mv2_int8_ethos_u85.pte
 │   ├── mv2_lrn_int8_ethos_u85.pte
-│   ├── small_upscaler_ptq_vgf.pte
-│   ├── small_upscaler_qat_vgf.pte
-│   └── add_sigmoid_vgf.pte
-├── pt2/
-│   └── mv2_fp32.pt2
-├── tflite/
-│   ├── mv2_fp32.tflite
-│   ├── mv2_int8.tflite
-│   └── mv2_lrn_int8.tflite
+│   └── small_upscaler_ptq_vgf.pte
 ├── tosa/
 │   ├── mv2_fp32.tosa
 │   ├── mv2_int8.tosa
@@ -138,9 +128,7 @@ ml-model-artifacts/
 │   ├── small_upscaler_ptq.tosa
 │   └── small_upscaler_qat.tosa
 ├── vgf/
-│   ├── small_upscaler_ptq.vgf
-│   ├── small_upscaler_qat.vgf
-│   └── add_sigmoid.vgf
+│   └── small_upscaler_ptq.vgf
 ├── etrecord/
 │   ├── opt125m_portable.etrecord
 │   ├── opt125m_xnnpack.etrecord
@@ -157,6 +145,6 @@ ml-model-artifacts/
 
 ## What you have learned
 
-You have learned how Model Explorer uses adapters and data providers to load artifact formats beyond its built-in model types. You have also seen how `.pte`, `.tosa`, `.vgf`, `.etrecord`, and `.etdp` files fit into Cortex-A, Cortex-M, Ethos-U, Vulkan ML, and ExecuTorch profiling workflows. The artifacts repository also includes `.pt2` and `.tflite` files that you can inspect directly as optional extensions.
+You have learned how the combined ExecuTorch extension and the separate TOSA and VGF adapters add artifact formats to Model Explorer. You have also seen how `.pte`, `.tosa`, `.vgf`, `.etrecord`, and `.etdp` files fit into Cortex-A, Cortex-M, Ethos-U, Vulkan ML, and ExecuTorch profiling workflows.
 
-Next, you will install Model Explorer, launch it with the Arm adapters, and open the first `.pte` artifact.
+Next, you will install Model Explorer and the Arm extensions, then open the first `.pte` artifact.

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/2-install-and-open-pte.md

@@ -1,5 +1,5 @@
 ---
-title: "Install Model Explorer and the adapters, and view a Cortex-M model graph"
+title: "Install Model Explorer extensions and view a Cortex-M model graph"
 
 weight: 3
 
@@ -9,11 +9,29 @@ layout: "learningpathall"
 
 ## Clone the repo of example models
 
-In this section, you install Model Explorer in a clean Python virtual environment, along with the Arm adapters, and confirm it is working using the PTE adapter. First you will clone the repo of example models to use across the course of this learning path.
+In this section, you install Model Explorer and the Arm extensions in a clean Python virtual environment. You then confirm the installation by opening a Cortex-M `.pte` file. First, clone the repository of example models used throughout this Learning Path.
 
 Use a machine capable of displaying a browser e.g, a laptop.
 
-This repository uses Git LFS for model artifacts. After cloning, run `git lfs pull` to download the files.
+This repository uses Git LFS for model artifacts. Install and configure Git LFS for your operating system. You only need to run `git lfs install` once for your user account.
+
+{{< tabpane code=true >}}
+  {{< tab header="Linux" language="bash">}}
+sudo apt update
+sudo apt install -y git-lfs
+git lfs install
+  {{< /tab >}}
+  {{< tab header="macOS" language="bash">}}
+brew install git-lfs
+git lfs install
+  {{< /tab >}}
+  {{< tab header="Windows PowerShell" language="powershell">}}
+winget install -e --id GitHub.GitLFS
+git lfs install
+  {{< /tab >}}
+{{< /tabpane >}}
+
+Clone the artifacts repository, then use `git lfs pull` to download the model files:
 
 ```bash
 git clone https://github.com/arm-education/ml-model-artifacts.git
@@ -25,6 +43,8 @@ git lfs pull
 
 Use a separate environment to avoid dependency conflicts with any ExecuTorch build, notebook, or application environment you already use:
 
+Use Python 3.10, 3.11, or 3.12 for this environment.
+
 If you use WSL on Windows, follow the Linux/macOS commands.
 
 {{< tabpane code=true >}}
@@ -48,53 +68,32 @@ Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
 ```
 {{% /notice %}}
 
-## Install Model Explorer
+## Install Model Explorer and the Arm extensions
 
-Install Model Explorer and PyTorch in the active virtual environment.
-
-The Linux command pins PyTorch to the CPU wheel index because this Learning Path does not need CUDA. On macOS and Windows, the standard PyPI install is usually sufficient.
-
-{{< tabpane code=true >}}
-  {{< tab header="Linux" language="bash">}}
-pip install torch --index-url https://download.pytorch.org/whl/cpu
-pip install ai-edge-model-explorer
-  {{< /tab >}}
-  {{< tab header="macOS" language="bash">}}
-pip install torch ai-edge-model-explorer
-  {{< /tab >}}
-  {{< tab header="Windows PowerShell" language="powershell">}}
-pip install torch ai-edge-model-explorer
-  {{< /tab >}}
-{{< /tabpane >}}
+Install the combined ExecuTorch extension with the separate TOSA and VGF adapters:
 
-## Install the Arm adapters
+```bash
+python -m pip install executorch-extension-model-explorer tosa-adapter-model-explorer vgf-adapter-model-explorer
+```
 
-{{% notice TODO before release %}}
-Update this installation section after the ExecuTorch Model Explorer extension is released.
+The ExecuTorch extension provides the PTE adapter, ETRecord adapter, and ETDump profiling data provider. The separate TOSA and VGF adapters open standalone `.tosa` and `.vgf` files.
 
-The intended install flow is to install the PTE, ETRecord, and ETDump adapters/data provider as one ExecuTorch extension, then launch Model Explorer with that ExecuTorch extension alongside the TOSA and VGF adapters. Until that package is available, keep the ETRecord and ETDump install and launch instructions under review.
+{{% notice Note %}}
+For component development or focused debugging, you can install the ExecuTorch components separately as `pte-adapter-model-explorer`, `etrecord-adapter-model-explorer`, and `etdump-data-provider-model-explorer`. For this Learning Path, use the combined `executorch-extension-model-explorer` package.
 {{% /notice %}}
 
-Install the PTE, TOSA, and VGF adapters used for the static artifact sections:
-
-```bash
-pip install pte-adapter-model-explorer
-pip install tosa-adapter-model-explorer
-pip install vgf-adapter-model-explorer
-```
-
 ## Launch Model Explorer
 
-Launch Model Explorer with the Arm adapters. This is the recommended route for the static artifact sections because you will open `.pte`, `.tosa`, and `.vgf` artifacts. Also shown are examples of running the base model explorer without adapters, and running with a single adapter.
+Launch Model Explorer with all extensions used in this Learning Path. The combined ExecuTorch extension opens `.pte` and `.etrecord` files and adds `.etdp` profiling data. The separate TOSA and VGF extensions open `.tosa` and `.vgf` files.
 
 This will launch a webpage in your browser.
 
 {{< tabpane code=true >}}
-  {{< tab header="All adapters" language="bash">}}
-model-explorer --extensions=pte_adapter_model_explorer,tosa_adapter_model_explorer,vgf_adapter_model_explorer
+  {{< tab header="All Learning Path extensions" language="bash">}}
+model-explorer --extensions=executorch_extension_model_explorer,tosa_adapter_model_explorer,vgf_adapter_model_explorer
   {{< /tab >}}
-  {{< tab header="PTE adapter" language="bash">}}
-model-explorer --extensions=pte_adapter_model_explorer
+  {{< tab header="ExecuTorch extension" language="bash">}}
+model-explorer --extensions=executorch_extension_model_explorer
   {{< /tab >}}
   {{< tab header="No adapters" language="bash">}}
 model-explorer
@@ -162,6 +161,6 @@ Click the `eye symbol` in the top left bar to select data to view on nodes and e
 
 ## What you have learned
 
-You have installed Model Explorer, launched it with the Arm adapters, and opened your first `.pte` artifact. You have also learned how to inspect the graph overview, expand into the `forward` layer, read operator metadata, and interpret common low-level `.pte` fields such as `KernelCall`, `op_index`, and `args`.
+You have installed Model Explorer, launched it with the Arm extensions, and opened your first `.pte` artifact. You have also learned how to inspect the graph overview, expand into the `forward` layer, read operator metadata, and interpret common low-level `.pte` fields such as `KernelCall`, `op_index`, and `args`.
 
 Next, you will keep the same browser tab open and compare portable and XNNPACK `.pte` artifacts to see how backend delegation changes the graph.

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/4-inspect-ethosu-pte.md

@@ -89,7 +89,7 @@ Look for:
 - Multiple delegate regions
 - Operators between delegate regions
 - Unsupported operations or graph patterns outside the NPU delegate
-- Extra tensor movement around backend boundaries
+- Quantize, dequantize, or non-delegated operators between delegate regions
 
 ![Screenshot of examining a fragmented INT8 Ethos-U PTE in Model Explorer.#center](ethos-u-int8-fragmented.png "Inspecting fragmented INT8 Ethos-U PTE with Model Explorer")
 
@@ -104,7 +104,7 @@ In Model Explorer, compare it with the clean delegated artifact:
 - You should see quantize and dequantize nodes around the delegated regions.
 - You should see an `aten::avg_pool3d` node between the delegate regions. This is visible non-delegated work that breaks the otherwise contiguous NPU path.
 
-This is what fragmentation looks like in a `.pte`: the NPU still accelerates supported regions, but unsupported work splits the graph and creates extra delegate boundaries. In a deployed runtime, non-delegated work can run on the CPU only if the runtime includes compatible kernels for those operators, dtypes, layouts, and shapes. Cortex-M bare-metal runtimes often include a narrower kernel set than Cortex-A runtimes, and both can use selective builds that include only the kernels required by the product.
+This is what fragmentation looks like in a `.pte`: the NPU still accelerates supported regions, but unsupported work splits the graph and creates extra delegate boundaries. Additional boundaries can introduce data conversion, synchronization, or tensor movement. Non-delegated operators can also dominate runtime, or fail to run if the deployed runtime does not include compatible kernels for their operators, data types, layouts, and shapes. The static graph shows where delegation splits, but it does not show which cost dominates.
 
 ## Compare targets only with target-specific artifacts
 

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/6-inspect-tosa.md

@@ -96,6 +96,8 @@ The second LRN TOSA file is the larger fragment. It starts from the original ima
 
 The graph fragmentation has become visible as multiple backend-ready TOSA artifacts. That matches the fragmented `.pte` view, where two `EthosUBackend` delegate regions were separated by non-delegated work.
 
+The two TOSA files show where the backend-supported graph was split. They do not measure the cost of that split or confirm that the non-delegated operators can run in the deployed runtime. Runtime profiling is needed to identify whether boundary-related work or non-delegated operators dominate execution.
+
 ## Use TOSA outside ExecuTorch
 
 TOSA is not limited to ExecuTorch. ExecuTorch can lower supported graph partitions to TOSA, but a different framework, internal compiler, or proprietary model frontend could also produce TOSA directly.