Update TinyML introduction LP

Author: annietllnd

content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/Overview-1.md renamed to content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/1-overview.md

@@ -8,12 +8,11 @@ layout: learningpathall
 
 ## TinyML
 
-
-This Learning Path is about TinyML. It is a starting point for learning how innovative AI technologies can be used on even the smallest of devices, making Edge AI more accessible and efficient. You will learn how to set up your host machine and target device to facilitate compilation and ensure smooth integration across devices.
+This Learning Path is about TinyML. It is a starting point for learning how innovative AI technologies can be used on even the smallest of devices, making Edge AI more accessible and efficient. You will learn how to set up your host machine to facilitate compilation and ensure smooth integration across devices.
 
 This section provides an overview of the domain with real-life use cases and available devices.
 
-TinyML represents a significant shift in Machine Learning deployment. Unlike traditional Machine Learning, which typically depends on cloud-based servers or high-performance hardware, TinyML is tailored to function on devices with limited resources, constrained memory, low power, and fewer processing capabilities. 
+TinyML represents a significant shift in Machine Learning deployment. Unlike traditional Machine Learning, which typically depends on cloud-based servers or high-performance hardware, TinyML is tailored to function on devices with limited resources, constrained memory, low power, and fewer processing capabilities.
 
 TinyML has gained popularity because it enables AI applications to operate in real-time, directly on the device, with minimal latency, enhanced privacy, and the ability to work offline. This shift opens up new possibilities for creating smarter and more efficient embedded systems.
 
@@ -36,7 +35,7 @@ Here are some of the key benefits of TinyML on Arm:
 
 TinyML is being deployed across multiple industries, enhancing everyday experiences and enabling groundbreaking solutions. The table below shows some examples of TinyML applications.
 
-| Area                  |  Device, Arm IP             | Description                                                                                                |
+| Area                  |  Example, Arm IP            | Description                                                                                                |
 | ------                | -------                     | ------------                                                                                               |
 | Healthcare            | Fitbit Charge 5, Cortex-M   | To monitor vital signs such as heart rate, detect arrhythmias, and provide real-time feedback.             |
 | Agriculture           | OpenAg, Cortex-M            | To monitor soil moisture and optimize water usage.                                                         |
@@ -70,4 +69,4 @@ In addition to hardware, there are software platforms that can help you build Ti
 
 Edge Impulse offers a suite of tools for developers to build and deploy TinyML applications on Arm-based devices. It supports devices like Raspberry Pi, Arduino, and STMicroelectronics boards.
 
-Now that you have an overview of the subject, you can move on to the next section where you will set up an environment on your host machine.
+Now that you have an overview of the subject, you can move on to the next section where you will set up a development environment.

content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/env-setup-5.md renamed to content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/2-env-setup.md

@@ -1,17 +1,23 @@
 ---
 # User change
-title: "Environment Setup on Host Machine"
+title: "Install ExecuTorch"
 
 weight: 3
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
 
-In this section, you will prepare a development environment to compile a Machine Learning model. These instructions have been tested on Ubuntu 22.04, 24.04, and on Windows Subsystem for Linux (WSL).
+In this section, you will prepare a development environment to compile a machine learning model.
+
+## Introduction to ExecuTorch
+
+ExecuTorch is a lightweight runtime designed for efficient execution of PyTorch models on resource-constrained devices. It enables machine learning inference on embedded and edge platforms, making it well-suited for Arm-based hardware. Since Arm processors are widely used in mobile, IoT, and embedded applications, ExecuTorch leverages Arm’s efficient CPU architectures to deliver optimized performance while maintaining low power consumption. By integrating with Arm’s compute libraries, it ensures smooth execution of AI workloads on Arm-powered devices, from Cortex-M microcontrollers to Cortex-A application processors.
 
 ## Install dependencies
 
+These instructions have been tested on Ubuntu 22.04, 24.04, and on Windows Subsystem for Linux (WSL).
+
 Python3 is required and comes installed with Ubuntu, but some additional packages are needed:
 
 ```bash
@@ -45,7 +51,6 @@ Run the commands below to set up the ExecuTorch internal dependencies:
 ```bash
 git submodule sync
 git submodule update --init
-./install_requirements.sh
 ./install_executorch.sh
 ```
 
@@ -70,8 +75,4 @@ executorch         0.6.0a0+3eea1f1
 
 ## Next Steps
 
-Your next steps depend on your hardware. 
-
-If you have the Grove Vision AI Module, proceed to [Set up the Grove Vision AI Module V2 Learning Path](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/setup-7-grove/).
-
-If you do not have the Grove Vision AI Module, you can use the Corstone-320 FVP instead. See the Learning Path [Set up the Corstone-320 FVP](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/env-setup-6-fvp/).
+Proceed to the next section to learn about and set up the virtualized hardware.

content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/3-env-setup-FVP.md

@@ -0,0 +1,40 @@
+---
+# User change
+title: "Set up the Corstone-320 FVP"
+
+weight: 5 # 1 is first, 2 is second, etc.
+
+# Do not modify these elements
+layout: "learningpathall"
+---
+
+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
+
+Navigate to the Arm examples directory in the ExecuTorch repository. Run the following command.
+
+```bash
+cd $HOME/executorch/examples/arm
+./setup.sh --i-agree-to-the-contained-eula
+```
+
+After the script has finished running, it prints a command to run to finalize the installation. This step adds the FVP executables to your system path.
+
+```bash
+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:
+
+```bash
+ ./examples/arm/run.sh --target=ethos-u85-256
+```
+
+You will see a number of examples run on the FVP.
+
+This confirms the installation, so you can now proceed to the Learning Path [Build a Simple PyTorch Model](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/build-model-8/).

content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/build-model-8.md renamed to content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/4-build-model.md

@@ -106,8 +106,6 @@ FVP_Corstone_SSE-320 \
 -a "$ET_HOME/examples/arm/executor_runner/cmake-out/arm_executor_runner"
 ```
 
-
-
 {{% notice Note %}}
 
 The argument `mps4_board.visualisation.disable-visualisation=1` disables the FVP GUI. This can speed up launch time for the FVP.
@@ -124,4 +122,4 @@ I [executorch:arm_executor_runner.cpp:412] Model in 0x70000000 $
 I [executorch:arm_executor_runner.cpp:414] Model PTE file loaded. Size: 3360 bytes.
 ```
 
-You have now set up your environment for TinyML development on Arm, and tested a small PyTorch and ExecuTorch Neural Network.
+You have now set up your environment for TinyML development on Arm, and tested a small PyTorch and ExecuTorch Neural Network. In the next Learning Path of this series, you will learn about optimizing neural networks to run on Arm.

content/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/_index.md

@@ -9,12 +9,11 @@ learning_objectives:
     - Describe what differentiates TinyML from other AI domains.
     - Describe the benefits of deploying AI models on Arm-based edge devices.
     - Identify suitable Arm-based devices for TinyML applications.
-    - Set up and configure a TinyML development environment using ExecuTorch and Corstone-320 FVP.
+    - Set up and configure a TinyML development environment using ExecuTorch and Corstone-320 Fixed Virtual Platform (FVP).
 
 prerequisites:
-    - Basic knowledge of Machine Learning concepts.
-    - A Linux host machine or VM running Ubuntu 22.04 or higher.
-    - A [Grove Vision AI Module](https://wiki.seeedstudio.com/Grove-Vision-AI-Module/) or an Arm license to run the Corstone-320 Fixed Virtual Platform (FVP).
+    - Basic knowledge of Machine Learning concepts
+    - A Linux computer
 
 
 author: Dominica Abena O. Amanfo
@@ -37,23 +36,21 @@ tools_software_languages:
     - ExecuTorch
     - Arm Compute Library
     - GCC
-    - Edge Impulse
-    - Node.js
 
 further_reading:
     - resource:
-        title: TinyML Brings AI to Smallest Arm Devices 
+        title: TinyML Brings AI to Smallest Arm Devices
         link: https://newsroom.arm.com/blog/tinyml
         type: blog
     - resource:
-        title: Arm Compiler for Embedded
-        link: https://developer.arm.com/Tools%20and%20Software/Arm%20Compiler%20for%20Embedded
+        title: Arm Machine Learning Resources
+        link: https://www.arm.com/developer-hub/embedded-and-microcontrollers/ml-solutions/getting-started
         type: documentation
     - resource:
-        title: Arm GNU Toolchain
-        link: https://developer.arm.com/Tools%20and%20Software/GNU%20Toolchain
+        title: Arm Developers Guide for Cortex-M Processors and Ethos-U NPU
+        link: https://developer.arm.com/documentation/109267/0101
         type: documentation
-    
+