Merge pull request #1522 from annietllnd/tiny-ml

WIP TinyML LP

Author: jasonrandrews

content/learning-paths/microcontrollers/introduction-to-tinyml-on-arm/Overview-1.md

@@ -6,42 +6,64 @@ weight: 2
 layout: learningpathall
 ---
 
-TinyML represents a significant shift in machine learning deployment. 
+This Learning Path is about TinyML. It serves as a starting point for learning how cutting-edge AI technologies may be put on even the smallest of devices, making Edge AI more accessible and efficient. You will learn how to setup on your host machine and target device to facilitate compilation and ensure smooth integration across all devices.
 
-Unlike traditional machine learning, which typically depends on cloud-based servers or high-powered hardware, TinyML is tailored to function on devices with limited resources, constrained memory, low power, and less processing capabilities. 
+In this section, you get an overview of the domain with real-life use-cases and available devices.
 
-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. 
+## Overview
+TinyML represents a significant shift in machine learning deployment. Unlike traditional machine learning, which typically depends on cloud-based servers or high-powered hardware, TinyML is tailored to function on devices with limited resources, constrained memory, low power, and less 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.
 
-This shift opens up new possibilities for creating smarter and more efficient embedded systems.
+### Benefits and applications
 
-## Module Overview 
+The advantages of TinyML match up well with the Arm architecture, which is widely used in IoT, mobile devices, and edge AI deployments.
 
-This Learning Path is about TinyML, applying machine learning to devices with limited resources like microcontrollers. It serves as a starting point for learning how cutting-edge AI technologies may be put on even the smallest of devices, making Edge AI more accessible and efficient. 
+Here are some key benefits of TinyML on Arm:
 
-You will learn how to setup on your host machine and target device to facilitate compilation and ensure smooth integration across all devices.
 
-## Examples of Arm-based devices and applications
+- **Power Efficiency**: TinyML models are designed to be extremely power-efficient, making them ideal for battery-operated devices like sensors, wearables, and drones.
 
-There are many devices you can use for TinyML projects. Some of them are listed below.
+- **Low Latency**: Because the AI processing happens on-device, there's no need to send data to the cloud, reducing latency and enabling real-time decision-making.
 
-### Raspberry Pi 4 and 5
+- **Data Privacy**: With on-device computation, sensitive data remains local, providing enhanced privacy and security. This is particularly crucial 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.
+
+- **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 contains a few examples of TinyML applications.
+
+| Area                  |  Device, Arm IP           | Description                                                                                             |
+| ------                | -------                   | ------------                                                                                            |
+| Healthcare            | Fitbit Charge 5, Cortex-M | Monitor vital signs such as heart rate, detect arrhythmias, and provide real-time feedback.             |
+| Agriculture           | OpenAg, Cortex-M          | Monitor soil moisture and optimize water usage.                                                         |
+| Home automation       | Arlo, Cortex-A            | Detect objects and people, trigger alerts or actions while saving bandwidth and improving privacy.      |
+| Industrial IoT        | Siemens, Cortex-A         | Analyze vibration patterns in machinery to predict when maintenance is needed and prevent breakdowns.   |
+| Wildlife conservation | Conservation X, Cortex-M  | Identify animal movements or detect poachers in remote areas without relying on external power sources. |
+
+### Examples of Arm-based devices
+
+There are many Arm-based off-the-shelf devices you can use for TinyML projects. Some of them are listed below, but the list is not exhaustive.
+
+#### Raspberry Pi 4 and 5
 
 Raspberry Pi single-board computers are excellent for prototyping TinyML projects. They are commonly used for prototyping machine learning projects at the edge, such as in object detection and voice recognition for home automation.
 
-### NXP i.MX RT microcontrollers
+#### NXP i.MX RT microcontrollers
 
 NXP i.MX RT microcontrollers are low-power microcontrollers that can handle complex TinyML tasks while maintaining energy efficiency, making them ideal for applications like wearable healthcare devices and environmental sensors.
 
-### STM32 microcontrollers
+#### STM32 microcontrollers
 
 STM32 microcontrollers are used in industrial IoT applications for predictive maintenance. These microcontrollers are energy-efficient and capable of running TinyML models for real-time anomaly detection in factory machinery.
 
-### Arduino Nano 33 BLE Sense
+#### Arduino Nano 33 BLE Sense
 
 The Arduino Nano, equipped with a suite of sensors, supports TinyML and is ideal for small-scale IoT applications, such as detecting environmental changes and movement patterns.
 
-### Edge Impulse
+#### Edge Impulse
+
+In addition to hardware, there are software platforms that can help you build TinyML applications.
 
