Merge pull request #2339 from annietllnd/review

Tech review of training-inference-pytorch

Author: pareenaverma

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

@@ -44,6 +44,7 @@ From within the Python virtual environment, run the commands below to download t
 cd $HOME
 git clone https://github.com/pytorch/executorch.git
 cd executorch
+git checkout 188312844ebfb499f92ab5a02137ed1a4abca782
 ```
 
 Run the commands below to set up the ExecuTorch internal dependencies:
@@ -70,7 +71,7 @@ pip list | grep executorch
 ```
 
 ```output
-executorch         0.6.0a0+3eea1f1
+executorch             1.1.0a0+1883128
 ```
 
 ## Next Steps

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

@@ -16,11 +16,11 @@ The Corstone reference system is provided free of charge, although you will have
 
 ## Corstone-320 FVP Setup for ExecuTorch
 
-Navigate to the Arm examples directory in the ExecuTorch repository. Run the following command.
+Run the FVP setup script in the ExecuTorch repository.
 
 ```bash
-cd $HOME/executorch/examples/arm
-./setup.sh --i-agree-to-the-contained-eula
+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.

content/learning-paths/embedded-and-microcontrollers/training-inference-pytorch/_index.md

@@ -1,44 +1,43 @@
 ---
-title: Edge AI with PyTorch & ExecuTorch - Tiny Sentiment Analysis on Arm
+title: Edge AI with PyTorch & ExecuTorch - Tiny Rock-Paper-Scissors on Arm
 
-draft: true
-cascade:
-    draft: true
+minutes_to_complete: 60
 
-minutes_to_complete: 90
+who_is_this_for: This learning path is for machine learning developers interested in deploying TinyML models on Arm-based edge devices. You will learn how to train and deploy a machine learning model for the classic game "Rock-Paper-Scissors" on edge devices. You'll use PyTorch and ExecuTorch, frameworks designed for efficient on-device inference, to build and run a small-scale computer vision model.
 
-who_is_this_for: This topic is for machine learning engineers, embedded AI developers, and researchers interested in deploying TinyML models for NLP on Arm-based edge devices using PyTorch and ExecuTorch.
 
 learning_objectives:
-    - Train a custom CNN-based sentiment classification model implemented in PyTorch.
-    - Optimize and convert the model using ExecuTorch for Arm-based edge devices.
-    - Deploy and run inference on the Corstone-320 FVP.
+    - Train a small Convolutional Neural Network (CNN) for image classification using PyTorch.
+    - Understand how to use synthetic data generation for training a model when real-world data is limited.
+    - Optimize and convert a PyTorch model into an ExecuTorch program (.pte) for Arm-based devices.
+    - Run the trained model on a local machine to play an interactive mini-game, demonstrating model inference.
 
-prerequisites:
-   - Basic knowledge of machine learning concepts.
-   - It is advised to complete The Learning Path, [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm) before starting this learning path.
-   - Familiarity with Python and PyTorch.
-   - A Linux host machine or VM running Ubuntu 22.04 or higher.
-   - An Arm license to run the examples on the Corstone-320 Fixed Virtual Platform (FVP), for hands-on deployment.
 
+prerequisites:
+   - A basic understanding of machine learning concepts.
+   - Familiarity with Python and the PyTorch library.
+   - Having completed [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm).
+   - An x86 Linux host machine or VM running Ubuntu 22.04 or higher.
 
 author: Dominica Abena O. Amanfo
 
 ### Tags
 skilllevels: Introductory
 subjects: ML
 armips:
-    - Cortex-A
+    - Cortex-M
+    - Ethos-U
 tools_software_languages:
     - tinyML
+    - Computer Vision
+    - Edge AI
     - CNN
     - PyTorch
     - ExecuTorch
 
 operatingsystems:
     - Linux
 
-
 further_reading:
     - resource:
         title: Run Llama 3 on a Raspberry Pi 5 using ExecuTorch
@@ -56,4 +55,4 @@ further_reading:
 weight: 1                       # _index.md always has weight of 1 to order correctly
 layout: "learningpathall"       # All files under learning paths have this same wrapper
 learning_path_main_page: "yes"  # This should be surfaced when looking for related content. Only set for _index.md of learning path content.
----
+---

content/learning-paths/embedded-and-microcontrollers/training-inference-pytorch/env-setup-1.md

@@ -6,17 +6,31 @@ weight: 2
 layout: learningpathall
 ---
 
-## Overview 
-In this course, you will learn how to train and run inference using a Tiny Sentiment Classifier. You'll deploy the model on the Arm Corstone-320 FVP for sentiment analysis. 
+## Overview
+This learning path (LP) is a direct follow-up to the [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm) learning path. While the previous one introduced you to the core concepts and the toolchain, this one puts that knowledge into practice with a fun, real-world example. You will move from the simple [Feedforward Neural Network](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/4-build-model) in the previous LP, to a more practical computer vision task: A tiny Rock-Paper-Scissors game, to demonstrate how these tools can be used to solve a tangible problem and run efficiently on Arm-based edge devices.
 
-We will train a lightweight convolutional neural network (CNN)-based sentiment classifier using synthetic text data. This model is optimized for small devices, using embedding layers and 1D convolutions for efficient text classification.
+You will train a lightweight CNN to classify images of the letters R, P, and S as "rock," "paper," or "scissors." The script uses a synthetic data renderer to create a large dataset of these images with various transformations and noise, eliminating the need for a massive real-world dataset.
 
+### What is a Convolutional Neural Network (CNN)?
+A Convolutional Neural Network (CNN) is a type of deep neural network primarily used for analyzing visual imagery. Unlike traditional neural networks, CNNs are designed to process pixel data by using a mathematical operation called **convolution**. This allows them to automatically and adaptively learn spatial hierarchies of features from input images, from low-level features like edges and textures to high-level features like shapes and objects.
 
-## Environment Setup
-Setup your development environment for TinyML by following the first 3 chapters of the [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm) Learning Path (LP).
+![Image of a convolutional neural network architecture](image.png)
+[Image credits](https://medium.com/@atul_86537/learning-ml-from-first-principles-c-linux-the-rick-and-morty-way-convolutional-neural-c76c3df511f4).
+
+CNNs are the backbone of many modern computer vision applications, including:
+
+- **Image Classification:** Identifying the main object in an image, like classifying a photo as a "cat" or "dog".
+- **Object Detection:** Locating specific objects within an image and drawing a box around them.
+- **Facial Recognition:** Identifying and verifying individuals based on their faces.
+
+For the Rock-Paper-Scissors game, you'll use a tiny CNN to classify images of the letters R, P, and S as the corresponding hand gestures.
 
 
-If you just followed the LP above, you should already have your virtual environment activated. If not, activate it using: 
+
+## Environment Setup
+To get started, follow the first three chapters of the [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm) Learning Path. This will set up your development environment and install the necessary tools. Return to this LP once you've run the `./examples/arm/run.sh` script in the ExecuTorch repository.
+
+If you just followed the LP above, you should already have your virtual environment activated. If not, activate it using:
 
 ```console
 source $HOME/executorch-venv/bin/activate
@@ -26,8 +40,7 @@ The prompt of your terminal now has `(executorch-venv)` as a prefix to indicate
 Run the commands below to install the dependencies.
 
 ```bash
-pip install argparse json
+pip install argparse numpy pillow torch
 ```
-You are now ready to build the model
-
+You are now ready to create the model.