Merge pull request #1987 from NinaARM/documentation-updates

Documentation updates - add macOS build instructions

Author: pareenaverma

assets/contributors.csv

@@ -85,5 +85,7 @@ Yiyang Fan,Arm,,,,
 Julien Jayat,Arm,,,,
 Geremy Cohen,Arm,geremyCohen,geremyinanutshell,,
 Barbara Corriero,Arm,,,,
-Nina Drozd,Arm,,ninadrozd,,
+Nina Drozd,Arm,NinaARM,ninadrozd,,
 Jun He,Arm,JunHe77,jun-he-91969822,,
+Gian Marco Iodice,Arm,,,,
+Aude Vuilliomenet,Arm,,,,

content/learning-paths/mobile-graphics-and-gaming/run-stable-audio-open-small-with-lite-rt/1-prerequisites.md

@@ -15,7 +15,6 @@ Your first task is to prepare a development environment with the required softwa
 - Android NDK: version r25b or newer.
 - Python: version 3.10 or newer (tested with 3.10).
 - CMake: version 3.16.0 or newer (tested with 3.28.1).
-- [Arm GNU Toolchain](/install-guides/gcc/arm-gnu).
 
 ### Create workspace directory
 
@@ -79,14 +78,26 @@ Bazel is an open-source build tool which you will use to build LiteRT libraries.
 {{< tabpane code=true >}}
   {{< tab header="Linux">}}
 cd $WORKSPACE
-wget https://github.com/bazelbuild/bazel/releases/download/7.4.1/bazel-7.4.1-installer-linux-x86_64.sh
+export BAZEL_VERSION=7.4.1
+wget https://github.com/bazelbuild/bazel/releases/download/{$BAZEL_VERSION}/bazel-{$BAZEL_VERSION}-installer-linux-x86_64.sh
 sudo bash bazel-7.4.1-installer-linux-x86_64.sh
+export PATH="/usr/local/bin:$PATH"
   {{< /tab >}}
   {{< tab header="MacOS">}}
-brew install bazel@7
+cd $WORKSPACE
+export BAZEL_VERSION=7.4.1
+curl -fLO "https://github.com/bazelbuild/bazel/releases/download/{$BAZEL_VERSION}/bazel-{$BAZEL_VERSION}-installer-darwin-arm64.sh"
+sudo bash bazel-7.4.1-installer-darwin-arm64.sh
+export PATH="/usr/local/bin:$PATH"
   {{< /tab >}}
 {{< /tabpane >}}
 
+You can verify the installation and check the version with:
+
+```console
+bazel --version
+```
+
 ### Install Android NDK
 
 To run the model on Android, install Android Native Development Kit (Android NDK):
@@ -98,9 +109,9 @@ wget https://dl.google.com/android/repository/android-ndk-r25b-linux.zip
 unzip android-ndk-r25b-linux.zip
   {{< /tab >}}
   {{< tab header="MacOS">}}
+cd $WORKSPACE
 wget https://dl.google.com/android/repository/android-ndk-r25b-darwin.zip
-unzip android-ndk-r25b-darwin
-mv android-ndk-r25b-darwin ~/Library/Android/android-ndk-r25b
+unzip android-ndk-r25b-darwin.zip
   {{< /tab >}}
 {{< /tabpane >}}
 
@@ -109,12 +120,13 @@ For easier access and execution of Android NDK tools, add these to the `PATH` an
 {{< tabpane code=true >}}
   {{< tab header="Linux">}}
 export NDK_PATH=$WORKSPACE/android-ndk-r25b/
+export ANDROID_NDK_HOME=$NDK_PATH
 export PATH=$NDK_PATH/toolchains/llvm/prebuilt/linux-x86_64/bin/:$PATH
   {{< /tab >}}
   {{< tab header="MacOS">}}
-export NDK_PATH=~/Library/Android/android-ndk-r25b
-export PATH=$PATH:$NDK_PATH/toolchains/llvm/prebuilt/darwin-x86_64/bin
-export PATH=$PATH:~/Library/Android/sdk/cmdline-tools/latest/bin
+export NDK_PATH=$WORKSPACE/android-ndk-r25b/
+export ANDROID_NDK_HOME=$NDK_PATH
+export PATH=$NDK_PATH/toolchains/llvm/prebuilt/darwin-x86_64/bin/:$PATH
   {{< /tab >}}
 {{< /tabpane >}}
 

content/learning-paths/mobile-graphics-and-gaming/run-stable-audio-open-small-with-lite-rt/3-converting-model.md

@@ -24,30 +24,28 @@ In this section, you will explore two different conversion routes, to convert th
 
 1. **ONNX to LiteRT**: using the `onnx2tf` tool. This is the traditional two-step approach (PyTorch -> ONNX -> LiteRT). You will use it to convert the Conditioners submodule.
 
