# Deploy SqueezeNet 1.0 INT8 model with ONNX Runtime on Azure Cobalt 100

## In this learning path

- [Introduction](https://learn.arm.com/learning-paths/servers-and-cloud-computing/onnx-on-azure/)
- [Overview](https://learn.arm.com/learning-paths/servers-and-cloud-computing/onnx-on-azure/background/)
- [Create an Arm-based Azure Cobalt 100 virtual machine](https://learn.arm.com/learning-paths/servers-and-cloud-computing/onnx-on-azure/create-instance/)
- [ONNX Installation](https://learn.arm.com/learning-paths/servers-and-cloud-computing/onnx-on-azure/deploy/)
- [Baseline Testing](https://learn.arm.com/learning-paths/servers-and-cloud-computing/onnx-on-azure/baseline/)
- [Benchmark ONNX runtime performance with onnxruntime_perf_test](https://learn.arm.com/learning-paths/servers-and-cloud-computing/onnx-on-azure/benchmarking/)
- [Next Steps](https://learn.arm.com/learning-paths/servers-and-cloud-computing/onnx-on-azure/_next-steps/)

## About this Learning Path

|  |  |
| --- | --- |
| Skill level: | Introductory |
| Reading time: | 1 hr |
| Last updated: | 02 Oct 2026 |

|  |  |
| --- | --- |
| Author: | Pareena Verma , Arm<br>[GitHub](https://github.com/pareenaverma)<br>[LinkedIn](https://linkedin.com/in/pareena-verma-7853607) |
| Arm IP: | [Neoverse](https://support.arm.com/?tab=compute-ip&Product%20Type=Infrastructure%20Processors) |
| Tags: | [ML](https://learn.arm.com/tag/ml) [Microsoft Azure Cobalt](https://learn.arm.com/tag/microsoft-azure-cobalt) [Linux](https://learn.arm.com/tag/linux) [Python](https://learn.arm.com/tag/python) [ONNX Runtime](https://learn.arm.com/tag/onnx-runtime) |

### Who is this for?
This Learning Path is for developers deploying ONNX-based applications on Arm-based machines.

### What will you learn?
After completing this Learning Path, you'll be able to perform the following tasks:
- Provision an Azure Arm64 virtual machine (VM) using Azure console, with Ubuntu Pro 24.04 LTS as the base image.
- Perform ONNX baseline testing and benchmarking on Arm64 VMs.

### Prerequisites
Before starting, you'll need the following 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

### Summary
You’ll run and benchmark SqueezeNet 1.0 INT8 inference with ONNX Runtime on an Arm-based Azure VM powered by Cobalt 100. First, you’ll provision an Ubuntu Pro 24.04 LTS Dpsv6 VM and prepare a Python environment. You’ll then run a baseline script to validate inference and record latency. Finally, you’ll use `onnxruntime_perf_test` to collect more detailed performance statistics on the Arm64 system.

### Frequently asked questions

**Which Azure VM size and OS image should I use?**

Select `D4ps_v6` from the Dpsv6 series powered by Azure Cobalt 100. Use the Ubuntu Pro 24.04 LTS image and select **Arm64** as the VM architecture.

**What do I need in place before running the baseline latency test?**

Activate your Python virtual environment, have the `baseline.py` script ready, and ensure that the SqueezeNet INT8 model file is available as `squeezenet-int8.onnx`. Place the model in the same working directory as the script or provide its full path.

**How do I know the baseline test worked correctly?**

The script completes without errors and reports a timing result for a single inference through the SqueezeNet INT8 model. Successful execution confirms that ONNX Runtime is functioning on the VM.

**When should I use onnxruntime_perf_test, and what output should I expect?**

Use `onnxruntime_perf_test` after validating the Python baseline to capture more detailed performance statistics. Expect a summary of inference metrics that you can use to evaluate ONNX Runtime efficiency on the Azure Arm64 instance.

**Does the baseline script use a real image as input?**

No. The script uses data in `float32` with shape `(1, 3, 224, 224)`. This represents one input with three color channels and dimensions of 224 by 224 pixels. You’ll use this synthetic input to measure inference latency.