First pass

Author: madeline-underwood

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

@@ -1,23 +1,19 @@
 ---
 title: Deploy SqueezeNet 1.0 INT8 model with ONNX Runtime on Azure Cobalt 100
 
-draft: true
-cascade:
-    draft: true
-    
+   
 minutes_to_complete: 60   
 
-who_is_this_for: This Learning Path introduces ONNX deployment on Microsoft Azure Cobalt 100 (Arm-based) virtual machines. It is designed for developers deploying ONNX-based applications on Arm-based machines.
+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.
-    - Deploy ONNX on the Ubuntu Pro virtual machine.
     - 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).
-    - Basic understanding of Python and machine learning concepts.
-    - Familiarity with [ONNX Runtime](https://onnxruntime.ai/docs/) and Azure cloud services.
+    - A [Microsoft Azure](https://azure.microsoft.com/) account with access to Cobalt 100 based instances (Dpsv6)
+    - Basic understanding of Python and machine learning concepts
+    - Familiarity with [ONNX Runtime](https://onnxruntime.ai/docs/) and Azure cloud services
 
 author: Pareena Verma    
 

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

@@ -8,14 +8,31 @@ 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. These include web and application servers, data analytics, open-source databases, caching systems, and more. Running at 3.4 GHz, the Cobalt 100 processor allocates a dedicated physical core for each vCPU, ensuring consistent and predictable performance. 
 
-To learn more about Cobalt 100, refer to 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).
+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).
 
 ## ONNX  
-ONNX (Open Neural Network Exchange) is an open-source format designed for representing machine learning models.  
-It provides interoperability between different deep learning frameworks, enabling models trained in one framework (such as PyTorch or TensorFlow) to be deployed and run in another.  
 
-ONNX models are serialized into a standardized format that can be executed by the ONNX Runtime, a high-performance inference engine optimized for CPU, GPU, and specialized hardware accelerators. This separation of model training and inference allows developers to build flexible, portable, and production-ready AI workflows.  
+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.
+
+To learn more, see the [ONNX official website](https://onnx.ai/) and the [ONNX Runtime documentation](https://onnxruntime.ai/docs/).
+
+## Summary
 
-ONNX is widely used in cloud, edge, and mobile environments to deliver efficient and scalable inference for deep learning models. Learn more from the [ONNX official website](https://onnx.ai/) and the [ONNX Runtime documentation](https://onnxruntime.ai/docs/).    
+Now that you understand the basics of Azure Cobalt 100 and ONNX, you're ready to start deploying and benchmarking ONNX models on Arm-based Azure infrastructure. If this is your first time working with these technologies, don't worry, each step in this Learning Path is designed to help you succeed.

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

@@ -52,3 +52,7 @@ Single inference latency(0.00260 sec): This is the time required for the model t
 Subsequent inferences are usually faster due to caching and optimized execution.
 
 This demonstrates that the setup is fully working, and ONNX Runtime efficiently executes quantized models on Arm64. 
+
+Great job! You've completed your first ONNX Runtime inference on Arm-based Azure infrastructure. This baseline test confirms your environment is set up correctly and ready for more advanced benchmarking.
+
+Next, you'll use a dedicated benchmarking tool to capture more detailed performance statistics and further optimize your deployment.

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

@@ -6,14 +6,20 @@ weight: 6
 layout: learningpathall
 ---
 
-Now that you have validated ONNX Runtime with Python-based timing (e.g., 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 helps evaluate the ONNX Runtime efficiency on Azure Arm64-based Cobalt 100 instances and other x86_64 instances. architectures.
+
+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.
+
+You are ready to run benchmarks — a key skill for optimizing real-world deployments.
+
 
 ## Run the performance tests using onnxruntime_perf_test
-The `onnxruntime_perf_test` is a performance benchmarking tool included in the ONNX Runtime source code. It is used to measure the inference performance of ONNX models and supports multiple execution providers (like CPU, GPU, or other execution providers). on Arm64 VMs, CPU execution is the focus.
+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
-Before building or running `onnxruntime_perf_test`, you will 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.
+### 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
 sudo apt update
@@ -29,35 +35,48 @@ You should see output similar to:
 ```output
 libprotoc 3.21.12
 ```
-### Build ONNX Runtime from Source:
+### Build ONNX Runtime from source
 
-The benchmarking tool `onnxruntime_perf_test`, isn’t available as a pre-built binary for any platform. So, you will have to build it from the source, which is expected to take around 40 minutes. 
+The benchmarking tool `onnxruntime_perf_test` isn’t available as a pre-built binary for any platform, so you will need to build it from source. This process can take up to 40 minutes.
 
-Clone onnxruntime repo:
+Clone the ONNX Runtime repository:
 ```console
 git clone --recursive https://github.com/microsoft/onnxruntime 
 cd onnxruntime
 ```
+
 Now, build the benchmark tool:
 
 ```console
 ./build.sh --config Release --build_dir build/Linux --build_shared_lib --parallel --build --update --skip_tests 
 ```
-You should see the executable at:
+If the build completes successfully, you should see the executable at:
 ```output
 ./build/Linux/Release/onnxruntime_perf_test
 ```
 
+
 ### Run the benchmark
 Now that you have built the benchmarking tool, you can run inference benchmarks on the SqueezeNet INT8 model:
 
 ```console
 ./build/Linux/Release/onnxruntime_perf_test -e cpu -r 100 -m times -s -Z -I ../squeezenet-int8.onnx
 ```
+
 Breakdown of the flags:
-  -e cpu → Use the CPU execution provider.
-  -r 100 → Run 100 inference passes for statistical reliability.
-  -m times → Run in “repeat N times” mode. Useful for latency-focused measurement.
+
+- `-e cpu`: Use the CPU execution provider.
+- `-r 100`: Run 100 inference passes for statistical reliability.
+- `-m times`: Run in “repeat N times” mode for latency-focused measurement.
+- `-s`: Print summary statistics after the run.
+- `-Z`: Disable memory arena for more consistent timing.
+- `-I ../squeezenet-int8.onnx`: Path to your ONNX model file.
+
+You should see output with latency and throughput statistics. If you encounter build errors, check that you have enough memory (at least 8 GB recommended) and all dependencies are installed. For missing dependencies, review the installation steps above.
+
+If the benchmark runs successfully, you are ready to analyze and optimize your ONNX model performance on Arm-based Azure infrastructure.
+
+Well done! You have completed a full benchmarking workflow. Continue to the next section to explore further optimizations or advanced deployment scenarios.
   -s → Show detailed per-run statistics (latency distribution).
   -Z → Disable intra-op thread spinning. Reduces CPU waste when idle between runs, especially on high-core systems like Cobalt 100.
   -I → Input the ONNX model path directly, skipping pre-generated test data.

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

@@ -28,29 +28,31 @@ Creating a virtual machine based on Azure Cobalt 100 is no different from creati
 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.
 
-![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance.png "Figure 1: Select the D-Series v6 family of virtual machines")
+![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.
 
-![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance1.png "Figure 2: Allow inbound port rules")
+![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:
 
-![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/ubuntu-pro.png "Figure 3: Review and Create an Azure Cobalt 100 Arm64 VM")
+![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.
 
-![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/instance4.png "Figure 4: Download Private key and Create Resources")
+![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 no time. You can SSH into the virtual machine using the private key, along with the Public IP details.
+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.
 
-![Azure portal VM creation — Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/final-vm.png "Figure 5: VM deployment confirmation in Azure portal")
+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.
 
-{{% notice Note %}}
+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.
 
-To learn more about Arm-based virtual machine in Azure, refer to “Getting Started with Microsoft Azure” in [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure).
+![Azure portal VM creation - Azure Cobalt 100 Arm64 virtual machine (D4ps_v6) alt-text#center](images/final-vm.png "VM deployment confirmation in Azure portal")
 
+{{% notice Note %}}
+For further information or alternative setup options, see “Getting Started with Microsoft Azure” in [Get started with Arm-based cloud instances](/learning-paths/servers-and-cloud-computing/csp/azure).
 {{% /notice %}}

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

@@ -10,12 +10,14 @@ 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.
 
-### Install Python and Virtual Environment:
+
+### Install Python and virtual environment
 
 ```console
 sudo apt update
 sudo apt install -y python3 python3-pip python3-virtualenv python3-venv
 ```
+
 Create and activate a virtual environment:
 
 ```console
@@ -24,28 +26,35 @@ source onnx-env/bin/activate
 ```
 {{% notice Note %}}Using a virtual environment isolates ONNX and its dependencies to avoid system conflicts.{{% /notice %}}
 
-### Install ONNX and Required Libraries:
+Once your environment is active, you're ready to install the required libraries.
+
+
+### Install ONNX and required libraries
 
 Upgrade pip and install ONNX with its runtime and supporting libraries:
 ```console
 pip install --upgrade pip
 pip install onnx onnxruntime fastapi uvicorn numpy
 ```
-This installs ONNX libraries along with FastAPI (web serving) and NumPy (for input tensor generation).
+This installs ONNX libraries, FastAPI (for web serving, if you want to deploy models as an API), Uvicorn (ASGI server for FastAPI), and NumPy (for input tensor generation).
+
+If you encounter errors during installation, check your internet connection and ensure you are using the activated virtual environment. For missing dependencies, try updating pip or installing system packages as needed.
+
+After installation, you're ready to validate your setup.
 
-### Validate ONNX and ONNX Runtime:
-Once the libraries are installed, you should verify that both ONNX and ONNX Runtime are correctly set up on your VM.
+
+### 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:
 ```python
 import onnx  
 import onnxruntime 
 
-print("ONNX version:", onnx.__version__)  
-print("ONNX Runtime version:", onnxruntime.__version__)  
+print("ONNX version:", onnx.__version__)
+print("ONNX Runtime version:", onnxruntime.__version__)
 ```
-Run the script: 
-
+Run the script:
 ```console
 python3 version.py
 ```
@@ -54,10 +63,15 @@ You should see output similar to:
 ONNX version: 1.19.0
 ONNX Runtime version: 1.23.0
 ```
-With this validation, 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.
+If you see version numbers for both ONNX and ONNX Runtime, your environment is ready. If you get an ImportError, double-check that your virtual environment is activated and the libraries are installed.
+
+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
+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.
 
-### 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