LiteRT di runtime layanan Google Play memungkinkan Anda menjalankan model machine learning (ML) tanpa memaketkan library LiteRT secara statis ke dalam aplikasi Anda. Panduan ini memberikan petunjuk tentang cara menggunakan API C atau C++ untuk layanan Google Play.
Sebelum menggunakan LiteRT di C API atau C++ API layanan Google Play, pastikan Anda telah menginstal alat build CMake.
Memperbarui konfigurasi build
(1) Tambahkan dependensi berikut ke kode project aplikasi Anda untuk mengakses Play Services API untuk LiteRT:
implementation "com.google.android.gms:play-services-tflite-java:16.4.0"
Perhatikan bahwa meskipun nama paket berakhiran -java, paket tersebut juga berisi
API C dan C++.
(2) Kemudian, aktifkan fitur Prefab untuk mengakses C API dari skrip CMake dengan mengupdate blok android file build.gradle modul Anda:
buildFeatures {
prefab = true
}
(3) [Khusus C++ API] Jika Anda menggunakan C++ API, salin
tflite-java-extract-cpp-sdk.gradle
ke project Anda, di direktori app, dan tambahkan kode berikut ke awal
skrip gradle aplikasi Anda (misalnya, app/build.gradle):
apply from: 'tflite-java-extract-cpp-sdk.gradle'
File ini berisi kode Gradle untuk mengekstrak C++ SDK secara otomatis dari
file AAR untuk play-services-tflite-java.
(4) [Khusus C++ API] Jika Anda menggunakan C++ API, temukan direktori yang
berisi file konfigurasi CMake aplikasi Anda (biasanya CMakeLists.txt); direktori
tersebut biasanya adalah direktori app/src/main/cpp Anda. Kemudian, salin
Findtflite_cc_api.cmake
ke project Anda, di subdirektori Modules baru dari direktori tersebut.
File ini berisi kode yang menemukan C++ SDK yang diekstrak oleh skrip Gradle di
langkah sebelumnya.
(5) Terakhir, Anda perlu menambahkan paket tensorflowlite_jni_gms_client, dan
untuk C++ API juga paket tflite_cc_api, yang keduanya diimpor
dari AAR, sebagai dependensi dalam skrip CMake Anda:
C
``` find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG) # Siapkan flag compiler C/C++ untuk mengaktifkan penggunaan TFLite di layanan Play # (bukan TFLite reguler yang dipaketkan dengan aplikasi). add_compile_definitions(TFLITE_IN_GMSCORE) add_compile_definitions(TFLITE_WITH_STABLE_ABI) target_link_libraries(tflite-jni # your JNI lib target tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client android # other deps for your target log) ```C++
``` # Menyiapkan TFLite di dependensi C API layanan Play (tensorflowlite_jni_gms_client). find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG) # Menyiapkan TFLite dalam dependensi C++ API (tflite_cc_api) layanan Play. list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Modules") find_package(tflite_cc_api REQUIRED MODULE) include_directories(${tflite_cc_api_INCLUDE_DIR}) add_subdirectory(${tflite_cc_api_DIR} tflite_cc_api_build) # Set up C/C++ compiler flags to enable use of TFLite in Play services # (rather than regular TFLite bundled with the app). add_compile_definitions(TFLITE_IN_GMSCORE) add_compile_definitions(TFLITE_WITH_STABLE_ABI) target_link_libraries(tflite-jni # your JNI lib target tflite_cc_api::tflite_cc_api tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client android # other deps for your target log) ```Melakukan inisialisasi runtime LiteRT
Sebelum memanggil LiteRT Native API, Anda harus melakukan inisialisasi
runtime TfLiteNative dalam kode Java atau Kotlin.
Java
Task tfLiteInitializeTask = TfLiteNative.initialize(context);
Kotlin
val tfLiteInitializeTask: Task= TfLiteNative.initialize(context)
Dengan menggunakan Task API layanan Google Play, TfLiteNative.initialize
memuat runtime TFLite secara asinkron dari layanan Google Play ke dalam
proses runtime aplikasi Anda. Gunakan addOnSuccessListener() untuk memastikan
tugas TfLite.initialize() selesai sebelum mengeksekusi kode yang mengakses
LiteRT API. Setelah tugas berhasil diselesaikan, Anda dapat memanggil
semua TFLite Native API yang tersedia.
Implementasi kode native
Untuk menggunakan LiteRT di layanan Google Play dengan kode C/C++, Anda dapat melakukan salah satu (atau keduanya) hal berikut:
- mendeklarasikan fungsi JNI baru untuk memanggil fungsi C atau C++ dari kode Java Anda
- memanggil LiteRT Native API dari kode C atau C++ yang ada.
Fungsi JNI
Anda dapat mendeklarasikan fungsi JNI baru agar runtime LiteRT yang dideklarasikan dalam kode C/C++ dapat diakses oleh kode Java/Kotlin Anda sebagai berikut:
Java
package com.google.samples.gms.tflite.c; public class TfLiteJni { static { System.loadLibrary("tflite-jni"); } public TfLiteJni() { /**/ }; public native void loadModel(AssetManager assetManager, String assetName); public native float[] runInference(float[] input); // For example. }
Kotlin
package com.google.samples.gms.tflite.c class TfLiteJni() { companion object { init { System.loadLibrary("tflite-jni") } } external fun loadModel(assetManager: AssetManager, assetName: String) external fun runInference(input: FloatArray): FloatArray // For example. }
Mencocokkan fungsi C atau C++ loadModel dan runInference berikut:
#ifdef __cplusplus
extern "C" {
#endif
void Java_com_google_samples_gms_tflite_c_loadModel(
JNIEnv *env, jobject tflite_jni, jobject asset_manager, jstring asset_name){
//...
}
jfloatArray Java_com_google_samples_gms_tflite_c_TfLiteJni_runInference(
JNIEnv* env, jobject tfliteJni, jfloatArray input) {
//...
}
#ifdef __cplusplus
} // extern "C".
#endif
Kemudian, Anda dapat memanggil fungsi C/C++ dari kode Java/Kotlin:
Java
tfLiteHandleTask.onSuccessTask(unused -> { TfLiteJni jni = new TfLiteJni(); jni.loadModel(getAssets(), "add.bin"); //... });
Kotlin
tfLiteHandleTask.onSuccessTask { val jni = TfLiteJni() jni.loadModel(assets, "add.bin") // ... }
LiteRT dalam kode native
Sertakan file header API yang sesuai untuk menyertakan LiteRT dengan API layanan Google Play:
C
``` #include "tensorflow/lite/c/c_api.h" ```C++
``` #include "tensorflow/lite/interpreter.h" #include "tensorflow/lite/model_builder.h" ```Kemudian, Anda dapat menggunakan LiteRT C atau C++ API reguler: