Merge pull request #2366 from madeline-underwood/tiny_ml_updates

Tiny ml updates_JA to review

Author: jasonrandrews

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

@@ -6,32 +6,34 @@ weight: 2
 layout: learningpathall
 ---
 
-## TinyML
+## Overview
 
 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.
+## What is TinyML?
+
 
 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.
 
-### Benefits and applications
+## Benefits and applications
 
 The benefits of TinyML align well with the Arm architecture, which is widely used in IoT, mobile devices, and edge AI deployments.
 
 Here are some of the key benefits of TinyML on Arm:
 
 
-- **Power Efficiency**: TinyML models are designed to be extremely power-efficient, making them ideal for battery-operated devices like sensors, wearables, and drones.
+- Power efficiency: TinyML models are designed to be extremely power-efficient, making them ideal for battery-operated devices like sensors, wearables, and drones.
 
-- **Low Latency**: AI processing happens on-device, so there is no need to send data to the cloud, which reduces latency and enables real-time decision-making.
+- Low latency: AI processing happens on-device, so there is no need to send data to the cloud, which reduces latency and enables real-time decision-making.
 
-- **Data Privacy**: With on-device computation, sensitive data remains local, providing enhanced privacy and security. This is a priority in healthcare and personal devices.
+- Data privacy: with on-device computation, sensitive data remains local, providing enhanced privacy and security. This is a priority in healthcare and personal devices.
 
-- **Cost-Effective**: Arm devices, which are cost-effective and scalable, can now handle sophisticated Machine Learning tasks, reducing the need for expensive hardware or cloud services.
+- Cost-effective: Arm devices, which are cost-effective and scalable, can now handle sophisticated machine learning tasks, reducing the need for expensive hardware or cloud services.
 
-- **Scalability**: With billions of Arm devices in the market, TinyML is well-suited for scaling across industries, enabling widespread adoption of AI at the edge.
+- Scalability: with billions of Arm devices in the market, TinyML is well-suited for scaling across industries, enabling widespread adoption of AI at the edge.
 
 TinyML is being deployed across multiple industries, enhancing everyday experiences and enabling groundbreaking solutions. The table below shows some examples of TinyML applications.
 

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

@@ -7,9 +7,6 @@ weight: 3
 # Do not modify these elements
 layout: "learningpathall"
 ---
-
-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.
@@ -18,7 +15,7 @@ ExecuTorch is a lightweight runtime designed for efficient execution of PyTorch
 
 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:
+Python 3 is required and comes installed with Ubuntu, but some additional packages are needed:
 
 ```bash
 sudo apt update
@@ -36,7 +33,7 @@ source $HOME/executorch-venv/bin/activate
 The prompt of your terminal now has `(executorch)` as a prefix to indicate the virtual environment is active.
 
 
-## Install Executorch
+## Install ExecuTorch
 
 From within the Python virtual environment, run the commands below to download the ExecuTorch repository and install the required packages:
 
@@ -74,6 +71,6 @@ pip list | grep executorch
 executorch             1.1.0a0+1883128
 ```
 
-## Next Steps
+## Next steps
 
-Proceed to the next section to learn about and set up the virtualized hardware.
+Proceed to the next section to set up the virtualized hardware.

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

@@ -8,22 +8,24 @@ weight: 5 # 1 is first, 2 is second, etc.
 layout: "learningpathall"
 ---
 
-In this section, you will run scripts to set up the Corstone-320 reference package.
+## Overview
 
-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.
+In this section, you 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 so you can test and optimize software before boards are available. Designed for AI and machine learning workloads, it includes support for Arm Ethos-U NPUs and Cortex-M processors, which makes it well-suited to 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
+## Set up Corstone-320 FVP for ExecuTorch
 
-Run the FVP setup script in the ExecuTorch repository.
+Run the FVP setup script in the ExecuTorch repository:
 
 ```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.
+When the script completes, it prints a command to finalize the installation by adding the FVP executables to your `PATH`:
 
 ```bash
 source $HOME/executorch/examples/arm/ethos-u-scratch/setup_path.sh

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

@@ -36,7 +36,7 @@ class SimpleNN(torch.nn.Module):
         return out
 
 # Create the model instance
-input_size = 10   # example input features size
+input_size = 10   # example input feature size
 hidden_size = 5   # hidden layer size
 output_size = 2   # number of output classes
 
@@ -52,7 +52,7 @@ ModelInputs = x
 print("Model successfully exported to simple_nn.pte")
 ```
 
-## Running the model on the Corstone-320 FVP
+## Run the model on the Corstone-320 FVP
 
 The final step is to take the Python-defined model and run it on the Corstone-320 FVP. This was done upon running the `run.sh` script in a previous section. To wrap up the Learning Path, you will perform these steps separately to better understand what happened under the hood. Start by setting some environment variables that are used by ExecuTorch.
 
@@ -61,7 +61,7 @@ export ET_HOME=$HOME/executorch
 export executorch_DIR=$ET_HOME/build
 ```
 
-Then, generate a model file on the `.pte` format using the Arm examples. The Ahead-of-Time (AoT) Arm compiler will enable optimizations for devices like the Grove Vision AI Module V2 and the Corstone-320 FVP. Run it from the ExecuTorch root directory.
+Generate a model in ExecuTorch `.pte` format using the Arm examples. The AoT Arm compiler enables optimizations for devices such as the Grove Vision AI Module V2 and the Corstone-320 FVP. Run the compiler from the ExecuTorch root directory:
 
 ```bash
 cd $ET_HOME
@@ -90,7 +90,7 @@ cmake --build $ET_HOME/examples/arm/executor_runner/cmake-out --parallel -- arm_
 
 ```
 
-Now run the model on the Corstone-320 with the following command:
+Run the model on Corstone-320:
 
 ```bash
 FVP_Corstone_SSE-320 \
@@ -104,9 +104,7 @@ FVP_Corstone_SSE-320 \
 ```
 
 {{% notice Note %}}
-
-The argument `mps4_board.visualisation.disable-visualisation=1` disables the FVP GUI. This can speed up launch time for the FVP.
-
+The argument `mps4_board.visualisation.disable-visualisation=1` disables the FVP GUI and can speed up launch time
 {{% /notice %}}
 
 Observe that the FVP loads the model file.
@@ -119,4 +117,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. In the next Learning Path of this series, you will learn about optimizing neural networks to run on Arm.
+You have now set up your environment for TinyML development on Arm and tested a small PyTorch model with ExecuTorch on the Corstone-320 FVP. In the next Learning Path, you learn how to optimize neural networks to run efficiently on Arm.

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

@@ -6,10 +6,10 @@ minutes_to_complete: 40
 who_is_this_for: This is an introductory topic for developers and data scientists new to Tiny Machine Learning (TinyML) who want to explore its potential using PyTorch and ExecuTorch.
 
 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 Fixed Virtual Platform (FVP).
+    - 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 Fixed Virtual Platform (FVP)
 
 prerequisites:
     - Basic knowledge of Machine Learning concepts