Editing Ethos-U learning path

Author: armwaheed

…/visualizing-tinyml-on-arm/1-overview.md …lizing-ethos-u-performance/1-overview.mdcontent/learning-paths/embedded-and-microcontrollers/visualizing-tinyml-on-arm/1-overview.md renamed to content/learning-paths/embedded-and-microcontrollers/visualizing-ethos-u-performance/1-overview.md content/learning-paths/embedded-and-microcontrollers/visualizing-tinyml-on-arm/1-overview.md renamed to content/learning-paths/embedded-and-microcontrollers/visualizing-ethos-u-performance/1-overview.md

@@ -1,25 +1,27 @@
 ---
 # User change
-title: "Set up the Corstone-320 FVP on macOS"
+title: "Set up the Corstone-320 FVP on Linux"
 
-weight: 5 # 1 is first, 2 is second, etc.
+weight: 4 # 1 is first, 2 is second, etc.
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
 
-## macOS Prerequisits
-
-Setting up FVPs on MacOS requires some extra steps, outlined in GitHub repo [VPs-on-Mac](https://github.com/Arm-Examples/FVPs-on-Mac/). macOS users must do this first, before setting up the Corestone-320 FVP.
-
-## Set up the Corestone-320 FVP
+In this section, you will run scripts to set up the Corstone-320 reference package.
 
 The Corstone-320 Fixed Virtual Platform (FVP) is a pre-silicon software development environment for Arm-based microcontrollers. It provides a virtual representation of hardware, allowing developers to test and optimize software before actual hardware is available. Designed for AI and machine learning workloads, it includes support for Arm's Ethos-U NPU and Cortex-M processors, making it ideal for embedded AI applications. The FVP accelerates development by enabling early software validation and performance tuning in a flexible, simulation-based environment.
 
 The Corstone reference system is provided free of charge, although you will have to accept the license in the next step. For more information on Corstone-320, check out the [official documentation](https://developer.arm.com/documentation/109761/0000?lang=en).
 
 ## Corstone-320 FVP Setup for ExecuTorch
 
+{{% notice macOS %}}
+
+Setting up FVPs on MacOS requires some extra steps, outlined in GitHub repo [VPs-on-Mac](https://github.com/Arm-Examples/FVPs-on-Mac/). macOS users must do this first, before setting up the Corestone-320 FVP.
+
+{{% /notice %}}
+
 Navigate to the Arm examples directory in the ExecuTorch repository. Run the following command.
 
 ```bash
@@ -35,6 +37,12 @@ source $HOME/executorch/examples/arm/ethos-u-scratch/setup_path.sh
 
 Test that the setup was successful by running the `run.sh` script for Ethos-U85, which is the target device for Corstone-320:
 
+{{% notice macOS %}}
+
+**Start Docker:** on macOS, FVPs run inside a Docker container.
+
+{{% /notice %}}
+
 ```bash
  ./examples/arm/run.sh --target=ethos-u85-256
 ```

…visualizing-tinyml-on-arm/2-env-setup.md …izing-ethos-u-performance/2-env-setup.mdcontent/learning-paths/embedded-and-microcontrollers/visualizing-tinyml-on-arm/2-env-setup.md renamed to content/learning-paths/embedded-and-microcontrollers/visualizing-ethos-u-performance/2-env-setup.md content/learning-paths/embedded-and-microcontrollers/visualizing-tinyml-on-arm/2-env-setup.md renamed to content/learning-paths/embedded-and-microcontrollers/visualizing-ethos-u-performance/2-env-setup.md

@@ -0,0 +1,57 @@
+---
+# User change
+title: "How ExecuTorch Works"
+
+weight: 5 # 1 is first, 2 is second, etc.
+
+# Do not modify these elements
+layout: "learningpathall"
+---
+
+Source: [How ExecuTorch Works](https://docs.pytorch.org/executorch/stable/intro-how-it-works.html) (official PyTorch Documentation)
+1. **Export the model:**
+   * Generate a Graph
+   * A graph is series of operators (ReLU, quantize, etc.) eligible for delegation to an accelerator
+   * Your goal is to identify operators for acceleration on the Ethos-U NPU
+2. **Compile to ExecuTorch:**
+   * This is the ahead-of-time compiler
+   * This is why ExecuTorch inference is faster than PyTorch inference
+   * Delegate operators to an accelerator, like the Ethos-U NPU
+3. **Run on targeted device:**
+   * Deploy the ML model to the Fixed Virtual Platform (FVP) or physical device
+   * Execute operators on the CPU and delegated operators on the Ethos-U NPU
+
+**Diagram of How ExecuTorch Works**
+![How ExecuTorch works](./how-executorch-works-high-level.png)
+
+## Deploy a TinyML Model
+
+With your development environment set up, you can deploy a simple PyTorch model.
+
+This example deploys the [MobileNet V2](https://pytorch.org/hub/pytorch_vision_mobilenet_v2/) computer vision model. The model is a convolutional neural network (CNN) that extracts visual features from an image. It is used for image classification and object detection.
+
+The actual Python code for the MobileNet V2 model is in your local `executorch` repo: [executorch/examples/models/mobilenet_v2/model.py](https://github.com/pytorch/executorch/blob/main/examples/models/mobilenet_v2/model.py). You can deploy it using [run.sh](https://github.com/pytorch/executorch/blob/main/examples/arm/run.sh), just like you did in the previous step, with some extra parameters:
+
+{{% notice macOS %}}
+
+**Start Docker:** on macOS, FVPs run inside a Docker container.
+
+{{% /notice %}}
+
+```bash
+./examples/arm/run.sh \
+--aot_arm_compiler_flags="--delegate --quantize --intermediates mv2_u85/ --debug --evaluate" \
+--output=mv2_u85 \
+--target=ethos-u85-128 \
+--model_name=mv2
+```
+
+**Explanation of run.sh Parameters**
+|run.sh Parameter|Meaning / Context|
+|--------------|-----------------|
+|--aot_arm_compiler_flags|Passes a string of compiler options to the ExecuTorch Ahead-of-Time (AOT) compiler|
+|--delegate|Enables backend delegation|
+|--quantize|Converts the floating-point model to int8 quantized format using post-training quantization<br>**Essential for running on NPUs**|
+|--intermediates mv2_u85/|Directory where intermediate files (e.g., TOSA, YAMLs, debug graphs) will be saved<br>Useful output files for **manual debugging**|
+|--debug|Verbose debugging logging|
+|--evaluate|Validates model output, provides timing estimates|

…g-tinyml-on-arm/4-env-setup-fvp-macos.md …g-ethos-u-performance/3-env-setup-fvp.mdcontent/learning-paths/embedded-and-microcontrollers/visualizing-tinyml-on-arm/4-env-setup-fvp-macos.md renamed to content/learning-paths/embedded-and-microcontrollers/visualizing-ethos-u-performance/3-env-setup-fvp.md content/learning-paths/embedded-and-microcontrollers/visualizing-tinyml-on-arm/4-env-setup-fvp-macos.md renamed to content/learning-paths/embedded-and-microcontrollers/visualizing-ethos-u-performance/3-env-setup-fvp.md

@@ -1,30 +1,14 @@
 ---
 # User change
-title: "Deploy a PyTorch model"
+title: "Configure the FVP GUI (optional)"
 
 weight: 6 # 1 is first, 2 is second, etc.
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
 
-## Deploy a small neural network using Python
-
-With your development environment set up, you can deploy a simple PyTorch model.
-
-This example deploys the [MobileNet V2](https://pytorch.org/hub/pytorch_vision_mobilenet_v2/) computer vision model. The model is a convolutional neural network (CNN) that extracts visual features from an image. It is used for image classification and object detection.
-
-The actual Python code for the MobileNet V2 model is in your local `executorch` repo: [executorch/examples/models/mobilenet_v2/model.py](https://github.com/pytorch/executorch/blob/main/examples/models/mobilenet_v2/model.py). You can deploy it using [run.sh](https://github.com/pytorch/executorch/blob/main/examples/arm/run.sh), just like you did in the previous step, with some extra parameters:
-```bash
-./examples/arm/run.sh \
---aot_arm_compiler_flags="--delegate --quantize --intermediates mv2_u85/ --debug --evaluate" \
---output=mv2_u85 \
---target=ethos-u85-128 \
---model_name=mv2
-```
-
-## Running the model on the Corstone-320 FVP GUI
-### Find your IP address
+## Find your IP address
 
 Note down your computer's IP address:
 ```bash
@@ -38,20 +22,17 @@ To help you, here are some common WiFi interface names on Linux:
 |wlx<MAC>|Some systems name interfaces after MAC addresses|
 |wifi0, ath0|Very rare, specific to certain drivers (e.g., Atheros)|
 
-
 {{% notice macOS %}}
 
 Note down your `en0` IP address (or whichever network adapter is active):
 
 ```bash
 ipconfig getifaddr en0 # Returns your Mac's WiFi IP address
-xhost + <YOUR_MAC_IP_ADDRESS>
-xhost + 127.0.0.1 # The Docker container seems to proxy through localhost, so add localhost just in case
 ```
 
 {{% /notice %}}
 
-### Enable the FVP's GUI
+## Enable the FVP's GUI
 
 Edit the following parameters in [run_fvp.sh](https://github.com/pytorch/executorch/blob/d5fe5faadb8a46375d925b18827493cd65ec84ce/backends/arm/scripts/run_fvp.sh#L97-L102), to enable the Mobilenet V2 output on the FVP's GUI:
 
@@ -78,17 +59,19 @@ Edit the following parameters in [run_fvp.sh](https://github.com/pytorch/executo
 --display-ip <YOUR_IP_ADDRESS>                   \
 ```
 
-### Deploy the model
+## Deploy the model
 
 {{% notice macOS %}}
 
-- Start Docker: on macOS, FVPs run inside a Docker container.
+- **Start Docker:** on macOS, FVPs run inside a Docker container.
 
   **Do not use Colima Docker!**
 
-  Make sure to use an [official version of Docker](https://www.docker.com/products/docker-desktop/) and not a free version like the [Colima](https://github.com/abiosoft/colima?tab=readme-ov-file) Docker container runtime. `run.sh` assumes Docker Desktop style networking (`host.docker.internal`) which breaks with Colima.
+  - Make sure to use an [official version of Docker](https://www.docker.com/products/docker-desktop/) and not a free version like the [Colima](https://github.com/abiosoft/colima?tab=readme-ov-file) Docker container runtime
+  - `run.sh` assumes Docker Desktop style networking (`host.docker.internal`) which breaks with Colima
+  - Colima then breaks the FVP GUI
 
-- Start XQuartz: on macOS, the FVP GUI runs using XQuartz.
+- **Start XQuartz:** on macOS, the FVP GUI runs using XQuartz.
 
   Start the xquartz.app and then configure XQuartz so that the FVP will accept connections from your Mac and localhost:
   ```bash
@@ -108,4 +91,4 @@ Now run the Mobilenet V2 computer vision model, using [executorch/examples/arm/r
 
 Observe that the FVP loads the model file, compiles the PyTorch model to ExecuTorch `.pte` format and then shows an instruction count in the top right of the GUI:
 
-![Terminal and FVP output](./Terminal%20and%20FVP%20Output.png)
+![Terminal and FVP output](./Terminal%20and%20FVP%20Output.jpg)