-In addition to hardware, there are software platforms that can help you build TinyML applications. 
+Edge Impulse platform 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.
 
-Edge Impulse platform 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, move on to the next section where you will set up an environment on your host machine.

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

@@ -7,23 +7,22 @@ cascade:
 
 minutes_to_complete: 40
 
-who_is_this_for: This is an introductory topic for developers, engineers, and data scientists who are new to TinyML and interested in exploring its potential for edge AI. You will learn how to get started using PyTorch and ExecuTorch for TinyML. 
+who_is_this_for: This is an introductory topic for developers, engineers, and data scientists who are new to TinyML and interested in exploring its potential for edge AI. You will learn how to get started using PyTorch and ExecuTorch for TinyML.
 
-learning_objectives: 
-    - Identify TinyML and how it's different from the AI you might be used to.
+learning_objectives:
+    - Identify how TinyML is different from other AI domains.
     - Understand the benefits of deploying AI models on Arm-based edge devices.
     - Select Arm-based devices for TinyML.
-    - Identify real-world use cases demonstrating the impact of TinyML.
     - Install and configure a TinyML development environment.
-    - Set up a cross-compilation environment on your host machine.
     - Perform best practices for ensuring optimal performance on constrained edge devices.
 
 
 prerequisites:
     - Basic knowledge of machine learning concepts.
-    - Understanding of IoT and embedded systems.
     - 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-300 Fixed Virtual Platform (FVP).
+
+
 author_primary: Dominica Abena O. Amanfo
 
 ### Tags
@@ -32,7 +31,7 @@ subjects: ML
 armips:
     - Cortex-A
     - Cortex-M
-   
+
 operatingsystems:
     - Linux
 
@@ -42,7 +41,7 @@ tools_software_languages:
     - Python
     - PyTorch
     - ExecuTorch
-    - Arm Compute Library 
+    - Arm Compute Library
     - GCC
     - Edge Impulse
     - Node.js

content/learning-paths/microcontrollers/introduction-to-tinyml-on-arm/benefits-3.md

@@ -8,9 +8,10 @@ weight: 7 # 1 is first, 2 is second, etc.
 layout: "learningpathall"
 ---
 
-With our Environment ready, you can create a simple program to test the setup. 
+TODO connect this part with the FVP/board?
+With our environment ready, you can create a simple program to test the setup.
 
-This example defines a small feedforward neural network for a classification task. The model consists of 2 linear layers with ReLU activation in between. 
+This example defines a small feedforward neural network for a classification task. The model consists of 2 linear layers with ReLU activation in between.
 
 Use a text editor to create a file named `simple_nn.py` with the following code:
 
@@ -26,7 +27,7 @@ class SimpleNN(torch.nn.Module):
         self.fc1 = torch.nn.Linear(input_size, hidden_size)
         self.relu = torch.nn.ReLU()
         self.fc2 = torch.nn.Linear(hidden_size, output_size)
-        
+
     def forward(self, x):
         out = self.fc1(x)
         out = self.relu(out)
@@ -73,7 +74,7 @@ Model successfully exported to simple_nn.pte
 
 The model is saved as a .pte file, which is the format used by ExecuTorch for deploying models to the edge.
 
-Run the ExecuTorch version, first build the executable: 
+Run the ExecuTorch version, first build the executable:
 
 ```console
 # Clean and configure the build system
@@ -105,7 +106,7 @@ I 00:00:00.006635 executorch:executor_runner.cpp:129] Setting up planned buffer
 I 00:00:00.007225 executorch:executor_runner.cpp:152] Method loaded.
 I 00:00:00.007237 executorch:executor_runner.cpp:162] Inputs prepared.
 I 00:00:00.012885 executorch:executor_runner.cpp:171] Model executed successfully.
-I 00:00:00.012896 executorch:executor_runner.cpp:175] 1 outputs: 
+I 00:00:00.012896 executorch:executor_runner.cpp:175] 1 outputs:
 Output 0: tensor(sizes=[1, 2], [-0.105369, -0.178723])
 ```
 

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

@@ -2,127 +2,63 @@
 # User change
 title: "Environment Setup on Host Machine"
 
-weight: 4 # 1 is first, 2 is second, etc.
+weight: 3
 
 # Do not modify these elements
 layout: "learningpathall"
 ---
-## Before you begin 
 
-You will use a Linux computer to run PyTorch and ExecuTorch to prepare a TinyML model to run on edge devices. 
+In this section, you will prepare a development environment to compile the model. These instructions have been tested on Ubuntu 22.04, 24.04 and on Windows Subsystem for Linux (WSL).
 
