Memperkenalkan LiteRT: Runtime Google berperforma tinggi untuk AI di perangkat, yang sebelumnya dikenal sebagai TensorFlow Lite.

Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat LiteRT untuk Android

Dokumen ini menjelaskan cara mem-build library Android LiteRT di sendiri. Biasanya, Anda tidak perlu membangun library LiteRT Android secara lokal. Jika Anda hanya ingin menggunakannya, lihat Panduan memulai Android untuk detail selengkapnya tentang cara menggunakannya di project Android Anda.

Gunakan Snapshot Malam

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

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. Sebagai misalnya, Anda dapat membuat biner khusus yang berisi operasi yang dipilih dari TensorFlow, atau Anda mungkin ingin membuat perubahan lokal pada LiteRT.

Menyiapkan lingkungan build menggunakan Docker

Download file Docker. Dengan mengunduh file Docker, Anda setuju bahwa persyaratan layanan berikut mengatur penggunaannya:

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

Anda dapat mengubah versi Android SDK atau NDK secara opsional. Letakkan yang sudah didownload Docker dalam 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 TensorFlow repositori 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, pasang 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 ):

sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

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

Setelah selesai membangun library, Anda dapat menyalinnya ke /host_dir di dalam container sehingga Anda dapat mengaksesnya di {i>host<i}.

Menyiapkan lingkungan build tanpa Docker

Instal Prasyarat Bazel dan Android

Bazel adalah sistem build utama untuk TensorFlow. Untuk membangun dengannya, Anda harus dan Android NDK serta SDK yang terinstal di sistem Anda.

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

Mengonfigurasi WORKSPACE dan .bazelrc

Ini adalah langkah konfigurasi satu kali yang diperlukan untuk membangun LiteRT library. Jalankan skrip ./configure di 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 tidak ditetapkan, variabel ini harus disediakan secara interaktif dalam 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 membangun 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

Tindakan ini akan menghasilkan file AAR di bazel-bin/tensorflow/lite/java/. Catatan bahwa tindakan ini akan membentuk "lemak" AAR dengan beberapa arsitektur yang berbeda; jika Anda tidak memerlukan semuanya, gunakan subset yang sesuai untuk lingkungan deployment Anda.

Anda dapat membuat file AAR berukuran 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, tensorflow-lite-select-tf-ops.aar jika salah satu model menggunakan Operasi TensorFlow. Untuk detail selengkapnya, lihat Bagian Kurangi ukuran biner LiteRT.

Menambahkan AAR langsung ke project

Pindahkan file tensorflow-lite.aar ke direktori bernama libs di proyek. Ubah file build.gradle aplikasi Anda untuk merujuk direktori baru dan mengganti dependensi LiteRT yang ada dengan library lokal baru, e.g.:

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')
}

Instal 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 mengganti 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 hanya untuk tujuan pengujian/pengembangan. Dengan AAR lokal yang terinstal, Anda dapat menggunakan API inferensi Java LiteRT dalam kode aplikasi Anda.