-2. **PyTorch to LiteRT**: using the Google AI Edge Torch tool. You will use this tool to convert the DiT and AutoEncoder submodules.
+2. **PyTorch to LiteRT**: using the [Google AI Edge Torch](https://developers.googleblog.com/en/ai-edge-torch-high-performance-inference-of-pytorch-models-on-mobile-devices/) tool. You will use this tool to convert the DiT and AutoEncoder submodules.
 
 
-## Download the sample code
-
-The Conditioners submodule is made of the T5Encoder model. You will use the ONNX to TFLite conversion for this submodule.
+## Create a virtual environment
 
 To avoid dependency issues, create a virtual environment. For example, you can use the following command:
 
 ```bash
 cd $WORKSPACE
-python3.10 -m venv env
-source env/bin/activate
+python3.10 -m venv .venv
+source .venv/bin/activate
 ```
 
-Clone the examples repository:
+## Clone the examples repository
 
 ```bash
 cd $WORKSPACE
 git clone https://github.com/ARM-software/ML-examples.git
 cd ML-examples/kleidiai-examples/audiogen/
 ```
 
-Install the required Python packages for this, including *onnx2tf* and *ai_edge_litert*
+## Install the required dependencies
 
 ```bash
 bash install_requirements.sh
@@ -58,13 +56,13 @@ bash install_requirements.sh
 If you are using GPU on your machine, you may notice the following error:
 ```text
 Traceback (most recent call last):
-  File "$WORKSPACE/env/lib/python3.10/site-packages/torch/_inductor/runtime/hints.py",
+  File "$WORKSPACE/.venv/lib/python3.10/site-packages/torch/_inductor/runtime/hints.py",
   line 46, in <module> from triton.backends.compiler import AttrsDescriptor
 ImportError: cannot import name 'AttrsDescriptor' from 'triton.backends.compiler'
-($WORKSPACE/env/lib/python3.10/site-packages/triton/backends/compiler.py)
+($WORKSPACE/.venv/lib/python3.10/site-packages/triton/backends/compiler.py)
 .
 ImportError: cannot import name 'AttrsDescriptor' from 'triton.compiler.compiler'
-($WORKSPACE/env/lib/python3.10/site-packages/triton/compiler/compiler.py)
+($WORKSPACE/.venv/lib/python3.10/site-packages/triton/compiler/compiler.py)
 ```
 
 Reinstall the following dependency:
@@ -89,13 +87,14 @@ You can use the provided script to convert the Conditioners submodule:
 python3 ./scripts/export_conditioners.py --model_config "$WORKSPACE/model_config.json" --ckpt_path "$WORKSPACE/model.ckpt"
 ```
 
-After successful conversion, you now have a `tflite_conditioners` directory containing models with different precision (e.g., float16, float32).
+
+After successful conversion, you now have a `conditioners_tflite` directory containing models with different precisions (e.g., float16, float32).
 
 You will be using the float32.tflite model for on-device inference.
 
-### Convert DiT and AutoEncoder
+### Convert DiT and AutoEncoder Submodules
 
-To convert the DiT and AutoEncoder submodules, use the [Generative API](https://github.com/google-ai-edge/ai-edge-torch/tree/main/ai_edge_torch/generative/) provided by the ai-edge-torch tools. This enables you to export a generative PyTorch model directly to `.tflite` using three main steps:
+To convert the DiT and AutoEncoder submodules, use the [Generative API](https://github.com/google-ai-edge/ai-edge-torch/tree/main/ai_edge_torch/generative/) provided by the `ai-edge-torch` tools. This enables you to export a generative PyTorch model directly to `.tflite` using three main steps:
 
 1. Model re-authoring.
 2. Quantization.

content/learning-paths/mobile-graphics-and-gaming/run-stable-audio-open-small-with-lite-rt/4-building-litert.md

@@ -33,11 +33,13 @@ Ensure the `NDK_PATH` variable is set to your previously installed Android NDK:
 {{< tabpane code=true >}}
   {{< tab header="Linux">}}
 export NDK_PATH=$WORKSPACE/android-ndk-r25b/
+export ANDROID_NDK_HOME=$NDK_PATH
 export PATH=$NDK_PATH/toolchains/llvm/prebuilt/linux-x86_64/bin/:$PATH
   {{< /tab >}}
   {{< tab header="MacOS">}}
-export NDK_PATH=~/Library/Android/android-ndk-r25b
-export PATH=$PATH:$NDK_PATH/toolchains/llvm/prebuilt/darwin-x86_64/bin
+export NDK_PATH=$WORKSPACE/android-ndk-r25b/
+export ANDROID_NDK_HOME=$NDK_PATH
+export PATH=$NDK_PATH/toolchains/llvm/prebuilt/darwin-x86_64/bin/:$PATH
   {{< /tab >}}
 {{< /tabpane >}}
 {{% /notice  %}}
@@ -54,6 +56,7 @@ python3 ./configure.py
 |Please input the desired Python library path to use[$WORKSPACE/lib/python3.10/site-packages] | Enter |
 |Do you wish to build TensorFlow with ROCm support? [y/N]|N (No)|
 |Do you wish to build TensorFlow with CUDA support?|N|
+|Please specify optimization flags to use during compilation when bazel option "--config=opt" is specified [Default is -Wno-sign-compare]:| Enter |
 |Do you want to use Clang to build TensorFlow? [Y/n]|N|
 |Would you like to interactively configure ./WORKSPACE for Android builds? [y/N]|y (Yes) |
 |Please specify the home path of the Android NDK to use. [Default is /home/user/Android/Sdk/ndk-bundle]| Enter |
@@ -63,15 +66,24 @@ python3 ./configure.py
 |Please specify an Android build tools version to use.  [Default is 35.0.0]| Enter |
 |Do you wish to build TensorFlow with iOS support? [y/N]:| n |
 
-Once the Bazel configuration is complete, you can build TFLite as follows:
+Once the Bazel configuration is complete, you can build LiteRT for your target platform as follows:
 
-```console
+{{< tabpane code=true >}}
+  {{< tab header="Android">}}
 bazel build -c opt --config android_arm64 //tensorflow/lite:libtensorflowlite.so \
     --define tflite_with_xnnpack=true \
     --define=xnn_enable_arm_i8mm=true \
     --define tflite_with_xnnpack_qs8=true \
     --define tflite_with_xnnpack_qu8=true
-```
+  {{< /tab >}}
+  {{< tab header="MacOS">}}
+bazel build -c opt --config macos //tensorflow/lite:libtensorflowlite.so \
+    --define tflite_with_xnnpack=true \
+    --define xnn_enable_arm_i8mm=true \
+    --define tflite_with_xnnpack_qs8=true \
+    --define tflite_with_xnnpack_qu8=true
+  {{< /tab >}}
+{{< /tabpane >}}
 
 The final step is to build flatbuffers used by the application:
 ```
@@ -81,7 +93,7 @@ cmake ../tensorflow/lite/tools/cmake/native_tools/flatbuffers
 cmake --build .
 ```
 
-Now that LiteRT and FlatBuffers are built, you're ready to compile and deploy the Stable Audio Open Small inference application on your Android device.
+Now that LiteRT and FlatBuffers are built, you're ready to compile and deploy the Stable Audio Open Small inference application on your Android or macOS device.
 
 
 

content/learning-paths/mobile-graphics-and-gaming/run-stable-audio-open-small-with-lite-rt/5-creating-simple-program.md renamed to content/learning-paths/mobile-graphics-and-gaming/run-stable-audio-open-small-with-lite-rt/5-creating-simple-program-for-android.md

@@ -1,5 +1,5 @@
 ---
-title: Create a simple program
+title: Create a simple program for Android target
 weight: 6
 
 ### FIXED, DO NOT MODIFY
@@ -36,7 +36,7 @@ A SentencePiece model is a type of subword tokenizer which is used by the audiog
 
 ```bash
 cd $WORKSPACE
-wget https://huggingface.co/google-t5/t5-base/tree/main
+wget https://huggingface.co/google-t5/t5-base/resolve/main/spiece.model
 ```
 
 Verify this model was downloaded to your `WORKSPACE`.
@@ -76,7 +76,13 @@ Start a new shell to access the device's system from your development machine:
 adb shell
 ```
 
-Finally, run the program on your Android device. Play around with the advice from [Download the model](../2-testing-model) section.
+From there, you can then run the audiogen application, which requires just three input arguments:
+
+* **Model Path:** The directory containing your LiteRT models and spiece.model files
+* **Prompt:** A text description of the desired audio (e.g., warm arpeggios on house beats 120BPM with drums effect)
+* **CPU Threads:** The number of CPU threads to use (e.g., 4)
+
+Play around with the advice from [Download and test the model](../2-testing-model) section.
 
 ```bash
 cd /data/local/tmp/app
@@ -90,4 +96,4 @@ You can now pull the generated `output.wav` back to your host machine and listen
 adb pull /data/local/tmp/app/output.wav
 ```
 
-You should now have gained hands-on experience running the Stable Audio Open Small model with LiteRT on Arm-based devices. This includes setting up the environment, optimizing the model for on-device inference, and understanding how efficient runtimes like LiteRT make low-latency generative AI possible at the edge. You’re now better equipped to explore and deploy AI-powered audio applications on mobile and embedded platforms.
+You should now have gained hands-on experience running the Stable Audio Open Small model with LiteRT on Arm-based devices. This includes setting up the environment, optimizing the model for on-device inference, and understanding how efficient runtimes like LiteRT make low-latency generative AI possible at the edge. You’re now better equipped to explore and deploy AI-powered audio applications on mobile and embedded platforms.

content/learning-paths/mobile-graphics-and-gaming/run-stable-audio-open-small-with-lite-rt/6-creating-simple-program-for-macos.md

@@ -0,0 +1,66 @@
+---
+title: Create a simple program for macOS target
+weight: 7
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Create and build a simple program
+
+As a final step, you’ll build a simple program that runs inference on all three submodules directly on a macOS device.
+
+The program takes a text prompt as input and generates an audio file as output.
+
+```bash
+cd $WORKSPACE/ML-examples/kleidiai-examples/audiogen/app
+mkdir build && cd build
+```
+
+Ensure the NDK path is set correctly and build with `cmake`:
+
+```bash
+cmake -DCMAKE_POLICY_VERSION_MINIMUM=3.5 \
+      -DTF_INCLUDE_PATH=$TF_SRC_PATH \
+      -DTF_LIB_PATH=$TF_SRC_PATH/bazel-bin/tensorflow/lite \
+      -DFLATBUFFER_INCLUDE_PATH=$TF_SRC_PATH/flatc-native-build/flatbuffers/include \
+    ..
+
+make -j
+```
+After the example application builds successfully, a binary file named `audiogen` is created.
+
+A SentencePiece model is a type of subword tokenizer which is used by the audiogen application, you’ll need to download the *spiece.model* file from:
+
+```bash
+cd $LITERT_MODELS_PATH
+wget https://huggingface.co/google-t5/t5-base/resolve/main/spiece.model
+```
+
+Verify this model was downloaded to your `WORKSPACE`.
+
+```text
+ls $LITERT_MODELS_PATH/spiece.model
+```
+
+Copy the shared LiteRT dynamic library to the $LITERT_MODELS_PATH.
+```bash
+cp $TF_SRC_PATH/bazel-bin/tensorflow/lite/libtensorflowlite.so $LITERT_MODELS_PATH/
+```
+
+From there, you can then run the audiogen application, which requires just three input arguments:
+
+* **Model Path:** The directory containing your LiteRT models and spiece.model files
+* **Prompt:** A text description of the desired audio (e.g., warm arpeggios on house beats 120BPM with drums effect)
+* **CPU Threads:** The number of CPU threads to use (e.g., 4)
+
+Play around with the advice from [Download and test the model](../2-testing-model) section.
+
+```bash
+cd $WORKSPACE/ML-examples/kleidiai-examples/audiogen/app/
+./build/audiogen $LITERT_MODELS_PATH "warm arpeggios on house beats 120BPM with drums effect" 4
+```
+
+You can now check the generated `output.wav` and listen to the result.
+
+You should now have gained hands-on experience running the Stable Audio Open Small model with LiteRT on Arm-based devices. This includes setting up the environment, optimizing the model for on-device inference, and understanding how efficient runtimes like LiteRT make low-latency generative AI possible at the edge. You’re now better equipped to explore and deploy AI-powered audio applications on mobile and embedded platforms.

content/learning-paths/mobile-graphics-and-gaming/run-stable-audio-open-small-with-lite-rt/_index.md

@@ -3,7 +3,7 @@ title: Generate audio with Stable Audio Open Small on LiteRT
 
 minutes_to_complete: 30
 
-who_is_this_for: This is an introductory topic for developers looking to deploy the Stable Audio Open Small text-to-audio model using LiteRT on an Android device.
+who_is_this_for: This is an introductory topic for developers looking to deploy the Stable Audio Open Small text-to-audio model using LiteRT on an Android™ device or on a reasonably modern platform with macOS®.
 
 learning_objectives:
     - Download and test the Stable Audio Open Small model. 
@@ -19,6 +19,9 @@ prerequisites:
 
 author:
     - Nina Drozd
+    - Gian Marco Iodice
+    - Adnan AlSinan
+    - Aude Vuilliomenet
     - Annie Tallund
 
 ### Tags
@@ -42,8 +45,8 @@ further_reading:
         link: https://stability.ai/news/stability-ai-and-arm-release-stable-audio-open-small-enabling-real-world-deployment-for-on-device-audio-control
         type: blog
     - resource:
-        title: Stability AI optimized its audio generation model to run on Arm chips
-        link: https://techcrunch.com/2025/03/03/stability-ai-optimized-its-audio-generation-model-to-run-on-arm-chips/
+        title: "Unlocking audio generation on Arm CPUs to all: Running Stable Audio Open Small with KleidiAI"
+        link: https://community.arm.com/arm-community-blogs/b/ai-blog/posts/audio-generation-arm-cpus-stable-audio-open-small-kleidiai
         type: blog
     - resource:
         title: Fast Text-to-Audio Generation with Adversarial Post-Training