Merge pull request #3492 from V3x-0E/main

Open PR for Vulkan update

Author: pareenaverma

content/learning-paths/mobile-graphics-and-gaming/vulkan-ml-sample/1-introduction.md

@@ -8,11 +8,11 @@ layout: learningpathall
 
 ## What is neural graphics, and why does it matter for real-time rendering?
 
-Neural graphics combines real-time rendering with the power of machine learning to enhance visual quality and performance. By integrating ML techniques like neural upscaling directly into the GPU pipeline, developers can achieve next-gen fidelity and efficiency. This is especially valuable on mobile and embedded devices, where power efficiency is critical.
+Neural graphics combines real-time rendering with machine learning to improve visual quality and performance. Integrating ML techniques, such as neural upscaling, directly into the GPU pipeline can improve visual fidelity and efficiency. This approach is especially valuable on mobile and embedded devices, where power efficiency is critical.
 
 ## How do ML Extensions for Vulkan support neural graphics workloads?
 
-Vulkan's data graph pipelines, introduced through the `VK_ARM_data_graph` and `VK_ARM_tensors` extensions, bring structured compute graph execution to the Vulkan API by introducing support for processing tensors. These pipelines are designed to execute ML inference workloads efficiently using SPIR-V-defined graphs.
+The `VK_ARM_data_graph` and `VK_ARM_tensors` extensions bring structured compute graph execution and tensor processing to the Vulkan API. Their data graph pipelines use SPIR-V-defined graphs to execute ML inference workloads efficiently.
 
 To help developers adopt these features, the Tensor and Data Graph Vulkan Samples offer hands-on demonstrations.
 
@@ -21,18 +21,18 @@ These samples address key challenges in ML integration, such as:
 - **Understanding graph-based compute with Vulkan**: See how compute workloads can be structured using explicit graph topologies.
 - **Demystifying ML inference in real-time rendering**: Learn how ML fits into the graphics pipeline.
 
-Samples range from basic setups to more advanced features like tensor aliasing and compute shader integration.
+The samples range from basic configurations to more advanced features, such as tensor aliasing and compute shader integration.
 
 This Learning Path walks you through setting up and running the first sample, `simple_tensor_and_data_graph`.
 
-
-### Why use ML Extensions for Vulkan for game and graphics development?
+### Why use ML Extensions for Vulkan in game and graphics development?
 
 As a game developer, you've probably noticed the rising demand for smarter, more immersive graphics — but also the increasing strain on GPU resources, especially on mobile. Vulkan's traditional pipelines give you fine-grained control, but finding the right tooling to integrate machine learning has been a challenge. That’s where the new ML extensions for Vulkan come in.
 
 Arm’s `VK_ARM_tensors` and `VK_ARM_data_graph` extensions give you native Vulkan support for executing neural networks on the GPU — using structured tensors and data graph pipelines. Instead of chaining compute shaders to simulate ML models, you can now express them as dataflow graphs in SPIR-V and run them more efficiently. This opens the door to using AI techniques right alongside the graphics pipeline.
 
-And while ML has found success in image classification and LLMs, these extensions are designed from the ground up for gaming and graphics workloads — prioritizing predictable execution, GPU compatibility, and memory efficiency. With built-in support for tensor formats and pipeline sessions, the extensions are optimized for developers looking to blend traditional rendering with machine learning on Vulkan.
+
+Although ML is widely used for image classification and large language models (LLMs), these extensions target game and graphics workloads. They prioritize predictable execution, GPU compatibility, and memory efficiency. Built-in support for tensor formats and pipeline sessions helps you combine traditional Vulkan rendering with machine learning.
 
 Arm provides emulation layers for development on any modern Vulkan-capable hardware, and PyTorch support is available for model conversion workflows.
 

content/learning-paths/mobile-graphics-and-gaming/vulkan-ml-sample/2-ml-ext-for-vulkan.md

@@ -1,5 +1,5 @@
 ---
-title: Setting up the ML Emulation Layers for Vulkan
+title: Set up the ML Emulation Layers for Vulkan
 weight: 3
 
 ### FIXED, DO NOT MODIFY
@@ -12,60 +12,85 @@ To run the Vulkan Samples, you first need to set up your development environment
 
 This setup involves two main steps:
 
-* Install the required tools on your development machine
-* Download the ML emulation layers for Vulkan, which simulate the `VK_ARM_data_graph` and `VK_ARM_tensors` extensions
+- Install the required tools on your development machine.
+- Download the ML Emulation Layers for Vulkan, which simulate the `VK_ARM_data_graph` and `VK_ARM_tensors` extensions.
 
 ## Install required tools for development
 
-Before building and running the samples, ensure the following tools are installed on your development machine:
+Before building and running the samples, install these tools on your development machine:
 
-- CMake (version 3.12 or later)
+- CMake (version 3.25 or later)
 - Python 3
 - Git
 
