Refine documentation for ONNX deployment on Azure Cobalt 100, enhancing clarity and structure across multiple sections.

Author: madeline-underwood

content/learning-paths/servers-and-cloud-computing/onnx-on-azure/_index.md

@@ -7,8 +7,8 @@ minutes_to_complete: 60
 who_is_this_for: This Learning Path is for developers deploying ONNX-based applications on Arm-based machines.
 
 learning_objectives:
-    - Provision an Azure Arm64 virtual machine using Azure console, with Ubuntu Pro 24.04 LTS as the base image.
-    - Perform ONNX baseline testing and benchmarking on Arm64 virtual machines.
+    - Provision an Azure Arm64 virtual machine using Azure console, with Ubuntu Pro 24.04 LTS as the base image
+    - Perform ONNX baseline testing and benchmarking on Arm64 virtual machines
 
 prerequisites:
     - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6)

content/learning-paths/servers-and-cloud-computing/onnx-on-azure/background.md

@@ -9,27 +9,29 @@ layout: "learningpathall"
 ## Azure Cobalt 100 Arm-based processor
 
 
-Azure’s Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor, the Cobalt 100. Designed entirely by Microsoft and based on Arm’s Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads. You can use Cobalt 100 for:
+Azure’s Cobalt 100 is built on Microsoft's first-generation, in-house Arm-based processor, the Cobalt 100. Designed entirely by Microsoft and based on Arm’s Neoverse N2 architecture, this 64-bit CPU delivers improved performance and energy efficiency across a broad spectrum of cloud-native, scale-out Linux workloads. 
+
+You can use Cobalt 100 for:
 
 - Web and application servers
 - Data analytics
 - Open-source databases
 - Caching systems
 - Many other scale-out workloads
 
-Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance.
-
-You can learn more about Cobalt 100 in the blog [Announcing the preview of new Azure virtual machine based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
+Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. You can learn more about Cobalt 100 in the Microsoft blog [Announcing the preview of new Azure virtual machine based on the Azure Cobalt 100 processor](https://techcommunity.microsoft.com/blog/azurecompute/announcing-the-preview-of-new-azure-vms-based-on-the-azure-cobalt-100-processor/4146353).
 
 ## ONNX  
 
-ONNX (Open Neural Network Exchange) is an open-source format designed for representing machine learning models. You can use ONNX to:
+ONNX (Open Neural Network Exchange) is an open-source format designed for representing machine learning models. 
+
+You can use ONNX to:
 
 - Move models between different deep learning frameworks, such as PyTorch and TensorFlow
 - Deploy models trained in one framework to run in another
 - Build flexible, portable, and production-ready AI workflows
 
-ONNX models are serialized into a standardized format that you can execute with ONNX Runtime—a high-performance inference engine optimized for CPU, GPU, and specialized hardware accelerators. This separation of model training and inference lets you deploy models efficiently across cloud, edge, and mobile environments.
+ONNX models are serialized into a standardized format that you can execute with ONNX Runtime - a high-performance inference engine optimized for CPU, GPU, and specialized hardware accelerators. This separation of model training and inference lets you deploy models efficiently across cloud, edge, and mobile environments.
 
 To learn more, see the [ONNX official website](https://onnx.ai/) and the [ONNX Runtime documentation](https://onnxruntime.ai/docs/).
 

content/learning-paths/servers-and-cloud-computing/onnx-on-azure/baseline.md

@@ -37,16 +37,18 @@ You should see output similar to:
 ```output
 Inference time: 0.0026061534881591797
 ```
-{{% notice Note %}}Inference time is the amount of time it takes for a trained machine learning model to make a prediction (i.e., produce output) after receiving input data. 
-input tensor of shape (1, 3, 224, 224): 
-- 1: batch size 
-- 3: color channels (RGB) 
+{{% notice Note %}}
+Inference time is the amount of time it takes for a trained machine learning model to make a prediction (produce output) after receiving input data.
+
+The input tensor has the shape `(1, 3, 224, 224)`, which means:
+- 1: batch size (number of images processed at once)
+- 3: color channels (RGB)
 - 224 x 224: image resolution (common for models like SqueezeNet)
 {{% /notice %}}
 
 This indicates the model successfully executed a single forward pass through the SqueezeNet INT8 ONNX model and returned results.
 
-#### Output summary:
+## Output summary:
 
 Single inference latency(0.00260 sec): This is the time required for the model to process one input image and produce an output. The first run includes graph loading, memory allocation, and model initialization overhead.
 Subsequent inferences are usually faster due to caching and optimized execution.

content/learning-paths/servers-and-cloud-computing/onnx-on-azure/benchmarking.md

@@ -1,12 +1,12 @@
 ---
-title: Benchmarking via onnxruntime_perf_test
+title: Benchmark ONNX runtime performance with onnxruntime_perf_test
 weight: 6
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-
+## Benchmark ONNX model inference on Azure Cobalt 100
 Now that you have validated ONNX Runtime with Python-based timing (for example, the SqueezeNet baseline test), you can move to using a dedicated benchmarking utility called `onnxruntime_perf_test`. This tool is designed for systematic performance evaluation of ONNX models, allowing you to capture more detailed statistics than simple Python timing.
 
 This approach helps you evaluate ONNX Runtime efficiency on Azure Arm64-based Cobalt 100 instances and compare results with other architectures if needed.
@@ -18,7 +18,7 @@ You are ready to run benchmarks — a key skill for optimizing real-world deploy
 The `onnxruntime_perf_test` tool is included in the ONNX Runtime source code. You can use it to measure the inference performance of ONNX models and compare different execution providers (such as CPU or GPU). On Arm64 VMs, CPU execution is the focus.
 
 
-### Install required build tools
+## Install required build tools
 Before building or running `onnxruntime_perf_test`, you need to install a set of development tools and libraries. These packages are required for compiling ONNX Runtime and handling model serialization via Protocol Buffers.
 
 ```console
@@ -56,7 +56,7 @@ If the build completes successfully, you should see the executable at:
 ```
 
 
-### Run the benchmark
+## Run the benchmark
 Now that you have built the benchmarking tool, you can run inference benchmarks on the SqueezeNet INT8 model:
 
 ```console
@@ -105,17 +105,17 @@ P95 Latency: 0.00187393 s
 P99 Latency: 0.00190312 s
 P999 Latency: 0.00190312 s
 ```
-### Benchmark Metrics Explained  
+## Benchmark Metrics Explained  
 
-  * Average Inference Time: The mean time taken to process a single inference request across all runs. Lower values indicate faster model execution.  
-  * Throughput: The number of inference requests processed per second. Higher throughput reflects the model’s ability to handle larger workloads efficiently.  
-  * CPU Utilization: The percentage of CPU resources used during inference. A value close to 100% indicates full CPU usage, which is expected during performance benchmarking.  
-  * Peak Memory Usage: The maximum amount of system memory (RAM) consumed during inference. Lower memory usage is beneficial for resource-constrained environments. 
-  * P50 Latency (Median Latency): The time below which 50% of inference requests complete. Represents typical latency under normal load.   
-  * Latency Consistency: Describes the stability of latency values across all runs. "Consistent" indicates predictable inference performance with minimal jitter.  
+  * Average inference time: the mean time taken to process a single inference request across all runs. Lower values indicate faster model execution.  
+  * Throughput: the number of inference requests processed per second. Higher throughput reflects the model’s ability to handle larger workloads efficiently.  
+  * CPU utilization: the percentage of CPU resources used during inference. A value close to 100% indicates full CPU usage, which is expected during performance benchmarking.  
+  * Peak Memory Usage: the maximum amount of system memory (RAM) consumed during inference. Lower memory usage is beneficial for resource-constrained environments. 
+  * P50 Latency (Median Latency): the time below which 50% of inference requests complete. Represents typical latency under normal load.   
+  * Latency Consistency: describes the stability of latency values across all runs. "Consistent" indicates predictable inference performance with minimal jitter.  
 
-### Benchmark summary on Arm64:
-Here is a summary of benchmark results collected on an Arm64 **D4ps_v6 Ubuntu Pro 24.04 LTS virtual machine**.
+## Benchmark summary on Arm64:
+Here is a summary of benchmark results collected on an Arm64 D4ps_v6 Ubuntu Pro 24.04 LTS virtual machine.
 
 | **Metric**                | **Value** |
 |----------------------------|-------------------------------|
@@ -132,12 +132,9 @@ Here is a summary of benchmark results collected on an Arm64 **D4ps_v6 Ubuntu Pr
 | **Latency Consistency**    | Consistent                   |
 
 
-### Highlights from Benchmarking on Azure Cobalt 100 Arm64 VMs
+## Highlights from Benchmarking on Azure Cobalt 100 Arm64 VMs
+
 
-The results on Arm64 virtual machines demonstrate:
-- Low-Latency Inference: Achieved consistent average inference times of ~1.86 ms on Arm64.  
-- Strong and Stable Throughput: Sustained throughput of over 538 inferences/sec using the `squeezenet-int8.onnx` model on D4ps_v6 instances.  
-- Lightweight Resource Footprint: Peak memory usage stayed below 37 MB, with CPU utilization around 96%, ideal for efficient edge or cloud inference.  
-- Consistent Performance: P50, P95, and Max latency remained tightly bound, showcasing reliable performance on Azure Cobalt 100 Arm-based infrastructure.
+These results on Arm64 virtual machines demonstrate low-latency inference, with consistent average inference times of approximately 1.86 ms. Throughput remains strong and stable, sustaining over 538 inferences per second using the `squeezenet-int8.onnx` model on D4ps_v6 instances. The resource footprint is lightweight, as peak memory usage stays below 37 MB and CPU utilization is around 96%, making this setup ideal for efficient edge or cloud inference. Performance is also consistent, with P50, P95, and maximum latency values tightly grouped, showcasing reliable results on Azure Cobalt 100 Arm-based infrastructure.
 
 You have now successfully benchmarked inference time of ONNX models on an Azure Cobalt 100 Arm64 virtual machine.

content/learning-paths/servers-and-cloud-computing/onnx-on-azure/create-instance.md

@@ -20,34 +20,36 @@ You will focus on the general-purpose virtual machines in the D-series. For furt
 
 While the steps to create this instance are included here for convenience, for further information on setting up Cobalt on Azure, see [Deploy a Cobalt 100 virtual machine on Azure Learning Path](/learning-paths/servers-and-cloud-computing/cobalt/).
 
-#### Create an Arm-based Azure Virtual Machine 
+## Create an Arm-based Azure Virtual Machine 
 
-Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other virtual machine in Azure. To create an Azure virtual machine, launch the Azure portal and navigate to "Virtual Machines".
-1. Select "Create", and click on "Virtual Machine" from the drop-down list.
-2. Inside the "Basic" tab, fill in the Instance details such as "Virtual machine name" and "Region".
-3. Choose the image for your virtual machine (for example, Ubuntu Pro 24.04 LTS) and select “Arm64” as the VM architecture.
-4. In the “Size” field, click on “See all sizes” and select the D-Series v6 family of virtual machines. Select “D4ps_v6” from the list.
+
+Creating a virtual machine based on Azure Cobalt 100 is no different from creating any other virtual machine in Azure. To create an Azure virtual machine, launch the Azure portal and navigate to **Virtual Machines**.
+
+- Select **Create**, and click on **Virtual Machine** from the drop-down list.
+- Inside the **Basic** tab, fill in the Instance details such as **Virtual machine name** and **Region**.
+- Choose the image for your virtual machine (for example, Ubuntu Pro 24.04 LTS) and select **Arm64** as the VM architecture.
+- In the **Size** field, click on **See all sizes** and select the D-Series v6 family of virtual machines. Select **D4ps_v6** from the list.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance.png "Select the D-Series v6 family of virtual machines")
 
-5. Select "SSH public key" as an Authentication type. Azure will automatically generate an SSH key pair for you and allow you to store it for future use. It is a fast, simple, and secure way to connect to your virtual machine.
-6. Fill in the Administrator username for your VM.
-7. Select "Generate new key pair", and select "RSA SSH Format" as the SSH Key Type. RSA could offer better security with keys longer than 3072 bits. Give a Key pair name to your SSH key.
-8. In the "Inbound port rules", select HTTP (80) and SSH (22) as the inbound ports.
+- Select **SSH public key** as an Authentication type. Azure will automatically generate an SSH key pair for you and allow you to store it for future use. It is a fast, simple, and secure way to connect to your virtual machine.
+- Fill in the **Administrator username** for your VM.
+- Select **Generate new key pair**, and select **RSA SSH Format** as the SSH Key Type. RSA could offer better security with keys longer than 3072 bits. Give a **Key pair name** to your SSH key.
+- In the **Inbound port rules**, select **HTTP (80)** and **SSH (22)** as the inbound ports.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance1.png "Allow inbound port rules")
 
-9. Click on the "Review + Create" tab and review the configuration for your virtual machine. It should look like the following:
+- Click on the **Review + Create** tab and review the configuration for your virtual machine. It should look like the following:
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/ubuntu-pro.png "Review and Create an Azure Cobalt 100 Arm64 VM")
 
