another pass of edits

Author: anupras-mohapatra-arm

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

@@ -10,7 +10,7 @@ layout: "learningpathall"
 
 ## 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. The visualizer provides a hierarchical view of model graphs. You can 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 the Model Explorer GitHub repository](https://github.com/google-ai-edge/model-explorer/) supports TFLite, TF, TFJS, MLIR, and PyTorch (Exported Program) formats.
+[Model Explorer](https://ai.google.dev/edge/model-explorer) is an open-source, web-based graph visualizer and debugger from Google AI Edge. The visualizer provides a hierarchical view of model graphs. You can 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 the Model Explorer GitHub 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 [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 Tensor Operator Set Architecture (TOSA) and VGF adapters. You'll install all three packages together in the next section.
 
@@ -77,15 +77,15 @@ TOSA is not inherently ExecuTorch-specific. TOSA is an intermediate representati
                                                for workflows using the ML extensions for Vulkan
 ```
 
-For VGF, the ExecuTorch Arm VGF backend uses the [Arm ML SDK Model Converter](https://github.com/arm/ai-ml-sdk-model-converter) to produce a VGF backend payload from TOSA. But the Arm ML SDK Model Converter can be used to convert `.tosa` files generated from a different flow, so VGF is also not specific to just ExecuTorch.
+For VGF, the ExecuTorch Arm VGF backend uses the [Arm ML SDK Model Converter](https://github.com/arm/ai-ml-sdk-model-converter) to produce a VGF backend payload from TOSA. But the Arm ML SDK Model Converter can be used to convert `.tosa` files generated from a different flow, so VGF is also not specific to ExecuTorch.
 
 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 VGF artifact used with the ML extensions for Vulkan, such as in a neural graphics workflow.
 
 If you've used the [Arm Neural Graphics Model Gym](https://github.com/arm/neural-graphics-model-gym), then you've been using ExecuTorch to export your neural graphics model to VGF. To learn more, see 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 happened when a `.pte` ran. Together, they let Model Explorer move from static inspection to runtime overlays. 
+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 happened when a `.pte` ran. Together, these artifacts 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.
+You can connect the graph structures that you'll see in the `.pte`, `.tosa`, and `.vgf` sections to operator and delegate events measured during execution.
 
 ## Terminology
 
@@ -104,14 +104,14 @@ The following is a glossary of different terms used 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. |
-| SPIR-V | Standard Portable Intermediate Representation - Vulkan. SPIR-V modules inside VGF files describe the data graph used by the ML extensions for Vulkan. |
+| Flatbuffer | A compact binary serialization format. TOSA flatbuffers store TOSA graphs, and `.pte` files use a FlatBuffer-based ExecuTorch program format. |
+| SPIR-V | Standard Portable Intermediate Representation - Vulkan (SPIR-V) modules inside VGF files describe the data graph used by the ML extensions for Vulkan. |
 | ETRecord | An ExecuTorch export-time debug artifact that preserves graph and delegate metadata for profiling attribution. |
 | ETDump | An ExecuTorch runtime trace artifact that can record operator, delegate, backend, timing, and cycle-count events from execution. The first Model Explorer overlay used in this Learning Path focuses on timing data. |
 
 ## What models you will use
 
-The hands-on sections will use a variety of pre-provided model artifacts. These are provided purely for educational purposes.
+You'll use the following pre-provided model artifacts provided purely for educational purposes:
 
 ```output
 ml-model-artifacts/
@@ -146,8 +146,8 @@ ml-model-artifacts/
     └── mobilenetv2_lrn_int8_ethosu.etdp
 ```
 
-## What you have learned
+## What you've learned and what's next
 
 You've now learned how the combined ExecuTorch extension and the separate TOSA and VGF adapters add artifact formats to Model Explorer. You've also seen how `.pte`, `.tosa`, `.vgf`, `.etrecord`, and `.etdp` files support Cortex-A, Cortex-M, Ethos-U, the ML extensions for Vulkan, and ExecuTorch profiling workflows.
 
-Next, you'll install Model Explorer and the Arm extensions, then open the first `.pte` artifact.
+Next, you'll install Model Explorer and the Arm extensions.

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

@@ -0,0 +1,93 @@
+---
+title: Install Model Explorer and the Arm extensions
+description: Download pre-generated model artifacts and install Model Explorer with Arm extensions in a Python virtual environment.
+
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: "learningpathall"
+---
+
+## Clone the repository of example models
+
+You'll download the example model artifacts and install Model Explorer with the Arm extensions in a clean Python virtual environment. In the next section, you'll confirm the installation by opening a Cortex-M `.pte` file.
+
+First, clone the repository of example models that you'll use.
+
+Use a machine capable of displaying a browser. For example, a laptop.
+
+The repository uses Git Large File Storage (LFS) for model artifacts. Install and configure Git LFS for your operating system:
+
+{{% notice Note %}}
+- If you use WSL on Windows, follow the Linux commands. 
+- You need to run `git lfs install` only once for your user account.
+{{% /notice %}}
+
+{{< 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
+cd ml-model-artifacts
+git lfs pull
+```
+
+## Create a virtual environment
+
+Use a separate Python 3.10, 3.11, or 3.12 environment to avoid dependency conflicts with any ExecuTorch build, notebook, or application environment that you already use:
+
+{{< tabpane code=true >}}
+  {{< tab header="Linux or macOS" language="bash">}}
+python3 -m venv model_explorer_env
+source model_explorer_env/bin/activate
+python -m pip install --upgrade pip
+  {{< /tab >}}
+  {{< tab header="Windows PowerShell" language="powershell">}}
+py -m venv model_explorer_env
+.\model_explorer_env\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+  {{< /tab >}}
+{{< /tabpane >}}
+
+{{% notice Note %}}
+If Windows PowerShell blocks `Activate.ps1`, allow local activation scripts for your user account:
+
+```powershell
+Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+```
+{{% /notice %}}
+
+## Install Arm extensions with TOSA and VGF adapters
+
+Install the combined ExecuTorch extension with the separate Tensor Operator Set Architecture (TOSA) and VGF adapters:
+
+```bash
+python -m pip install executorch-extension-model-explorer tosa-adapter-model-explorer vgf-adapter-model-explorer
+```
+
+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.
+
+{{% notice Note %}}
+For component development or focused debugging, 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 %}}
+
+## What you've accomplished and what's next
+
+You've downloaded the example model artifacts, created a Python virtual environment, and installed Model Explorer with the combined ExecuTorch extension and separate TOSA and VGF adapters.
+
+Next, you'll launch Model Explorer and confirm the installation by opening and inspecting a Cortex-M `.pte` artifact.