Membangun TensorFlow Lite untuk Android

Dokumen ini menjelaskan cara mem-build library Android TensorFlow Lite sendiri. Biasanya, Anda tidak perlu mem-build library Android TensorFlow Lite secara lokal. Jika Anda hanya ingin menggunakannya, lihat panduan memulai Android untuk mengetahui detail selengkapnya tentang cara menggunakannya dalam project Android.

Menggunakan Ringkasan Malam

Untuk menggunakan snapshot setiap malam, tambahkan repo berikut ke konfigurasi build root Gradle 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'
        }
    }
}

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

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'org.tensorflow:tensorflow-lite-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'org.tensorflow:tensorflow-lite-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

Mem-build TensorFlow Lite secara lokal

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

Menyiapkan lingkungan build menggunakan Docker

  • Mendownload file Docker. Dengan mendownload file Docker, Anda setuju bahwa persyaratan layanan berikut mengatur penggunaannya:

Dengan mengklik setuju, dengan ini Anda menyetujui bahwa semua penggunaan Android Studio dan Android Native Development Kit akan diatur oleh Perjanjian Lisensi Software Development Kit Android 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 tersebut.

  • Anda dapat memilih untuk mengubah versi Android SDK atau NDK. Tempatkan file Docker yang didownload ke folder kosong dan bangun image docker 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 pada host, instal direktori host tersebut (-v hostDir:/host_dir).

  • Setelah berada di dalam container, Anda dapat menjalankan perintah berikut untuk mendownload alat dan library Android tambahan (perhatikan bahwa Anda mungkin perlu menyetujui lisensinya):
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 mem-build library, Anda dapat menyalinnya ke /host_dir dalam penampung sehingga Anda dapat mengaksesnya di host.

Menyiapkan lingkungan build tanpa Docker

Instal Prasyarat Bazel dan Android

Bazel adalah sistem build utama untuk TensorFlow. Untuk membangun dengan aplikasi ini, Anda harus menginstalnya serta Android NDK dan SDK di sistem Anda.

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

Mengonfigurasi WORKSPACE dan .bazelrc

Ini adalah langkah konfigurasi satu kali yang diperlukan untuk mem-build library TF Lite. Jalankan skrip ./configure di direktori checkout TensorFlow root, dan jawab "Ya" saat skrip meminta untuk mengonfigurasi ./WORKSPACE secara interaktif untuk build Android. Skrip ini akan mencoba mengonfigurasi setelan menggunakan variabel lingkungan berikut:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

Jika tidak ditetapkan, variabel ini harus disediakan secara interaktif di perintah skrip. Konfigurasi yang berhasil akan menghasilkan entri yang serupa dengan yang berikut 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"

Membuat dan menginstal

Setelah Bazel dikonfigurasi dengan benar, Anda dapat mem-build AAR TensorFlow Lite dari direktori root checkout 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/. Perlu diketahui bahwa cara ini membangun AAR "gemuk" dengan beberapa arsitektur berbeda; jika Anda tidak memerlukan semuanya, gunakan subset yang sesuai untuk lingkungan deployment Anda.

Anda dapat membangun file AAR yang lebih kecil yang hanya menargetkan sekumpulan model seperti 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 TensorFlow Lite.

Menambahkan AAR secara langsung ke project

Pindahkan file tensorflow-lite.aar ke direktori bernama libs di project Anda. Ubah file build.gradle aplikasi Anda untuk merujuk direktori baru dan mengganti dependensi TensorFlow Lite 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, pastikan Anda memiliki dependensi mavenLocal() dan ganti dependensi TensorFlow Lite 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 hanya untuk keperluan pengujian/pengembangan. Setelah AAR lokal diinstal, Anda dapat menggunakan API inferensi Java TensorFlow Lite standar dalam kode aplikasi Anda.