Merge pull request #2493 from annietllnd/updates

Update Android LlamaDemo LP

Author: pareenaverma

content/learning-paths/mobile-graphics-and-gaming/build-llama3-chat-android-app-using-executorch-and-xnnpack/1-dev-env-setup.md

@@ -13,61 +13,109 @@ In this Learning Path, you will learn how to build and deploy a simple LLM-based
 The first step is to prepare a development environment with the required software:
 
 - Android Studio (latest version recommended).
-- Android NDK version 28.0.12433566.
+- Android NDK version 28.0.12433566 or later.
 - Java 17 JDK.
 - Git.
 - Python 3.10 or later (these instructions have been tested with 3.10 and 3.12).
 
 The instructions assume macOS with Apple Silicon, an x86 Debian, or an Ubuntu Linux machine, with at least 16GB of RAM.
 
-## Install Android Studio and Android NDK
+## Install Java 17 JDK
+
+Open the [Java SE 17 Archive Downloads](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html) page in your browser.
+
+Select an appropriate download for your development machine operating system.
 
-Follow these steps to install and configure Android Studio:
+Downloads are available for macOS as well as Linux. 
 
-1. Download and install the latest version of [Android Studio](https://developer.android.com/studio/).
+## Install and configure Android Studio
 
-2. Start Android Studio and open the **Settings** dialog.
+Start by downloading and installing the latest version of Android Studio by navigating to the Downloads page:
 
-3. Navigate to **Languages & Frameworks**, then **Android SDK**.
+```
+https://developer.android.com/studio/
+```
 
-4. In the **SDK Platforms** tab, check **Android 14.0 ("UpsideDownCake")**.
+### For MacOS: Using UI
 
-Next, install the specific version of the Android NDK that you require by first installing the Android command line tools:
+Follow these steps to configure Android Studio:
 
-Linux:
+1. Start Android Studio and open the **Settings** dialog.
 
+2. Navigate to **Languages & Frameworks**, then **Android SDK**.
+
+3. In the **SDK Platforms** tab, check **Android 14.0 ("UpsideDownCake")**. Click **Apply** to install. 
+
+4. In the **SDK Tools** tab, check **NDK (Side by side)**. Click **Apply** to install.
+
+Initiate the `ANDROID_HOME` environment variable:
+
+```bash
+export ANDROID_HOME="$(realpath ~/Library/Android/sdk)"
 ```
-curl https://dl.google.com/android/repository/commandlinetools-linux-11076708_latest.zip -o commandlinetools.zip
-```
 
-macOS:
+### For Linux: Using the CLI
+
+Command-line tools allow you to manage Android SDK components without the GUI. Create SDK directory and download command-line tools:
 
+```bash
+mkdir -p ~/Android/cmdline-tools
+cd ~/Android/cmdline-tools
+wget https://dl.google.com/android/repository/commandlinetools-linux-10406996_latest.zip
 ```
-curl https://dl.google.com/android/repository/commandlinetools-mac-11076708_latest.zip -o commandlinetools.zip
+
+Unzip and move into the `cmdline-tools` directory.
+
+```bash
+unzip commandlinetools-linux-*.zip
+mv cmdline-tools latest
 ```
 
-Unzip the Android command line tools:
+Initiate the `ANDROID_HOME` environment variable and add the `sdkmanager` to `PATH`:
 
+```bash
+export ANDROID_HOME="~/Android"
+export PATH="$ANDROID_HOME/cmdline-tools/latest/bin:$ANDROID_HOME/platform-tools:$PATH"
 ```
-unzip commandlinetools.zip -d android-sdk
+
+The next step is to accept the license agreements. Press 'y', then 'Enter', as many times as prompted.
+
+```bash
+sdkmanager --licenses
 ```
 
-Install the NDK in the same directory that Android Studio installed the SDK. This is generally `~/Library/Android/sdk` by default. Set the requirement environment variables:
+Finally, you can install the required Android SDK components:
 
+```bash
+sdkmanager "platform-tools" \
+           "platforms;android-34" \
+           "build-tools;34.0.0" \
+           "ndk;29.0.14206865"
 ```
-export ANDROID_HOME="$(realpath ~/Library/Android/sdk)"
-export PATH=$ANDROID_HOME/cmdline-tools/bin/:$PATH
-sdkmanager --sdk_root="${ANDROID_HOME}" --install "ndk;28.0.12433566"
-export ANDROID_NDK=$ANDROID_HOME/ndk/28.0.12433566/
+
+## Verify NDK installation 
+
+Verify by checking that the NDK was installed in the same directory that Android Studio installed the SDK. 
+
+{{% notice Default Path %}}
+On macOS, this is generally `~/Library/Android/sdk`, and on Linux, it's `~/Android/Sdk`. You should also update the command to use the installed NDK version.
+{{% /notice %}}
+
+```bash
+ls $ANDROID_HOME
 ```
 
-## Install Java 17 JDK
+It should print the installed version, for example:
 
-Open the [Java SE 17 Archive Downloads](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html) page in your browser.
+```output
+29.0.14206865
+```
 
-Select an appropriate download for your development machine operating system.
+Set the required environment variable:
 
-Downloads are available for macOS as well as Linux.
+```
+export ANDROID_NDK="$ANDROID_HOME/ndk/29.0.14206865/"
+```
 
 ## Install Git and cmake
 

content/learning-paths/mobile-graphics-and-gaming/build-llama3-chat-android-app-using-executorch-and-xnnpack/2-executorch-setup.md

@@ -12,7 +12,9 @@ ExecuTorch is an end-to-end solution for enabling on-device inference capabiliti
 
 The best practice is to generate an isolated Python environment in which to install your ExecuTorch dependencies. We provide instructions for both a Python virtual environment and a Conda virtual environment, but you only need one.
 
-### Option 1: Create a Python virtual environment
+### Create a Python virtual environment
+
+Use the `venv` module that is available through Python:
 
 ```bash
 python3.10 -m venv executorch-venv
@@ -21,24 +23,14 @@ source executorch-venv/bin/activate
 
 The prompt of your terminal has `executorch` as a prefix to indicate the virtual environment is active.
 
-### Option 2: Create a Conda virtual environment
-
-Install Miniconda on your development machine by following the [Installing conda](https://conda.io/projects/conda/en/latest/user-guide/install/index.html) instructions.
-
-Once `conda` is installed, create the environment:
-
-```bash
-conda create -yn executorch-venv python=3.10.0
-conda activate executorch-venv
-```
-
 ### Clone ExecuTorch and install the required dependencies
 
-From within the conda environment, run the commands below to download the ExecuTorch repository and install the required packages:
+From within the virtual environment, run the commands below to download the ExecuTorch repository and install the required packages:
 
 ``` bash
 git clone https://github.com/pytorch/executorch.git
 cd executorch
+git checkout release/1.0
 git submodule sync
 git submodule update --init --recursive
 ./install_executorch.sh

content/learning-paths/mobile-graphics-and-gaming/build-llama3-chat-android-app-using-executorch-and-xnnpack/5-run-benchmark-on-android.md

@@ -32,6 +32,7 @@ Use `cmake` to cross-compile ExecuTorch:
 cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake \
     -DANDROID_ABI=arm64-v8a \
     -DANDROID_PLATFORM=android-23 \
+    -DEXECUTORCH_BUILD_EXTENSION_NAMED_DATA_MAP=ON \
     -DCMAKE_INSTALL_PREFIX=cmake-out-android \
     -DEXECUTORCH_ENABLE_LOGGING=1 \
     -DCMAKE_BUILD_TYPE=Release \
@@ -69,11 +70,7 @@ cmake  -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake \
     -DCMAKE_INSTALL_PREFIX=cmake-out-android \
     -DCMAKE_BUILD_TYPE=Release \
     -DPYTHON_EXECUTABLE=python \
-    -DEXECUTORCH_BUILD_XNNPACK=ON \
     -DEXECUTORCH_BUILD_KERNELS_OPTIMIZED=ON \
-    -DEXECUTORCH_BUILD_KERNELS_QUANTIZED=ON \
-    -DEXECUTORCH_BUILD_KERNELS_CUSTOM=ON \
-    -DSUPPORT_REGEX_LOOKAHEAD=ON \
     -DBUILD_TESTING=OFF \
     -Bcmake-out-android/examples/models/llama \
     examples/models/llama

content/learning-paths/mobile-graphics-and-gaming/build-llama3-chat-android-app-using-executorch-and-xnnpack/6-build-android-chat-app.md

@@ -6,17 +6,16 @@ weight: 7
 layout: learningpathall
 ---
 
+In this section, you will use a Android demo application to demonstrate local inference with ExecuTorch.
+
 ## Build the Android Archive (AAR)
-{{% notice Note %}}
-You can use the Android demo application included in ExecuTorch repository [LlamaDemo](https://github.com/pytorch/executorch/tree/main/examples/demo-apps/android/LlamaDemo) to demonstrate local inference with ExecuTorch.
-{{% /notice %}}
 
 1. Open a terminal window and navigate to the root directory of the `executorch` repository.
 
-2. Set the following environment variables:
+2. If you haven't already, set the following environment variables:
 
     ``` bash
-    export ANDROID_NDK=$ANDROID_HOME/ndk/28.0.12433566/
+    export ANDROID_NDK=$ANDROID_HOME/ndk/29.0.14206865/
     export ANDROID_ABI=arm64-v8a
     ```
 
@@ -25,21 +24,12 @@ You can use the Android demo application included in ExecuTorch repository [Llam
 Make sure you can confirm <path_to_android_ndk>/build/cmake/android.toolchain.cmake is available for CMake to cross-compile.
 {{% /notice %}}
 
-3. Run the following commands to set up the required JNI library:
+3. Run the following command to set up the required JNI library:
 
     ``` bash
-    pushd extension/android
-    ./gradlew build
-    popd
-    pushd examples/demo-apps/android/LlamaDemo
-    ./gradlew :app:setup
-    popd
+    sh scripts/build_android_library.sh
     ```
 
-{{% notice Note %}}
-This is running the shell script setup.sh which configures and builds the required core ExecuTorch, Llama, and Android libraries.
-{{% /notice %}}
-
 ## Getting models
 
 Make sure the exported model and tokenizer are copied to the Android phone:
@@ -74,21 +64,26 @@ If the files are not on the device, use the device explorer to copy them.
 
 ## Build the Android Package Kit
 
+Before starting, you need to obtain the example app by cloning `executorch-examples`:
+
+```
+git clone https://github.com/meta-pytorch/executorch-examples.git
+```
+
 ### Option 1: Using Android Studio
 
 This is the recommended option.
 
-1. Open Android Studio and select **Open an existing Android Studio project** and navigate to open `examples/demo-apps/android/LlamaDemo`.
+1. Open Android Studio and select **Open an existing Android Studio project** and navigate to open `executorch-examples/llm/android/LlamaDemo`.
 
 2. Run the app (^R). This builds and launches the app on the phone.
 
 ### Option 2: Command line
 
-Without Android Studio UI, you can run gradle directly to build the app. You need to set up the Android SDK path and invoke gradle.
+Without Android Studio UI, you can run gradle directly to build the app. You need to set up the Android SDK path and invoke gradle. Navigate to the newly cloned `executorch-examples` repository. 
 
 ``` bash
-export ANDROID_HOME=<path_to_android_sdk_home>
-pushd examples/demo-apps/android/LlamaDemo
+pushd llm/android/LlamaDemo
 ./gradlew :app:installDebug
 popd
 ```