Updates

Author: madeline-underwood

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

@@ -1,32 +1,30 @@
 ---
-title: Edge AI with PyTorch & ExecuTorch - Tiny Rock-Paper-Scissors on Arm
+title: "Edge AI on Arm with PyTorch and ExecuTorch: Tiny Rock-Paper-Scissors"
 
 minutes_to_complete: 60
 
-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 is an introductory topic for machine learning developers who want to deploy TinyML models on Arm-based edge devices using PyTorch and ExecuTorch.
 
 learning_objectives:
-    - 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.
-
+  - Train a small Convolutional Neural Network (CNN) for image classification using PyTorch
+  - Use synthetic data generation for training a model when real data is limited
+  - Convert and optimize a PyTorch model to an ExecuTorch program (`.pte`) for Arm-based devices
+  - Run the trained model locally as an interactive mini-game to demonstrate inference
 
 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.
+  - Basic understanding of machine learning concepts
+  - Familiarity with Python and the PyTorch library
+  - Completion of the Learning Path [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 later
 
 author: Dominica Abena O. Amanfo
 
 ### Tags
 skilllevels: Introductory
 subjects: ML
 armips:
-    - Cortex-M
-    - Ethos-U
+  - Cortex-M
+  - Ethos-U
 tools_software_languages:
     - tinyML
     - Computer Vision
@@ -36,23 +34,21 @@ tools_software_languages:
     - ExecuTorch
 
 operatingsystems:
-    - Linux
+  - Linux
 
 further_reading:
-    - resource:
-        title: Run Llama 3 on a Raspberry Pi 5 using ExecuTorch
-        link: /learning-paths/embedded-and-microcontrollers/rpi-llama3
-        type: website
-    - resource:
-        title: ExecuTorch Examples
-        link: https://github.com/pytorch/executorch/blob/main/examples/README.md
-        type: website
-
-
+  - resource:
+      title: Run Llama 3 on a Raspberry Pi 5 using ExecuTorch
+      link: /learning-paths/embedded-and-microcontrollers/rpi-llama3
+      type: website
+  - resource:
+      title: ExecuTorch examples
+      link: https://github.com/pytorch/executorch/blob/main/examples/README.md
+      type: website
 
 ### FIXED, DO NOT MODIFY
 # ================================================================================
 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,40 +6,45 @@ weight: 2
 layout: learningpathall
 ---
 
-## 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.
+## Environment setup for tiny rock-paper-scissors on Arm (PyTorch + ExecuTorch)
+
+
+
+This Learning Path is a direct follow-up to [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm). While the previous Learning Path introduced the core concepts and toolchain, this one puts that knowledge into practice with a small, real-world example. You move from a simple [Feedforward Neural Network](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm/4-build-model) to a practical computer vision task: a tiny Rock-Paper-Scissors game that runs efficiently on Arm-based edge devices.
 
 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.
+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.
 
 A convolutional neural network (CNN) is a deep neural network designed to analyze visual data using the **convolution** operation. CNNs learn spatial hierarchies of features - from edges and textures to shapes and objects - directly from pixels.
 
-CNNs are the backbone of many modern computer vision applications, including:
+![Conceptual CNN diagram alt-text#center](image.png)  
+[Image credits](https://medium.com/@atul_86537/learning-ml-from-first-principles-c-linux-the-rick-and-morty-way-convolutional-neural-c76c3df511f4)
 
-- **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.
+Common CNN applications include:
 
-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.
+- Image classification: identify the main object in an image, such as classifying a photo as a cat or dog
+- Object detection: locate specific objects in an image and draw bounding boxes
+- Facial recognition: identify or verify individuals based on facial features
 
+For the rock-paper-scissors game, you use a tiny CNN to classify the letters R, P, and S as the corresponding hand gestures.
 
+## Environment setup
 
-## 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.
+To get started, complete the first three sections of [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm). This setup prepares your development environment and installs the required tools. Return here after running 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:
+If you just completed the earlier Learning Path, your virtual environment should still be active. If not, activate it:
 
 ```console
 source $HOME/executorch-venv/bin/activate
 ```
 The prompt of your terminal now has `(executorch-venv)` as a prefix to indicate the virtual environment is active.
 
-Run the commands below to install the dependencies.
+Install Python dependencies:
 
-```bash
-pip install argparse numpy pillow torch
+```console
+pip install numpy pillow torch
 ```
-You are now ready to create the model.
 
+You’re now ready to create the model.