-10. Finally, when you are confident about your selection, click on the "Create" button, and click on the "Download Private key and Create Resources" button.
+- When you are confident about your selection, click on the **Create** button, and click on the **Download Private key and Create Resources** button.
 
 ![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance4.png "Download Private key and Create Resources")
 
-11. Your virtual machine should be ready and running within a few minutes. You can SSH into the virtual machine using the private key, along with the Public IP details.
+- Your virtual machine should be ready and running within a few minutes. You can SSH into the virtual machine using the private key, along with the Public IP details.
 
-You should see your VM listed as "Running" in the Azure portal. If you have trouble connecting, double-check your SSH key and ensure the correct ports are open. If the VM creation fails, check your Azure quota, region availability, or try a different VM size.
+You should see your VM listed as **Running** in the Azure portal. If you have trouble connecting, double-check your SSH key and ensure the correct ports are open. If the VM creation fails, check your Azure quota, region availability, or try a different VM size.
 
 Nice work! You have successfully provisioned an Arm-based Azure Cobalt 100 virtual machine. This environment is now ready for ONNX Runtime installation and benchmarking in the next steps.
 

content/learning-paths/servers-and-cloud-computing/onnx-on-azure/deploy.md

@@ -8,14 +8,16 @@ layout: learningpathall
 
 
 ## ONNX Installation on Azure Ubuntu Pro 24.04 LTS