+Install Git with the following command:
+
+```bash
+winget install --id Git.Git -e
+```
+
+In Visual Studio Code, create a folder for the project and install these Microsoft extensions:
+
+- C/C++
+- CMake Tools
+
+![C/C++ tools extension](images/c-ext.png)
+
+![CMake Tools extension](images/cmake-ext.png)
+
+Create a Python virtual environment and install the required packages:
+
+```bash
+py -m venv .venv
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+python -m pip install ai-ml-emulation-layer-for-vulkan cmake
+```
+
 To verify your installation, run the following commands:
 
 ```bash
 cmake --version
-python3 --version
+python --version
 git --version
+python -m pip show ai-ml-emulation-layer-for-vulkan
 ```
 
-Each command should print the installed version of the tool.
+Each command prints the installed version of the tool or shows where the appropriate files are located.
 
-### Install Vulkan Software Development Kit
+### Install the Vulkan Software Development Kit
 
-Go to the [Getting Started with the Windows Vulkan SDK](https://vulkan.lunarg.com/sdk/home) and download the SDK Installer for Windows. This installs **Vulkan Configurator** which is used to run the emulation layers.
+Download the Windows installer from [Getting Started with the Windows Vulkan SDK](https://vulkan.lunarg.com/sdk/home). The Vulkan Software Development Kit (SDK) includes **Vulkan Configurator**, which you use to run the emulation layers.
 
 {{% notice Note %}}
-You must use a version >= 1.4.321 for the Vulkan SDK.
-{{% /notice %}}
 
-## Download the emulation layers
+Use Vulkan SDK version 1.4.321 or later.
 
-For this Learning Path, a pre-built of package of the emulation layers is available. Download them by clicking the link.
-
-[ML Emulation Layer for Vulkan](https://www.arm.com/-/media/Files/developer/MLEmulationLayerForVulkan20251107)
+{{% /notice %}}
 
-Extract the downloaded file in a location of your choice. You’re now ready to enable the emulation layers in Vulkan Configurator.
 
 ## Enable the emulation layers in Vulkan Configurator
 
-Next, enable the emulation layers using the Vulkan Configurator to simulate the `VK_ARM_data_graph` and `VK_ARM_tensors` extensions. Open **Vulkan Configurator**.
+Open **Vulkan Configurator** to enable the layers that emulate the `VK_ARM_data_graph` and `VK_ARM_tensors` extensions.
 
-Under the **Vulkan Layers Location** tab, add the path to your `MLEmulationLayerForVulkan` folder.
+On the **Vulkan Layers Available** tab, browse to the emulation layer folder in your virtual environment's `site-packages` directory:
 
-Switch back to the **Vulkan Loader Management** tab. In the **Apply a Vulkan Loader Configuration** list, right-click and choose **Create a new Configuration**. You can give the new configuration any name, for example `tensor_and_data_graph`.
+```output
+.venv/Lib/site-packages/emulation_layer/deploy/bin
+```
+
+![VL available](images/vl-available.png)
 
-![Screenshot of the Vulkan Configurator showing the Vulkan Layers Location tab, where the emulation layer path (MLEmulationLayerForVulkan) is added to enable VK_ARM_data_graph and VK_ARM_tensors alt-text#center](./images/load_layers.png "Add emulation layers in Vulkan Configurator")
+On the **Vulkan Layers Configuration** tab, set **Vulkan Loader Configuration Scope** to **Any Running Vulkan Executable**. Select **New Configuration**, then enable the **Graph Emulation** and **Tensor Emulation** layers.
 
 Ensure that the **Graph** layer is listed above the **Tensor** layer.
 
-![Screenshot showing the Graph layer listed above the Tensor layer in the Vulkan Configurator. alt-text#center](./images/verify_layers.png "Reorder layers in Vulkan Configurator")
+![VL Config](images/vl-layers.png)
 
 {{% notice Important %}}
+
 Keep Vulkan Configurator running while you run the Vulkan samples.
-{{% /notice %}}
 
-With the emulation layers configured, you're ready to build the Vulkan Samples. Continue to the next section to get started.
+{{% /notice %}}
 
+With the emulation layers configured, you're ready to build the Vulkan Samples.

content/learning-paths/mobile-graphics-and-gaming/vulkan-ml-sample/3-first-sample.md

@@ -8,36 +8,39 @@ layout: learningpathall
 
 ## Understand how the Simple Tensor and Data Graph sample works
 
-The **Simple Tensor and Data Graph** sample is your starting point for working with the ML extensions for Vulkan. It demonstrates how to execute a simple neural network using a data graph pipeline — specifically, a 2D average pooling operation.
+The **Simple Tensor and Data Graph** sample is a starting point for working with ML Extensions for Vulkan. It demonstrates how to execute a simple neural network with a data graph pipeline, specifically a 2D average pooling operation.
 
 ## Clone the Vulkan Samples
 
-With the environment set up, you can now grab the sample code. These examples sit in the the Khronos Group's repository.
+With the environment set up, clone the sample code from the Khronos Group repository:
 
 ```bash
 git clone --recurse-submodules https://github.com/KhronosGroup/Vulkan-Samples.git
 cd Vulkan-Samples
 ```
 
-This repository includes the framework and samples showcasing the ML extensions for Vulkan.
+The repository includes the framework and samples that demonstrate ML Extensions for Vulkan.
 
 ## Build the Vulkan Samples
 
-You're now ready to compile the project. From the root of the repository:
+You're now ready to compile the project.
 
 {{% notice Note %}}
-Be sure to run the commands in [Developer Mode](https://learn.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development#activate-developer-mode) to avoid permission issues.
+Enable [Developer Mode](https://learn.microsoft.com/en-us/windows/apps/get-started/enable-your-device-for-development#activate-developer-mode) before running the commands to avoid permission issues.
 {{% /notice %}}
 
 Generate Visual Studio project files using CMake:
+
 ```bash
 cmake -G "Visual Studio 17 2022" -A x64 -S . -Bbuild/windows
 ```
-Finally, compile the `vulkan_samples` target in Release mode:
+
+Compile the `vulkan_samples` target in Release mode:
 
 ```bash
 cmake --build build/windows --config Release --target vulkan_samples
 ```
+
 ## Run the Simple Tensor and Data Graph sample
 
 Run the built executable using the following command:
@@ -46,23 +49,23 @@ Run the built executable using the following command:
 build\windows\app\bin\Release\AMD64\vulkan_samples.exe sample simple_tensor_and_data_graph
 ```
 
-This should open a new window visualizing the operation. In this sample, a minimal Vulkan application sets up a data graph pipeline configured to process a small neural network.
+A new window opens and visualizes the operation. The sample uses a minimal Vulkan application to create a data graph pipeline that processes a small neural network.
 
-The sample creates input and output tensors, binds them using descriptor sets and pipeline layouts, and supplies a SPIR-V module that defines the network operation. Finally, it records and dispatches commands to execute the pipeline — and visualizes the results in real time. More details about what's going on under the hood can be found in the [documentation](https://arm-software.github.io/Vulkan-Samples/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/README.html).
+The sample creates input and output tensors, binds them with descriptor sets and pipeline layouts, and supplies a SPIR-V module that defines the network operation. It then records and dispatches commands to execute the pipeline and visualize the results in real time. For implementation details, see the [Simple Tensor and Data Graph documentation](https://arm-software.github.io/Vulkan-Samples/samples/extensions/tensor_and_data_graph/simple_tensor_and_data_graph/README.html).
 
 ## Summary and next steps
 
-By running this sample, you’ve stepped through a complete Vulkan data graph pipeline powered by the ML extensions for Vulkan. You’ve created tensors, set up descriptors, built a SPIR-V-encoded ML graph, and dispatched inference — all without needing custom shaders. This sets the foundation for neural graphics. As you explore the remaining samples, you’ll see how this core pattern extends into real-world graphics scenarios.
+By running this sample, you've stepped through a complete Vulkan data graph pipeline powered by ML Extensions for Vulkan. You've created tensors, set up descriptors, built a SPIR-V-encoded ML graph, and dispatched inference without custom shaders. This workflow provides a foundation for neural graphics and extends to more complex graphics scenarios.
 
-As a next step, you can explore the remaining samples for the data graph pipeline. The documentation sits in each sample's directory, available under `samples/extensions/tensor_and_data_graph/` in the repository.
+You can also explore the remaining data graph pipeline samples. Each sample's documentation is in its directory under `samples/extensions/tensor_and_data_graph/`.
 
-## Overview of Additional Samples
+## Overview of additional samples
 
-| Sample Name                      | Description                                                                                  | Focus Area                              |
+| Sample name                      | Description                                                                                  | Focus area                              |
 |-------------------------------------|----------------------------------------------------------------------------------------------|------------------------------------------|
-| **Graph Constants**              | Shows how to include constants like weights and biases into the data graph pipeline using tensors| Constant tensor injection           |
+| **Graph Constants**              | Shows how to add constants, such as weights and biases, to the data graph pipeline using tensors | Constant tensor injection           |
 | **Compute Shaders with Tensors** | Demonstrates how to feed tensor data into or out of data graph pipelines using compute shaders   | Shader interoperability      |
 | **Tensor Image Aliasing**      | Demonstrates tensor aliasing with Vulkan images to enable zero-copy workflows                  | Memory-efficient data sharing |
-| **Postprocessing with VGF**      | Explores using VGF format, which contains SPIR-V, input, output and constant data used to run a data graph pipeline.   | Neural network model     |
+| **Postprocessing with VGF**      | Explores how a VGF file packages SPIR-V with input, output, and constant data for a data graph pipeline | Neural network model     |
 
-Next, you'll review additional tools to help you work with ML extensions for Vulkan in your own development environment.
+Next, you'll review additional tools for working with ML Extensions for Vulkan in your development environment.