Add Dominica's updates to training-inference-pytorch

Author: annietllnd

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

@@ -1,36 +1,37 @@
 ---
-title: Edge AI with PyTorch & ExecuTorch - Tiny Sentiment Analysis on Arm
-
-draft: true
-cascade:
-    draft: true
+title: Edge AI with PyTorch & ExecuTorch - Tiny Rock-Paper-Scissors on Arm
 
 minutes_to_complete: 90
 
-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.
+who_is_this_for: This learning path is for machine learning engineers, embedded AI developers, and researchers 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. We'll use PyTorch and ExecuTorch, a framework designed for efficient on-device inference, to build and run a small-scale computer vision model.
+
 
 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 basic understanding of machine learning concepts.
+   - Familiarity with Python and the PyTorch library.
+   - It is advised to first complete [Introduction to TinyML on Arm using PyTorch and ExecuTorch](/learning-paths/embedded-and-microcontrollers/introduction-to-tinyml-on-arm) before starting this learning path.
    - 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.
 
 
 author: Dominica Abena O. Amanfo
 
 ### Tags
-skilllevels: Introductory
+skilllevels: Intermediate
 subjects: ML
 armips:
-    - Cortex-A
+    - Cortex-M
 tools_software_languages:
     - tinyML
+    - Computer Vision
+    - Edge AI Game
     - CNN
     - PyTorch
     - ExecuTorch
@@ -56,4 +57,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,34 @@ 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 path introduced you to the core concepts and the toolchain, this one puts that knowledge into practice with a fun, real-world example. We 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 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.
+
+![Image of a convolutional neural network architecture](image.png)
+
+Image of a convolutional neural network architecture : [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 our Rock-Paper-Scissors game, we'll use a tiny CNN to classify images of the letters R, P, and S as the corresponding hand gestures.
 
-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.
 
 
 ## 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).
+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.
 
 
-If you just followed the LP above, you should already have your virtual environment activated. If not, activate it using: 
+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 +43,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 json numpy pillow torch
 ```
-You are now ready to build the model
-
+You are now ready to build the model.