-To work with ONNX models on Azure, you will need a clean Python environment with the required packages. The following steps install Python, set up a virtual environment, and prepare for ONNX model execution using ONNX Runtime.
+To work with ONNX models on Azure, you will need a clean Python environment with the required packages. The following steps show you how to install Python, set up a virtual environment, and prepare for ONNX model execution using ONNX Runtime.
 
 
-### Install Python and virtual environment
+## Install Python and virtual environment
+
+To get started, update your package list and install Python 3 along with the tools needed to create a virtual environment:
 
 ```console
 sudo apt update
-sudo apt install -y python3 python3-pip python3-virtualenv python3-venv
+sudo apt install -y python3 python3-pip python3-venv
 ```
 
 Create and activate a virtual environment:
@@ -29,7 +31,7 @@ source onnx-env/bin/activate
 Once your environment is active, you're ready to install the required libraries.
 
 
-### Install ONNX and required libraries
+## Install ONNX and required libraries
 
 Upgrade pip and install ONNX with its runtime and supporting libraries:
 ```console
@@ -43,7 +45,7 @@ If you encounter errors during installation, check your internet connection and
 After installation, you're ready to validate your setup.
 
 
-### Validate ONNX and ONNX Runtime
+## Validate ONNX and ONNX Runtime
 Once the libraries are installed, verify that both ONNX and ONNX Runtime are correctly set up on your VM.
 
 Create a file named `version.py` with the following code:
@@ -68,15 +70,15 @@ If you see version numbers for both ONNX and ONNX Runtime, your environment is r
 Great job! You have confirmed that ONNX and ONNX Runtime are installed and ready on your Azure Cobalt 100 VM. This is the foundation for running inference workloads and serving ONNX models.
 
 
-### Download and validate ONNX model: SqueezeNet
+## Download and validate ONNX model: SqueezeNet
 SqueezeNet is a lightweight convolutional neural network (CNN) architecture designed to provide accuracy close to AlexNet while using 50x fewer parameters and a much smaller model size. This makes it well-suited for benchmarking ONNX Runtime.
 
 Now that your environment is set up and validated, you're ready to download and test the SqueezeNet model in the next step.
 Download the quantized model:
 ```console
 wget https://github.com/onnx/models/raw/main/validated/vision/classification/squeezenet/model/squeezenet1.0-12-int8.onnx -O squeezenet-int8.onnx
 ```
-#### Validate the model: 
+## Validate the model: 
 
 After downloading the SqueezeNet ONNX model, the next step is to confirm that it is structurally valid and compliant with the ONNX specification. ONNX provides a built-in checker utility that verifies the graph, operators, and metadata.
 Create a file named `validation.py` with the following code: