style edits

Author: anupras-mohapatra-arm

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

@@ -16,7 +16,7 @@ Model Explorer uses adapters and data providers to load formats beyond the built
 
 ## What you will do
 
-This Learning Path is about model artifacts, not model training or export. You'll start from small pre-generated files and use each to gain an understanding of when you'd use Model Explorer, and what insights you can gain.
+This Learning Path is about model artifacts, not model training or export. You'll start from small pre-generated files and use each to understand when you'd use Model Explorer, and what insights you can gain.
 
 You'll use the following artifacts:
 
@@ -28,7 +28,7 @@ You'll use the following artifacts:
 | `.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 |
 
-You'll 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.
+You'll focus 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 can result in a very different model graph. For example, delegating the same model to an Ethos-U55, might produce a very different model graph from delegating to an Ethos-U85.
@@ -101,7 +101,7 @@ The following is a glossary of different terms used in this Learning Path:
 | Compiler | A tool that transforms an intermediate representation into a lower-level target representation, such as Vela compiling TOSA for Ethos-U. |
 | Lower | To transform a model or graph from a higher-level representation into a lower-level representation closer to a target backend. |
 | Convert | To change one artifact format into another, such as TOSA to VGF. |
-| Intermediate representation | A representation between the original model and the final target artifact. TOSA is the main intermediate representation in this learning path. |
+| Intermediate representation | A representation between the original model and the final target artifact. TOSA is the main intermediate representation in this Learning Path. |
 | Delegate | A backend-specific execution path that handles supported parts of a graph. Unsupported parts can remain outside the delegate, and can run on a CPU path only when the deployed runtime includes compatible kernels. |
 | Kernel | The code that executes a model operator for a specific runtime or backend, such as a portable ExecuTorch kernel or a CMSIS-NN kernel. |
 | Flatbuffer | A compact binary serialization format. TOSA flatbuffers store TOSA graphs; `.pte` files use a FlatBuffer-based ExecuTorch program format. |

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

@@ -103,7 +103,7 @@ model-explorer
   {{< /tab >}}
 {{< /tabpane >}}
 
-Use `CTRL + C` to stop Model Explorer.
+Press `Ctrl+C` to stop Model Explorer.
 
 {{% notice Note %}}
 If you're interested in a specific model format or a particular target, skip to the appropriate section.
@@ -121,19 +121,19 @@ CMSIS-NN exists to make common ML operations such as convolutions, fully connect
 The Cortex-M backend is a work-in-progress proof of concept. It's not intended for production use, and APIs might change without notice. However, the `.pte` is pre-generated for you in the provided repository. To learn more about the Cortex-M backend, see the [Cortex-M Backend Documentation](https://docs.pytorch.org/executorch/1.2/backends/arm-cortex-m/arm-cortex-m-overview.html), which also links to a Jupyter Notebook.
 {{% /notice %}}
 
-In the Model Explorer UI, open `ml-model-artifacts/pte/mv2_cortex_m.pte`.
+In Model Explorer, open `ml-model-artifacts/pte/mv2_cortex_m.pte`.
 
 Your view in the browser should appear as follows:
 
 ![Screenshot of Model Explorer with Arm Adapters and a loaded Cortex-M PTE.#center](model_explorer.png "Model Explorer with Arm Adapters")
 
-Select `View selected models`, and your view should appear as follows:
+Select **View selected models**, and your view should appear as follows:
 
 ![Screenshot of top-level view in Model Explorer of a loaded Cortex-M PTE.#center](cortex_m_top.png "Typical top-level graph view in Model Explorer")
 
-A right-hand bar tells you the graph info, including the `op node count` and the `layer count`. The `op node count` is the number of operator nodes in the graph. The `layer count` is the number of hierarchical graph components represented in the current view, not necessarily the number of neural network layers in the original model.
+The graph information panel shows the **op node count** and **layer count**. The **op node count** is the number of operator nodes in the graph. The **layer count** is the number of hierarchical graph components represented in the current view, not necessarily the number of neural network layers in the original model.
 
-Double click the `forward` layer to see the various operators comprising the layer. Click a specific operator — for example, `cortex_m::quantize_per_tensor` — to see various attributes, as well as inputs and outputs, in the right-hand bar.
+Expand the `forward` layer to view its operators. Select an operator, such as `cortex_m::quantize_per_tensor`, to see its attributes, inputs, and outputs in the node information panel.
 
 ![Screenshot of examining a specific Cortex-M operator in Model Explorer.#center](cortex_m_inspect.png "Inspecting specific operators with Model Explorer")
 
@@ -156,7 +156,7 @@ You might also see lower-level `.pte` execution fields in the node attributes. T
 
 You don't need to memorize these internal fields. Use the fields as clues when you want to connect a visible graph node to the underlying ExecuTorch program structure.
 
-Select the `eye symbol` in the top left bar to select data to view on nodes and edges. Choose the data you want to see - for example, `op node id` and `op node attributes` — to include more data within the graph itself.
+Select the eye icon in the toolbar to open the **View on nodes** panel. Select the data you want to display, such as **Op node id** and **Op node attributes**, to show more information in the graph.
 
 ## What you've accomplished and what's next
 

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/3-compare-portable-xnnpack-pte.md

@@ -1,5 +1,5 @@
 ---
-title: Compare portable and XNNPACK PTE files on Model Explorer
+title: Compare portable and XNNPACK PTE files with Model Explorer
 description: Compare portable-kernel and XNNPACK PTE files in Model Explorer to identify delegated regions and work that remains on the default Cortex-A CPU path.
 
 weight: 4
@@ -20,7 +20,7 @@ Portable kernels aren't usually the fastest CPU path. The kernels prioritize bro
 
 On Arm CPUs, XNNPACK can use Arm KleidiAI micro-kernels. [KleidiAI](https://developer.arm.com/dev2/ai/kleidi-libraries) is Arm's open-source library of optimized low-level AI routines for Arm CPUs. It provides architecture-tuned compute kernels for operations such as matrix multiplication, using Arm features such as Neon, SVE2, and SME2 where supported. You do not call KleidiAI directly in this workflow; ExecuTorch delegates to XNNPACK, and XNNPACK can use KleidiAI-optimized kernels internally when the operator, data type, and hardware are supported.
 
-If you are interested in understanding how SME2 can accelerate performance of ExecuTorch models, take a look at [Profile ExecuTorch models with SME2 on Arm](https://learn.arm.com/learning-paths/cross-platform/sme-executorch-profiling/).
+If you are interested in understanding how SME2 can accelerate performance of ExecuTorch models, see the [Profile ExecuTorch models with SME2 on Arm](https://learn.arm.com/learning-paths/cross-platform/sme-executorch-profiling/) Learning Path.
 
 To summarize the different CPU paths:
 
@@ -32,7 +32,7 @@ To summarize the different CPU paths:
 
 ## Compare CPU deployment artifacts
 
-You'll compare two `.pte` files generated from the same Open Pre-trained Transformer (OPT)model: [`facebook/opt-125m`](https://huggingface.co/facebook/opt-125m).
+You'll compare two `.pte` files generated from the same Open Pre-trained Transformer (OPT) model: [`facebook/opt-125m`](https://huggingface.co/facebook/opt-125m).
 
 OPT-125M is a 125-million-parameter, decoder-only transformer language model from Meta. The model is a small member of the OPT family, which makes it useful for demonstrations. OPT-125M is large enough to contain transformer operations such as embeddings, attention, linear layers, matrix multiplication, reshapes, and masking, but small enough to inspect and run on edge-class Arm systems.
 

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

@@ -1,5 +1,5 @@
 ---
-title: Inspect Ethos-U PTE delegation on Model Explorer
+title: Inspect Ethos-U PTE delegation with Model Explorer
 description: Inspect FP32 and INT8 Ethos-U PTE files in Model Explorer to identify clean, missing, and fragmented NPU delegation.
 
 weight: 5
@@ -16,12 +16,12 @@ Model Explorer is useful because the final `.pte` shows whether the ExecuTorch p
 
 Ethos-U execution is heterogeneous: supported subgraphs are delegated to the NPU, while unsupported operators remain outside the NPU delegate. Whether that remaining work can execute on the CPU depends on the kernels included in the deployed ExecuTorch runtime. 
 
-The PyTorch blog [Efficient Edge AI on Arm CPUs and NPUs](https://pytorch.org/blog/efficient-edge-ai-on-arm-cpus-and-npus/) describes this flow as the following:
+The PyTorch blog [Efficient Edge AI on Arm CPUs and NPUs](https://pytorch.org/blog/efficient-edge-ai-on-arm-cpus-and-npus/) describes the following steps:
 
 - Quantizing the model
 - Lowering supported regions to Tensor Operator Set Architecture (TOSA)
 - Running Vela to produce an optimized Ethos-U command stream
-- Packaging the result into the final `.pte`. 
+- Packaging the result into the final `.pte`
 
 You'll inspect three MobileNetV2 artifacts in order: FP32 with no NPU delegation, INT8 with clean delegation, and INT8 with fragmented delegation.
 
@@ -56,7 +56,7 @@ Now you'll use the same MobileNetV2 model, but quantized with the `EthosUQuantiz
 
 Open `ml-model-artifacts/pte/mv2_int8_ethos_u85.pte`.
 