-The instructions are for Ubuntu 22.04 or newer.
+## Install dependencies
 
-You also need the [Grove Vision AI Module](https://wiki.seeedstudio.com/Grove-Vision-AI-Module/). If you don't have the board you can use the Corstone-300 Fixed Virtual Platform (FVP) instead.
+Python3 is required and comes installed with Ubuntu, but some additional packages are needed.
 
-{{% notice Note %}}
-Note that the Corstone-300 FVP is not available for the Arm architecture so your host machine needs to x86_64.
-{{% /notice %}}
-
-The instructions have been tested on:
-- Arm-based cloud instances running Ubuntu 22.04.
-- Desktop computer with Ubuntu 24.04.
-- Windows Subsystem for Linux (WSL).
-
-The host machine is where you will perform most of your development work, especially compiling code for the target Arm devices.
-
-## Install Python
-
-Python 3 is included in Ubuntu, but some additional packages are needed. 
-
-```console
+```bash
 sudo apt update
-sudo apt install python-is-python3 gcc g++ make -y
+sudo apt install python-is-python3 python3-dev python3-venv gcc g++ make -y
 ```
 
-## Install PyTorch
-
-Create a Python virtual environment using Miniconda. 
-
-For Arm Linux:
+## Create a virtual environment
 
-```console
-curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-aarch64.sh
-sh ./Miniconda3-latest-Linux-aarch64.sh -b
-eval "$($HOME/miniconda3/bin/conda shell.bash hook)"
-conda --version
-```
-
-For x86_64 Linux:
+Create a Python virtual environment using `python venv`.
 
 ```console
-curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
-sh ./Miniconda3-latest-Linux-x86_64.sh -b
-eval "$($HOME/miniconda3/bin/conda shell.bash hook)"
-conda --version
+python3 -m venv $HOME/executorch-venv
+source $HOME/executorch-venv/bin/activate
 ```
-
-Activate the Python virtual environment:
-
-```bash
-conda create -yn executorch python=3.10.0
-conda activate executorch
-```
-
 The prompt of your terminal now has (executorch) as a prefix to indicate the virtual environment is active.
 
 
 ## Install Executorch
 
-From within the Python virtual environment, run the commands below to download the ExecuTorch repository and install the required packages: 
+From within the Python virtual environment, run the commands below to download the ExecuTorch repository and install the required packages:
 
 ``` bash
-# Clone the ExecuTorch repo from GitHub
-git clone --branch v0.3.0 https://github.com/pytorch/executorch.git
+cd $HOME
+git clone https://github.com/pytorch/executorch.git
 cd executorch
+```
 
-# Update and pull submodules
+Run a few commands to set up the ExecuTorch internal dependencies.
+```bash
 git submodule sync
 git submodule update --init
 
-# Install ExecuTorch pip package and its dependencies, as well as
-# development tools like CMake.
 ./install_requirements.sh
 ```
 
-## Install Edge Impulse CLI
-
-1. Create an [Edge Impulse Account](https://studio.edgeimpulse.com/signup) and sign in.
-
-2. Install the Edge Impulse CLI tools in your terminal
-
-The Edge Impulse CLI tools require Node.js. 
-
-```console
-sudo apt install nodejs npm -y
-```
-
-Confirm `node` is available by running: 
-
-```console
-node -v 
-```
-
-Your version is printed, for example:
-
-```output
-v18.19.1
-```
-
-Install the Edge Impulse CLI using NPM:
-
-```console
-npm install -g edge-impulse-cli
-```
-
-3. Install Screen to use with edge devices
+{{% notice Note %}}
+If you run into an issue of `buck` running in a stale environment, reset it by running the following instructions.
 
-```console
-sudo apt install screen -y
+```bash
+ps aux | grep buck
+pkill -f buck
 ```
+{{% /notice %}}
 
 ## Next Steps
 
-If you don't have the Grove AI vision board and want to use the Corstone-300 FVP proceed to [Environment Setup Corstone-300 FVP](/learning-paths/microcontrollers/introduction-to-tinyml-on-arm/env-setup-6-fvp/)
+If you don't have the Grove AI vision board, use the Corstone-300 FVP proceed to [Environment Setup Corstone-300 FVP](/learning-paths/microcontrollers/introduction-to-tinyml-on-arm/env-setup-6-fvp/)
 
 If you have the Grove board proceed o to [Setup on Grove - Vision AI Module V2](/learning-paths/microcontrollers/introduction-to-tinyml-on-arm/setup-7-grove/)