Membuat LiteRT untuk Android

Dokumen ini menjelaskan cara mem-build library Android LiteRT sendiri. Biasanya, Anda tidak perlu membuat library Android LiteRT secara lokal.

Menggunakan Snapshot Malam

Untuk menggunakan snapshot malam, tambahkan repo berikut ke konfigurasi build Gradle root Anda.

allprojects {
    repositories {      // should be already there
        mavenCentral()  // should be already there
        maven {         // add this repo to use snapshots
          name 'ossrh-snapshot'
          url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
    }
}

Tambahkan snapshot malam ke dependensi (atau edit sesuai kebutuhan) ke build.gradle Anda

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Membangun LiteRT secara lokal

Dalam beberapa kasus, Anda mungkin ingin menggunakan build lokal LiteRT. Misalnya, Anda mungkin membuat biner kustom yang mencakup operasi yang dipilih dari TensorFlow, atau Anda mungkin ingin membuat perubahan lokal pada LiteRT.

Menyiapkan lingkungan build menggunakan Docker

  • Download file Docker. Dengan mendownload file Docker, Anda menyetujui bahwa persyaratan layanan berikut mengatur penggunaan Anda atas file tersebut:

Dengan mengklik untuk menyetujui, Anda dengan ini menyetujui bahwa semua penggunaan Android Studio dan Android Native Development Kit akan diatur oleh Perjanjian Lisensi Android Software Development Kit yang tersedia di https://developer.android.com/studio/terms (URL tersebut dapat diperbarui atau diubah oleh Google dari waktu ke waktu).

Anda harus menyetujui persyaratan layanan untuk mendownload file.

  • Anda dapat mengubah versi Android SDK atau NDK secara opsional. Letakkan file Docker yang didownload di folder kosong dan bangun image Docker Anda dengan menjalankan:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • Mulai container Docker secara interaktif dengan memasang folder saat ini ke /host_dir di dalam container (perhatikan bahwa /tensorflow_src adalah repositori TensorFlow di dalam container):
docker run -it -v $PWD:/host_dir tflite-builder bash

Jika Anda menggunakan PowerShell di Windows, ganti "$PWD" dengan "pwd".

Jika Anda ingin menggunakan repositori TensorFlow di host, pasang direktori host tersebut (-v hostDir:/host_dir).

  • Setelah berada di dalam penampung, Anda dapat menjalankan perintah berikut untuk mendownload alat dan library Android tambahan (perhatikan bahwa Anda mungkin perlu menyetujui lisensi):
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

Sekarang Anda harus melanjutkan ke bagian Mengonfigurasi WORKSPACE dan .bazelrc untuk mengonfigurasi setelan build.

Setelah selesai membangun library, Anda dapat menyalinnya ke /host_dir di dalam penampung sehingga Anda dapat mengaksesnya di host.

Menyiapkan lingkungan build tanpa Docker

Menginstal Bazel dan Prasyarat Android

Bazel adalah sistem build utama untuk TensorFlow. Untuk mem-build dengan alat ini, Anda harus menginstalnya beserta Android NDK dan SDK di sistem Anda.

  1. Instal sistem build Bazel versi terbaru.
  2. Android NDK diperlukan untuk membuat kode LiteRT native (C/C++). Versi yang direkomendasikan saat ini adalah 25b, yang dapat ditemukan di sini.
    1. Android SDK dan alat build dapat diperoleh di sini, atau sebagai bagian dari Android Studio. Alat build API >= 23 adalah versi yang direkomendasikan untuk membangun LiteRT.

Mengonfigurasi WORKSPACE dan .bazelrc

Ini adalah langkah konfigurasi satu kali yang diperlukan untuk membuat pustaka LiteRT. Jalankan skrip ./configure di direktori checkout TensorFlow root, dan jawab "Yes" saat skrip meminta untuk mengonfigurasi ./WORKSPACE secara interaktif untuk build Android. Skrip akan mencoba mengonfigurasi setelan menggunakan variabel lingkungan berikut:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Jika variabel ini tidak ditetapkan, variabel tersebut harus diberikan secara interaktif dalam perintah skrip. Konfigurasi yang berhasil akan menghasilkan entri yang mirip dengan berikut ini dalam file .tf_configure.bazelrc di folder root:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r25b"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="30.0.3"
build --action_env ANDROID_SDK_API_LEVEL="30"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

Membangun dan menginstal

Setelah Bazel dikonfigurasi dengan benar, Anda dapat membuat AAR LiteRT dari direktori checkout root sebagai berikut:

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm64 \
  --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --define=android_dexmerger_tool=d8_dexmerger \
  --define=android_incremental_dexing_tool=d8_dexbuilder \
  //tensorflow/lite/java:tensorflow-lite

Langkah ini akan menghasilkan file AAR di bazel-bin/tensorflow/lite/java/. Perhatikan bahwa ini membangun AAR "gemuk" dengan beberapa arsitektur yang berbeda; jika Anda tidak memerlukan semuanya, gunakan subset yang sesuai untuk lingkungan deployment Anda.

Anda dapat membuat file AAR yang lebih kecil yang hanya menargetkan sekumpulan model sebagai berikut:

bash tensorflow/lite/tools/build_aar.sh \
  --input_models=model1,model2 \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Skrip di atas akan menghasilkan file tensorflow-lite.aar dan secara opsional file tensorflow-lite-select-tf-ops.aar jika salah satu model menggunakan operasi Tensorflow. Untuk mengetahui detail selengkapnya, lihat bagian Mengurangi ukuran biner LiteRT.

Menambahkan AAR langsung ke project

Pindahkan file tensorflow-lite.aar ke direktori bernama libs di project Anda. Ubah file build.gradle aplikasi Anda untuk mereferensikan direktori baru dan ganti dependensi LiteRT yang ada dengan library lokal baru, misalnya:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        flatDir {
            dirs 'libs'
        }
    }
}

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}

Menginstal AAR ke repositori Maven lokal

Jalankan perintah berikut dari direktori checkout root Anda:

mvn install:install-file \
  -Dfile=bazel-bin/tensorflow/lite/java/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar

Di build.gradle aplikasi Anda, pastikan Anda memiliki dependensi mavenLocal() dan ganti dependensi LiteRT standar dengan dependensi yang memiliki dukungan untuk operasi TensorFlow tertentu:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
}

Perhatikan bahwa versi 0.1.100 di sini murni untuk tujuan pengujian/pengembangan. Dengan AAR lokal yang diinstal, Anda dapat menggunakan LiteRT Java inference API standar dalam kode aplikasi Anda.