Refactor documentation for ONNX Runtime learning path: enhance clarity, improve structure, and correct formatting in multiple markdown files.

Author: madeline-underwood

content/learning-paths/mobile-graphics-and-gaming/performance_onnxruntime_kleidiai_sme2/build_ort.md

@@ -8,13 +8,13 @@ layout: learningpathall
 
 ## Build ONNX Runtime with KleidiAI and SME2 for Android
 
-To run this on an Android device, cross-compile ORT using the Android NDK.
+To run this on an Android device, you need to cross-compile ONNX Runtime using the Android NDK.
 
-Prerequisites:
--	Android NDK: Version r26b or newer (r27+ recommended for latest SME2 toolchain support).
--	CMake & Ninja: Ensure these are in your system PATH.
+Before you begin, verify that you have:
+- Android NDK version r26b or newer (r27 or later is recommended for the latest SME2 toolchain support)
+- CMake and Ninja installed and available in your system PATH
 
-### Build onnxruntime
+## Build onnxruntime
 
 First, clone the [ONNX Runtime](https://github.com/microsoft/onnxruntime). This Learning Path uses version `v1.23.2`:
 ```bash
@@ -28,9 +28,10 @@ Build ONNX Runtime with KleidiAI support enabled. The build script configures cr
 ./build.sh --android --android_sdk_path $ANDROID_NDK_HOME --android_ndk_path $ANDROID_NDK_HOME --android_abi arm64-v8a --android_api 27 --config RelWithDebInfo --build_shared_lib --cmake_extra_defines onnxruntime_USE_KLEIDIAI=ON --cmake_generator Ninja --parallel
 ```
 
-Notes:
+{{% notice Note %}}
 - The flag `onnxruntime_USE_KLEIDIAI=ON` triggers the inclusion of Arm KleidiAI kernels into the MLAS library.
-- The build directory is `build/` by default. This can be overriden with the `--build_dir <path_to_your_build_directory>` commande line option to `build.sh`
+- The build directory is `build/` by default. This can be overridden with the `--build_dir <path_to_your_build_directory>` command line option to `build.sh`.
+{{% /notice %}}
 
 ## Profile model performance with onnxruntime_perf_test
 
@@ -54,16 +55,18 @@ The `onnxruntime_perf_test` tool simulates inference and gathers statistics. Run
 # Execute on the device
 adb shell "/data/local/tmp/onnxruntime_perf_test -e cpu -m times  -r 20 -s -Z  -x 1 /data/local/tmp/<your_model>/<your_model>.onnx"
 ```
+### Command options explained
 
-The command example set the arguments of the application as,
--	`-e cpu` specifies the provider as cpu provider
--	`-m times` specifies the test mode as “times”
--	`-r 20` specifies the repeated times as 20
--	`-Z` disallows thread from spinning during runs to reduce cpu usage
--	`-s` shows statistics result
--	`-x 1` sets the number of threads used to parallelize the execution within nodes as 1
+The benchmark command uses several flags to control execution:
 
-You can try other arguments setting if you would like to.
+- `-e cpu`: Use the CPU execution provider
+- `-m times`: Run in timing mode to measure latency
+- `-r 20`: Repeat the test 20 times for consistent results
+- `-Z`: Prevent thread spinning to reduce CPU usage
+- `-s`: Display statistics after the run
+- `-x 1`: Use a single thread for parallel execution within nodes
+
+You can adjust these settings based on your performance testing needs.
 
 ## Deep dive into operator profiling
 

content/learning-paths/mobile-graphics-and-gaming/performance_onnxruntime_kleidiai_sme2/kleidiai_integration.md

@@ -7,9 +7,10 @@ layout: learningpathall
 ---
 
 ## Integration of KleidiAI to ONNX Runtime MLAS
-ONNX Runtime builds with KleidiAI support:
-1.	Detection: At runtime, MLAS checks the CPU capabilities for SME2 support.
-2.	Dispatch: If SME2 is detected, MLAS overrides its default kernels. For example, a Gemm (General Matrix Multiplication) operation that would normally use standard vector instructions (such as NEON) dispatches to a KleidiAI SME2 micro-kernel.
+ONNX Runtime automatically detects and uses KleidiAI when SME2 support is available:
+
+- Detection: MLAS checks the CPU capabilities for SME2 support at runtime.
+- Dispatch: when SME2 is detected, MLAS replaces its default kernels with KleidiAI micro-kernels. For example, a Gemm operation that normally uses NEON instructions dispatches to a KleidiAI SME2 micro-kernel instead.
 
 Currently, KleidiAI in MLAS provides `ArmKleidiAI::MlasConv`, `ArmKleidiAI::MlasGemmBatch`, and `ArmKleidiAI::MlasDynamicQGemmBatch` kernels.
 
@@ -18,7 +19,7 @@ ORT dispatches 2D fp32 (32-bit floating point) convolution operators with batch_
 
 For example, the figure below shows a (7,7) Conv node.
 
-![Diagram showing a 7x7 convolution node with input tensor of size 112x112x64, filter size 7x7x64, and output tensor size 56x56x64 with stride 2#center](images/conv_nodes_7x7.jpg "An example of (7,7) Conv node")
+![Diagram showing a 7x7 convolution node with input tensor of size 112x112x64, filter size 7x7x64, and output tensor size 56x56x64 with stride 2#center](images/conv_nodes_7x7.jpg "An example of a (7,7) Conv node")
 
 `ArmKleidiAI::MlasConv` kernel uses KleidiAI's indirect matrix multiplication (imatmul) micro kernel to accelerate the convolution.
 
@@ -50,7 +51,7 @@ This kernel performs a batched fp32 matrix multiplication (GEMM or GemV) operati
 
 For example, the figure below shows a (1,1) Conv node.
 
-![Diagram showing a 1x1 convolution node with input tensor of size 56x56x64, filter size 1x1x64, and output tensor size 56x56x256 fused with BatchNormalization and Relu operations alt-txt#center](images/conv_nodes_1x1.jpg "An example of (1,1) FusedConv node")
+![Diagram showing a 1x1 convolution node with input tensor of size 56x56x64, filter size 1x1x64, and output tensor size 56x56x256 fused with BatchNormalization and Relu operations alt-txt#center](images/conv_nodes_1x1.jpg "An example of a (1,1) FusedConv node")
 
 The function calls of fp32 Conv operators with (1,1) filter kernels are shown below.
 
@@ -79,7 +80,7 @@ onnxruntime::InferenceSession::Run
 
 For example, the figure below shows a Gemm node.
 
-![Diagram showing a Gemm (General Matrix Multiplication) node with input matrices A and B, performing matrix multiplication with optional bias addition alt-txt#center](images/gemm_node.jpg "An example of Gemm node")
+![Diagram showing a Gemm (General Matrix Multiplication) node with input matrices A and B, performing matrix multiplication with optional bias addition alt-txt#center](images/gemm_node.jpg "An example of a Gemm node")
 
 The function calls of fp32 Gemm operators are shown below.
 ```text

content/learning-paths/mobile-graphics-and-gaming/performance_onnxruntime_kleidiai_sme2/overview.md

@@ -8,32 +8,44 @@ layout: learningpathall
 
 ## ONNX Runtime overview
 With the rise of on-device AI, squeezing performance from CPUs has become critical. Arm's Scalable Matrix Extension 2 (SME2) represents a leap forward, offering significant speedups for matrix-heavy workloads like Transformers and CNNs.
-This Learning Path walks you through the technical steps to integrate KleidiAI—Arm's specialized micro-kernel library with SME2 support—into ONNX Runtime (ORT) and profile its performance using onnxruntime_perf_test on Android devices.
+This Learning Path walks you through the technical steps to integrate KleidiAI-Arm's specialized micro-kernel library with SME2 support-into ONNX Runtime (ORT) and profile its performance using onnxruntime_perf_test on Android devices.
 
-### Understanding the ONNX Runtime software stack
+## Understanding the ONNX Runtime software stack
 ONNX Runtime's internal architecture consists of four main components that work together to execute AI models efficiently:
 ![Diagram showing the four main components of ONNX Runtime: In-Memory Graph at the top, followed by Graph Partitioner, Graph Runner, and Execution Provider at the bottom, with data flow indicated between layers alt-txt#center](images/ort_overview.jpg "The ONNX Runtime overview")
 
-#### 1. In-Memory Graph
-When loading an ONNX model, ORT parses the protobuf file and creates an In-Memory Graph. This is a live representation of the model’s structure, consisting of:
--	Nodes: Representing operations (e.g., MatMul, Conv, Add).
--	Edges: Representing the flow of data (tensors) between those operations.
+### In-Memory Graph
+When ORT loads an ONNX model, it parses the protobuf file and builds an in-memory representation of the model's structure. This graph consists of:
+
+- Nodes: operations like MatMul, Conv, and Add
+- Edges: tensor data flowing between operations
 
 During this stage, ORT performs Graph Optimizations like constant folding and node fusion.
-#### 2. Graph Partitioner
+### Graph Partitioner
 The Graph Partitioner decides which part of the model runs on which hardware. It analyzes the computational graph and matches nodes to the registered Execution Providers.
 It clusters adjacent nodes assigned to the same EP into "Subgraphs".
-#### 3. Graph Runner 
+### Graph Runner 
 Once the graph is partitioned, the Graph Runner executes the operators in the correct order. It manages the flow of data (Tensors) between nodes.
 In ORT, parallelism splits into two distinct levels to maximize hardware utilization: Intra-op (inside an operator/node, splitting a single heavy operation/node into smaller chunks) and Inter-op (between different operators, running multiple independent operators at the same time).
+### Execution Provider (EP)
+
+An Execution Provider is the abstraction layer that interfaces with specific hardware or libraries. Each EP provides optimized math functions (called "Kernels") for specific operators.
+
+ORT supports multiple Execution Providers across different hardware types:
+
+**CPU-based providers:**
+- Default CPU provider
+- Intel DNNL
+- XNNPACK
+
+**GPU-based providers:**
+- NVIDIA CUDA/TensorRT
+- AMD MIGraphX
+- DirectML
 
-#### 4. Execution Provider (EP)
-An Execution Provider is the abstraction layer that interfaces with specific hardware or libraries. 
-Each EP provides a set of "Kernels" (optimized math functions) for specific operators.
-Examples: 
--	CPU: Default CPU, Intel DNNL, XNNPACK etc.
--	GPU: NVIDIA CUDA/TensorRT, AMD MIGraphX, DirectML etc.
--	Others: NPU, Qualcomm QNN etc.
+**Specialized accelerators:**
+- NPU
+- Qualcomm QNN
 
 If a specialized EP doesn't support a specific operator, ORT automatically falls back to the CPU provider.
 
@@ -45,7 +57,7 @@ This Learning Path focuses on Arm CPU Execution Provider.
 
 ## What you've accomplished and what's next
 
-You now understand how ONNX Runtime processes models through its layered architecture—from the in-memory graph to execution providers. You've learned how the Graph Partitioner assigns operations to hardware, how the Graph Runner orchestrates execution, and how Execution Providers like the CPU provider use optimized kernels. You also know that MLAS serves as the default CPU backend and that KleidiAI can optimize it with SME2-specific kernels.
+You now understand how ONNX Runtime processes models through its layered architecture-from the in-memory graph to execution providers. You've learned how the Graph Partitioner assigns operations to hardware, how the Graph Runner orchestrates execution, and how Execution Providers like the CPU provider use optimized kernels. You also know that MLAS serves as the default CPU backend and that KleidiAI can optimize it with SME2-specific kernels.
 
 Next, you'll explore how KleidiAI integrates into MLAS and which specific operators benefit from SME2 acceleration.
 

content/learning-paths/mobile-graphics-and-gaming/performance_onnxruntime_kleidiai_sme2/profiling_example.md

@@ -1,12 +1,12 @@
 ---
-title: Profiling – Use Resnet50v2 fp32 model as an example
+title: Profile ONNX model performance
 weight: 5
 
 ### FIXED, DO NOT MODIFY
 layout: learningpathall
 ---
 
-## Profile an ONNX model – Using Resnet50v2 as an example
+## Profile ONNX model performance using ResNet-50 v2
 
 Resnet50v2 serves as the example model in this Learning Path. Download the model package containing the ONNX model and its input data from the [ONNX model repository](https://github.com/onnx/models/tree/main/validated/vision/classification/resnet/model), then transfer it to your Android device:
 
@@ -76,11 +76,12 @@ P95 Latency: 0.34682 s
 P99 Latency: 0.34682 s
 P999 Latency: 0.34682 s
 ```
+
 ## Performance analysis
 
-#### Visualize profiling data with perfetto
+#### Visualize profiling data with Perfetto
 
-You can use [perfetto tool](https://ui.perfetto.dev/) to view the two JSON profile files.
+You can use [Perfetto](https://ui.perfetto.dev/) to view the two JSON profile files.
 
 The figure below is a screenshot of the Non-KleidiAI version of the JSON profile file. The selected part (one `model_run/SequentialExecutor`) in the figure includes information of one inference execution.