-Inspect the graph and look for the followiing:
+Inspect the graph and look for the following:
 
 - Whether there's an Ethos-U delegate region
 - Whether the NPU region is one large block or several smaller blocks
@@ -117,7 +117,7 @@ For example, an Ethos-U85 artifact doesn't provide full insight into Ethos-U55 b
 ## (Optional) Visualize TFLite and PT2 files
 
 <details>
-<summary>Click to reveal</summary>
+<summary>Show optional artifacts</summary>
 
 The artifacts repository also includes MobileNetV2 `.pt2` and `.tflite` files:
 ```output

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

@@ -1,5 +1,5 @@
 ---
-title: Inspect TOSA artifacts using Model Explorer
+title: Inspect TOSA artifacts with Model Explorer
 description: Inspect TOSA graphs in Model Explorer to compare operators, tensor metadata, quantization, and graph fragmentation before backend compilation or conversion.
 
 weight: 6
@@ -12,7 +12,7 @@ layout: "learningpathall"
 
 Tensor Operator Set Architecture (TOSA) is a stable operator-level intermediate representation (IR) used between model export and backend-specific compilation or conversion.
 
-Ethos-U `.pte` files files show the final ExecuTorch program after supported regions have been delegated or left outside the NPU delegate. With TOSA, you can inspect an earlier stage: the graph representation that backend tools such as Vela or the Arm ML SDK Model Converter can consume.
+Ethos-U `.pte` files show the final ExecuTorch program after supported regions have been delegated or left outside the NPU delegate. With TOSA, you can inspect an earlier stage: the graph representation that backend tools such as Vela or the Arm ML SDK Model Converter can consume.
 
 You don't need separate TOSA artifacts for the Cortex-A portable, Cortex-A XNNPACK, or Cortex-M examples. Those routes don't need a TOSA intermediate representation: portable kernels stay in the ExecuTorch operator path, XNNPACK uses an ExecuTorch delegate for Cortex-A CPU acceleration, and Cortex-M uses its own Cortex-M/CMSIS-NN-oriented lowering path. TOSA becomes relevant for the backend routes that consume TOSA, such as Ethos-U and VGF.
 
@@ -35,7 +35,7 @@ Open the FP32 TOSA artifact `ml-model-artifacts/tosa/mv2_fp32.tosa`.
 Inspect the graph and look for the following:
 
 - Whether the input is in the right shape `[1, 3, 224, 224]`
-- Whether the output shape is `[1, 1000]`?
+- Whether the output shape is `[1, 1000]`
 - Whether the tensor types are FP32
 - What convolution, add, clamp, and pooling patterns are visible
 

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/7-inspect-vgf.md

@@ -1,5 +1,5 @@
 ---
-title: Inspect VGF artifacts using Model Explorer
+title: Inspect VGF artifacts with Model Explorer
 description: Compare VGF-backend PTE and standalone VGF artifacts in Model Explorer to understand ExecuTorch packaging and Vulkan backend graph structure.
 
 weight: 7
@@ -12,7 +12,7 @@ layout: "learningpathall"
 
 VGF is the artifact used by Arm ML SDK for Vulkan workflows. It's useful in workflows using the ML extensions for Vulkan, and in neural graphics applications where you need to inspect the graph consumed by the Vulkan runtime.
 
-In the previous section, you inspected the TOSA artifacts for a small neural upscaling model, obtained from the [Quantize neural upscaling models with ExecuTorch](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/quantize-neural-upscaling-models/) learning path. You'll now inspect the VGF and PTE artifacts produced from that flow.
+In the previous section, you inspected the TOSA artifacts for a small neural upscaling model, obtained from the [Quantize neural upscaling models with ExecuTorch](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/quantize-neural-upscaling-models/) Learning Path. You'll now inspect the VGF and PTE artifacts produced from that flow.
 
 Although that flow uses ExecuTorch and generates `.pte` files as well, VGF isn't ExecuTorch-specific. If you have a `.tosa` file obtained from another flow, you can convert it to `.vgf` using the Arm ML SDK Model Converter.
 
@@ -35,7 +35,7 @@ Inspect the graph and look for the following:
 
 - Whether there's a `VgfBackend` delegate node
 - The work that happens before and after the backend call
-- Whether the top-level graph show the internal upscaler operators
+- Whether the top-level graph shows the internal upscaler operators
 - What this view tells you about the ExecuTorch runtime path
 
 ![Screenshot of examining a VGF-backed PTE in Model Explorer.#center](ptq_vgf_pte.png "Inspecting a VGF-backed PTE with Model Explorer")
@@ -50,7 +50,7 @@ Expand the `VgfBackend` delegate graph:
 
 Now, open the matched standalone VGF artifact `ml-model-artifacts/vgf/small_upscaler_ptq.vgf`.
 
-You'll see they show the same view.
+The VGF artifact shows the same view as the `VgfBackend` delegate graph.
 
 Inspect the graph and look for the following:
 

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/8-etrecord-etdump-overlays.md

@@ -1,5 +1,5 @@
 ---
-title: Inspect ETRecord and ETDump overlays using Model Explorer
+title: Inspect ETRecord and ETDump overlays with Model Explorer
 description: Overlay ETRecord and ETDump profiling data in Model Explorer to connect ExecuTorch graph nodes and delegate regions with runtime timing.
 
 weight: 8
@@ -10,7 +10,7 @@ layout: "learningpathall"
 
 ## View ExecuTorch runtime profiling data
 
-You've inspected static artifacts. PTE, TOSA, and VGF views to learn what was exported, lowered, compiled, converted, or packaged.
+PTE, TOSA, and VGF views help you learn what was exported, lowered, compiled, converted, or packaged.
 
 Runtime profiling answers a different set of questions. With runtime profiling, you can learn what happened when the artifact ran on a specific runtime, runner, target hardware, and tracing configuration.
 

content/learning-paths/cross-platform/explore-model-artifacts-with-model-explorer/_index.md

@@ -1,5 +1,5 @@
 ---
-title: Visualize ExecuTorch, TOSA, and VGF artifacts with Google Model Explorer and Arm Extensions
+title: Visualize ExecuTorch, TOSA, and VGF artifacts with Google Model Explorer and Arm extensions
 
 description: Inspect ExecuTorch PTE, TOSA, VGF, ETRecord, and ETDump model artifacts with Google Model Explorer and Arm extensions.