Merge branch 'ArmDeveloperEcosystem:main' into Executorch_Kleid

madeline-underwood · web-flow · commit f1dccbd5adf2 · 2024-10-22T15:44:07.000+01:00
diff --git a/content/install-guides/wperf.md b/content/install-guides/wperf.md
@@ -30,26 +30,26 @@ multitool_install_part: false   # Set to true if a sub-page of a multi-page arti
 layout: installtoolsall         # DO NOT MODIFY. Always true for tool install articles
 ---
 
-WindowsPerf is a Linux Perf inspired Windows on Arm performance profiling tool. Profiling is based on ARM64 PMU and its hardware counters. WindowsPerf supports the counting model for obtaining aggregate counts of occurrences of special events, and sampling model for determining the frequencies of event occurrences produced by program locations at the function, basic block, and/or instruction levels.  WindowsPerf is an open-source project hosted on [GitHub](https://github.com/arm-developer-tools/windowsperf).
+WindowsPerf is a Linux Perf-inspired Windows on Arm performance profiling tool. Profiling is based on the Arm AArch64 PMU and its hardware counters. WindowsPerf supports the counting model for obtaining aggregate counts of occurrences of PMU events, and the sampling model for determining the frequencies of event occurrences produced by program locations at the function, basic block, and instruction levels.  WindowsPerf is an open-source project hosted on [GitHub](https://github.com/arm-developer-tools/windowsperf).
 
-WindowsPerf consists of a kernel-mode driver and a user-space command-line tool. The WindowsPerf command line tool can be seamlessly integrated with both the [WindowsPerf Visual Studio Extension](#vs2022) and the [WindowsPerf VS Code Extension](#vscode). These extensions, which can be downloaded from the Visual Studio Marketplace, enhance the functionality of WindowsPerf by providing a more user-friendly interface and additional features for performance analysis and debugging. This integration allows developers to efficiently analyze and optimize their applications directly within their preferred development environment.
+WindowsPerf consists of a kernel-mode driver and a user-space command-line tool. You can seamlessly integrate the WindowsPerf command line tool with both the [WindowsPerf Visual Studio Extension](#vs2022) and the [WindowsPerf VS Code Extension](#vscode). These extensions, which you can download from the Visual Studio Marketplace, enhance the functionality of WindowsPerf by providing a user-friendly interface, and additional features for performance analysis and debugging. This integration allows developers to efficiently analyze and optimize their applications directly within their preferred development environment.
 
 
-{{% notice  Virtual Machines%}}
-WindowsPerf cannot be used on virtual machines, such as cloud instances.
+{{% notice  Note%}}
+You cannot use WindowsPerf on virtual machines, such as cloud instances.
 {{% /notice %}}
 
 ## Visual Studio and the Windows Driver Kit (WDK)
 
-WindowsPerf relies on `dll` files installed with Visual Studio (Community Edition or higher) and (optionally) installers from the Windows Driver Kit extension.
+WindowsPerf relies on `dll` files installed with Visual Studio, from the Community Edition or higher and, optionally, installers from the Windows Driver Kit extension.
 
-[Download the Windows Driver Kit (WDK)](https://learn.microsoft.com/en-us/windows-hardware/drivers/download-the-wdk) explains the WDK installation process.
+For information about the WDK installation process, see [Download the Windows Driver Kit (WDK)](https://learn.microsoft.com/en-us/windows-hardware/drivers/download-the-wdk).
 
 See also the [Visual Studio for Windows on Arm install guide](/install-guides/vs-woa/).
 
 ## Download WindowsPerf
 
-The latest release package `windowsperf-bin-<version>.zip` can be downloaded from the Arm GitHub repository:
+You can download the latest release package, `windowsperf-bin-<version>.zip` from the Arm GitHub repository:
 ```url
 https://github.com/arm-developer-tools/windowsperf/releases
 ```
@@ -70,17 +70,17 @@ tar -xmf windowsperf-bin-3.8.0.zip
 
 ## Install wperf driver
 
-You can install the kernel driver using supplied `wperf-devgen` installer.
+You can install the kernel driver using the supplied `wperf-devgen` installer.
 
 The [wperf-devgen](https://github.com/arm-developer-tools/windowsperf/blob/main/wperf-devgen/README.md) tool has been designated as the preferred installer and uninstaller for the WindowsPerf Kernel Driver in the latest release. This tool offers a simple process for managing the installation and removal of the driver.
 
 {{% notice  Note%}}
 You must install the driver as `Administrator`.
 {{% /notice %}}
 
-Open a `Windows Command Prompt` terminal with `Run as administrator` enabled.
+Open a **Windows Command Prompt** terminal with **Run as administrator** selected.
 
-Make sure you are in the `windowsperf-bin-<version>` directory. 
+Make sure you are in the `windowsperf-bin-<version>` directory:
 
 ```command
 cd windowsperf-bin-3.8.0
@@ -95,7 +95,7 @@ cd wperf-driver
 wperf-devgen install
 ```
 
-The output is similar to:
+The output should be similar to:
 
 ```output 
 Executing command: install.
@@ -108,7 +108,7 @@ Device installed successfully
 You can check everything is working by running the `wperf` executable.
 
 {{% notice  Note%}}
-Once the above driver is installed, you can use `wperf` without `Administrator` privileges.
+Once you have installed the driver, you can use `wperf` without `Administrator` privileges.
 {{% /notice %}}
 
 For example:
@@ -129,7 +129,7 @@ You see output similar to:
 ```
 ## Uninstall wperf driver
 
-You can uninstall (aka "remove") the kernel driver using supplied [wperf-devgen](#devgen_uninstall) uninstaller.
+You can uninstall (or *remove*) the kernel driver using supplied [wperf-devgen](#devgen_uninstall) uninstaller.
 
 {{% notice  Note%}}
 You must uninstall the driver as `Administrator`.
@@ -149,17 +149,17 @@ Executing command: uninstall.
 Uninstall requested.
 Root\WPERFDRIVER
 Device found
-Device uninstalled sucessfully
+Device uninstalled successfully
 ```
 
 ## Install WindowsPerf Virtual Studio Extension (optional) {#vs2022}
 
-WindowsPerf GUI (Graphical User Interface) project, a Visual Studio 2022 extension designed to bring a seamless UI experience to WindowsPerf, the command-line performance profiling tool for Windows on Arm. Extension is available on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=Arm.WindowsPerfGUI).
+WindowsPerf GUI (Graphical User Interface) is a Visual Studio 2022 extension designed to bring a seamless UI experience to WindowsPerf, the command-line performance profiling tool for Windows on Arm. It is available on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=Arm.WindowsPerfGUI).
 
-Install by opening `Extensions` menu, select `Manage Extensions` and click `Browse`. Type `WindowsPerf` to search for Arm WindowsPerf GUI extension. Click `Install`.
+Install by opening **Extensions** menu, click **Manage Extensions**, and click **Browse**. Type `WindowsPerf` to search for Arm WindowsPerf GUI extension. Click **Install**.
 
 {{% notice How to set up wperf.exe path in the extension%}}
-In order to set the path to the `wperf.exe` executable, go to `Tools -> Options -> WindowsPerf -> WindowsPerf Path` and set the absolute path to the wperf.exe executable and then on the Validate button.
+In order to set the path to the `wperf.exe` executable, go to **Tools** -> **Options** -> **WindowsPerf** -> **WindowsPerf Path** and set the absolute path to the wperf.exe executable and then click on the **Validate** button.
 {{% /notice %}}
 
 Also, visit WindowsPerf GUI project website on [GitHub](https://github.com/arm-developer-tools/windowsperf-vs-extension) for more details and latest updates.
@@ -168,9 +168,9 @@ Also, visit WindowsPerf GUI project website on [GitHub](https://github.com/arm-d
 
 In addition to the command-line tools, `WindowsPerf` is available on the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=Arm.windowsperf).
 
-Install by opening the `Extensions` view (`Ctrl`+`Shift`+`X`) and searching for `WindowsPerf`.　Click `Install`.
+Install by opening the **Extensions** view (Ctrl+Shift+X) and searching for `WindowsPerf`. Click **Install**.
 
-Open `Settings` (`Ctrl`+`,`) > `Extensions` > `WindowsPerf`, and specify the path to the `wperf` executable.
+Open **Settings** (Ctrl+,) > **Extensions** > **WindowsPerf**, and specify the path to the `wperf` executable.
 
 {{% notice Non-Windows on Arm host%}}
 You can only generate reports from a Windows on Arm device.
diff --git a/content/learning-paths/servers-and-cloud-computing/gh-runners/_index.md b/content/learning-paths/servers-and-cloud-computing/gh-runners/_index.md
@@ -1,24 +1,23 @@
 ---
-title: MLOps with Arm-hosted GitHub Runners
-draft: true
+title: Optimize MLOps with Arm-hosted GitHub Runners
+
 cascade:
-    draft: true
 
-minutes_to_complete: 30
+minutes_to_complete: 60
 
-who_is_this_for: This is an introductory topic for software developers interested in automation for machine learning (ML) tasks.
+who_is_this_for: This is an introductory topic for software developers interested in automation for Machine Learning (ML) tasks.
 
 learning_objectives:
     - Set up an Arm-hosted GitHub runner.
     - Train and test a PyTorch ML model with the German Traffic Sign Recognition Benchmark (GTSRB) dataset.
-    - Use PyTorch compiled with OpenBLAS and oneDNN with Arm Compute Library to compare the performance of a trained model.
-    - Containerize the model and push the container to DockerHub.
-    - Automate all the steps in the ML workflow using GitHub Actions.
+    - Compare the performance of two trained PyTorch ML models; one model compiled with OpenBLAS (Open Basic Linear Algebra Subprograms Library) and oneDNN (Deep Neural Network Library), and the other model compiled with Arm Compute Library (ACL).
+    - Containerize a ML model and push the container to DockerHub.
+    - Automate steps in an ML workflow using GitHub Actions.
 
 prerequisites:
     - A GitHub account with access to Arm-hosted GitHub runners.
     - A Docker Hub account for storing container images.
-    - Some familiarity with ML and continuous integration and deployment (CI/CD) concepts.
+    - Familiarity with the concepts of ML and continuous integration and deployment (CI/CD).
 
 author_primary: Pareena Verma, Annie Tallund
 
diff --git a/content/learning-paths/servers-and-cloud-computing/gh-runners/_review.md b/content/learning-paths/servers-and-cloud-computing/gh-runners/_review.md
@@ -8,29 +8,29 @@ review:
             - "No"
         correct_answer: 1
         explanation: >
-            Arm-hosted runners for use with GitHub Actions are available for Linux and Windows.
+            You can use Arm-hosted runners with GitHub Actions, and they are available for both Linux and Windows.
 
     - questions:
         question: >
-            What is the GTSRB dataset made up of?
+            What does the GTSRB dataset consist of?
         answers:
-            - Sound files of spoken German words
-            - Sound files of animal sounds
-            - Images of flower petals
-            - Images of German traffic signs
+            - Sound files of spoken German words.
+            - Sound files of animal sounds.
+            - Images of flower petals.
+            - Images of German traffic signs.
         correct_answer: 4
         explanation: >
-            GTSRB stands for German Traffic Signs Recognition Benchmark
+            GTSRB stands for German Traffic Signs Recognition Benchmark, and the dataset consists of images of German traffic signs.
 
     - questions:
         question: >
-            ACL is included in PyTorch.
+            Is ACL included in PyTorch?
         answers:
             - "True"
             - "False"
         correct_answer: 1
         explanation: >
-            While it is possible to use ACL stand-alone, the optimized kernels are built into PyTorch through the oneDNN backend.
+            While it is possible to use Arm Compute Library independently, the optimized kernels are built into PyTorch through the oneDNN backend.
 
 
 
diff --git a/content/learning-paths/servers-and-cloud-computing/gh-runners/background.md b/content/learning-paths/servers-and-cloud-computing/gh-runners/background.md
@@ -10,33 +10,43 @@ layout: learningpathall
 
 In this Learning Path, you will learn how to automate an MLOps workflow using Arm-hosted GitHub runners and GitHub Actions. 
 
-You will learn how to do the following tasks:
+You will perform the following tasks:
 - Train and test a neural network model with PyTorch.
 - Compare the model inference time using two different PyTorch backends.
 - Containerize the model and save it to DockerHub.
 - Deploy the container image and use API calls to access the model.
 
 ## GitHub Actions
 
-GitHub Actions is a platform that automates software development workflows, including continuous integration and continuous delivery. Every repository on GitHub has an `Actions` tab as shown below:
+GitHub Actions is a platform that automates software development workflows, which includes Continuous Integration and Continuous Delivery (CI/CD). 
+
+Every repository on GitHub has an **Actions** tab as shown below:
 
 ![#actions-gui](images/actions-gui.png)
 
 GitHub Actions runs workflow files to automate processes. Workflows run when specific events occur in a GitHub repository. 
 
 [YAML](https://yaml.org/) defines a workflow. 
 
-Workflows specify how a job is triggered, the running environment, and the commands to run. 
+Workflows specify:
+
+* How a job is triggered.
+* The running environment.
+* The commands to run. 
 
-The machine running workflows is called a _runner_.
+The machine running the workflows is called a _runner_.
 
 ## Arm-hosted GitHub runners
 
-Hosted GitHub runners are provided by GitHub so you don't need to setup and manage cloud infrastructure. Arm-hosted GitHub runners use the Arm architecture so you can build and test software without cross-compiling or instruction emulation.
+Hosted GitHub runners are provided by GitHub, so you do not need to set up and manage cloud infrastructure. Arm-hosted GitHub runners use the Arm architecture so you can build and test software without the necessity for cross-compiling or instruction emulation.
+
+Arm-hosted GitHub runners enable you to:
 
-Arm-hosted GitHub runners enable you to optimize your workflows, reduce cost, and improve energy consumption. 
+* Optimize your workflows.
+* Reduce cost.
+* Improve energy consumption. 
 
-Additionally, the Arm-hosted runners are preloaded with essential tools, making it easier for you to develop and test your applications.
+Additionally, the Arm-hosted runners are preloaded with essential tools, which makes it easier for to develop and test your applications.
 
 Arm-hosted runners are available for Linux and Windows. This Learning Path uses Linux.
 
@@ -66,22 +76,22 @@ jobs:
 
 ## Machine Learning Operations (MLOps)
 
-Machine learning use-cases have a need for reliable workflows to maintain performance and quality. 
+Machine learning use cases require reliable workflows to maintain both performance and quality of output. 
 
-There are many tasks that can be automated in the ML lifecycle. 
-- Model training and re-training
-- Model performance analysis
-- Data storage and processing
-- Model deployment
+There are tasks that can be automated in the ML lifecycle, such as: 
+- Model training and retraining.
+- Model performance analysis.
+- Data storage and processing.
+- Model deployment.
 
-Developer Operations (DevOps) refers to good practices for collaboration and automation, including CI/CD. The domain-specific needs for ML, combined with DevOps knowledge, creates the new term MLOps.
+Developer Operations (DevOps) refers to good practices for collaboration and automation, including CI/CD. MLOps describes the area of practice where the ML application development intersects with ML system deployment and operations.
 
 ## German Traffic Sign Recognition Benchmark (GTSRB)
 
 This Learning Path explains how to train and test a PyTorch model to perform traffic sign recognition. 
 
 You will learn how to use the GTSRB dataset to train the model. The dataset is free to use under the [Creative Commons](https://creativecommons.org/publicdomain/zero/1.0/) license. It contains thousands of images of traffic signs found in Germany. It has become a well-known resource to showcase ML applications. 
 
-The GTSRB dataset is also good for comparing performance and accuracy of different models and to compare and contrast different PyTorch backends. 
+The GTSRB dataset is also effective for comparing the performance and accuracy of both different models, and different PyTorch backends. 
 
-Continue to the next section to learn how to setup an end-to-end MLOps workflow using Arm-hosted GitHub runners.
+Continue to the next section to learn how to set up an end-to-end MLOps workflow using Arm-hosted GitHub runners.
diff --git a/content/learning-paths/servers-and-cloud-computing/gh-runners/compare-performance.md b/content/learning-paths/servers-and-cloud-computing/gh-runners/compare-performance.md
@@ -14,7 +14,7 @@ In this section, you will change the PyTorch backend being used to test the trai
 
 In the previous section, you used the PyTorch 2.3.0 Docker Image compiled with OpenBLAS from DockerHub to run your testing workflow. PyTorch can be run with other backends. You will now modify the testing workflow to use PyTorch 2.3.0 Docker Image compiled with OneDNN and the Arm Compute Library. 
 
-The [Arm Compute Library](https://github.com/ARM-software/ComputeLibrary) is a collection of low-level machine learning functions optimized for Arm's Cortex-A and Neoverse processors and Mali GPUs. Arm-hosted GitHub runners use Arm Neoverse CPUs, which make it possible to optimize your neural networks to take advantage of processor features. ACL implements kernels (also known as operators or layers), using specific instructions that run faster on AArch64.
+The [Arm Compute Library](https://github.com/ARM-software/ComputeLibrary) is a collection of low-level machine learning functions optimized for Arm's Cortex-A and Neoverse processors and Mali GPUs. Arm-hosted GitHub runners use Arm Neoverse CPUs, which make it possible to optimize your neural networks to take advantage of processor features. ACL implements kernels, which are also known as operators or layers, using specific instructions that run faster on AArch64.
 
 ACL is integrated into PyTorch through [oneDNN](https://github.com/oneapi-src/oneDNN), an open-source deep neural network library.
 
@@ -43,11 +43,11 @@ jobs:
 
 ### Run the test workflow
 
-Trigger the **Test Model** job again by clicking the `Run workflow` button on the `Actions` tab.
+Trigger the **Test Model** job again by clicking the **Run workflow** button on the **Actions** tab.
 
 The test workflow starts running. 
 
-Navigate to the workflow run on the `Actions` tab, click into the job, and expand the **Run testing script** step. 
+Navigate to the workflow run on the **Actions** tab, click into the job, and expand the **Run testing script** step. 
 
 You see a change in the performance results with OneDNN and ACL kernels being used. 
 
diff --git a/content/learning-paths/servers-and-cloud-computing/gh-runners/train-test.md b/content/learning-paths/servers-and-cloud-computing/gh-runners/train-test.md
diff --git a/content/learning-paths/servers-and-cloud-computing/gh-runners/workflows.md b/content/learning-paths/servers-and-cloud-computing/gh-runners/workflows.md
