TensorFlow Lite di layanan Google Play juga dapat diakses menggunakan Java API, selain Native API. Secara khusus, TensorFlow Lite di layanan Google Play tersedia melalui TensorFlow Lite Task API dan TensorFlow Lite Interpreter API . Task Library menyediakan antarmuka model siap pakai yang dioptimalkan untuk tugas pembelajaran mesin umum menggunakan data visual, audio, dan teks. TensorFlow Lite Interpreter API, yang disediakan oleh runtime TensorFlow, menyediakan antarmuka yang lebih umum untuk membuat dan menjalankan model ML.
Bagian berikut memberikan petunjuk tentang cara menggunakan Interpreter dan Task Library API dengan TensorFlow Lite di layanan Google Play. Meskipun aplikasi dapat menggunakan API Interpreter dan API Task Library, sebagian besar aplikasi hanya boleh menggunakan satu set API.
Menggunakan API Perpustakaan Tugas
TensorFlow Lite Task API menggabungkan Interpreter API dan menyediakan antarmuka pemrograman tingkat tinggi untuk tugas-tugas machine learning umum yang menggunakan data visual, audio, dan teks. Anda harus menggunakan Task API jika aplikasi Anda memerlukan salah satu tugas yang didukung .
1. Tambahkan dependensi proyek
Ketergantungan proyek Anda bergantung pada kasus penggunaan pembelajaran mesin Anda. API Tugas berisi pustaka berikut:
- Pustaka visi:
org.tensorflow:tensorflow-lite-task-vision-play-services
- Pustaka audio:
org.tensorflow:tensorflow-lite-task-audio-play-services
- Pustaka teks:
org.tensorflow:tensorflow-lite-task-text-play-services
Tambahkan salah satu dependensi ke kode proyek aplikasi Anda untuk mengakses API layanan Play untuk TensorFlow Lite. Misalnya, gunakan yang berikut ini untuk mengimplementasikan tugas visi:
dependencies {
...
implementation 'org.tensorflow:tensorflow-lite-task-vision-play-services:0.4.2'
...
}
2. Tambahkan inisialisasi TensorFlow Lite
Inisialisasi komponen TensorFlow Lite dari API layanan Google Play sebelum menggunakan TensorFlow Lite API. Contoh berikut menginisialisasi perpustakaan visi:
Kotlin
init { TfLiteVision.initialize(context) }
3. Jalankan inferensi
Setelah menginisialisasi komponen TensorFlow Lite, panggil metode detect()
untuk menghasilkan inferensi. Kode persisnya dalam metode detect()
bervariasi bergantung pada pustaka dan kasus penggunaan. Berikut ini adalah kasus penggunaan deteksi objek sederhana dengan pustaka TfLiteVision
:
Kotlin
fun detect(...) { if (!TfLiteVision.isInitialized()) { Log.e(TAG, "detect: TfLiteVision is not initialized yet") return } if (objectDetector == null) { setupObjectDetector() } ... }
Bergantung pada format datanya, Anda mungkin juga perlu melakukan praproses dan mengonversi data Anda dalam metode detect()
sebelum membuat kesimpulan. Misalnya, data gambar untuk detektor objek memerlukan hal berikut:
val imageProcessor = ImageProcessor.Builder().add(Rot90Op(-imageRotation / 90)).build()
val tensorImage = imageProcessor.process(TensorImage.fromBitmap(image))
val results = objectDetector?.detect(tensorImage)
Menggunakan API Interpreter
API Interpreter menawarkan lebih banyak kontrol dan fleksibilitas dibandingkan API Task Library. Anda harus menggunakan API Interpreter jika tugas pembelajaran mesin Anda tidak didukung oleh pustaka Tugas, atau jika Anda memerlukan antarmuka yang lebih umum untuk membuat dan menjalankan model ML.
1. Tambahkan dependensi proyek
Tambahkan dependensi berikut ke kode proyek aplikasi Anda untuk mengakses API layanan Play untuk TensorFlow Lite:
dependencies {
...
// Tensorflow Lite dependencies for Google Play services
implementation 'com.google.android.gms:play-services-tflite-java:16.0.1'
// Optional: include Tensorflow Lite Support Library
implementation 'com.google.android.gms:play-services-tflite-support:16.0.1'
...
}
2. Tambahkan inisialisasi TensorFlow Lite
Inisialisasi komponen TensorFlow Lite dari Google Play services API sebelum menggunakan TensorFlow Lite API:
Kotlin
val initializeTask: Task<Void> by lazy { TfLite.initialize(this) }
Jawa
Task<Void> initializeTask = TfLite.initialize(context);
3. Buat Interpreter dan atur opsi runtime
Buat penerjemah menggunakan InterpreterApi.create()
dan konfigurasikan untuk menggunakan runtime layanan Google Play, dengan memanggil InterpreterApi.Options.setRuntime()
, seperti yang ditunjukkan dalam contoh kode berikut:
Kotlin
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private lateinit var interpreter: InterpreterApi ... initializeTask.addOnSuccessListener { val interpreterOption = InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) interpreter = InterpreterApi.create( modelBuffer, interpreterOption )} .addOnFailureListener { e -> Log.e("Interpreter", "Cannot initialize interpreter", e) }
Jawa
import org.tensorflow.lite.InterpreterApi import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime ... private InterpreterApi interpreter; ... initializeTask.addOnSuccessListener(a -> { interpreter = InterpreterApi.create(modelBuffer, new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)); }) .addOnFailureListener(e -> { Log.e("Interpreter", String.format("Cannot initialize interpreter: %s", e.getMessage())); });
Anda harus menggunakan implementasi di atas karena menghindari pemblokiran thread antarmuka pengguna Android. Jika Anda perlu mengelola eksekusi thread dengan lebih cermat, Anda dapat menambahkan panggilan Tasks.await()
ke pembuatan interpreter:
Kotlin
import androidx.lifecycle.lifecycleScope ... lifecycleScope.launchWhenStarted { // uses coroutine initializeTask.await() }
Jawa
@BackgroundThread InterpreterApi initializeInterpreter() { Tasks.await(initializeTask); return InterpreterApi.create(...); }
4. Jalankan inferensi
Dengan menggunakan objek interpreter
yang Anda buat, panggil metode run()
untuk menghasilkan inferensi.
Kotlin
interpreter.run(inputBuffer, outputBuffer)
Jawa
interpreter.run(inputBuffer, outputBuffer);
Akselerasi perangkat keras
TensorFlow Lite memungkinkan Anda mempercepat performa model menggunakan prosesor perangkat keras khusus, seperti unit pemrosesan grafis (GPU). Anda dapat memanfaatkan prosesor khusus ini menggunakan driver perangkat keras yang disebut delegasi . Anda dapat menggunakan delegasi akselerasi hardware berikut dengan TensorFlow Lite di layanan Google Play:
Delegasi GPU (disarankan) - Delegasi ini disediakan melalui layanan Google Play dan dimuat secara dinamis, sama seperti versi layanan Play dari Task API dan Interpreter API.
Delegasi NNAPI - Delegasi ini tersedia sebagai dependensi perpustakaan yang disertakan dalam proyek pengembangan Android Anda, dan digabungkan ke dalam aplikasi Anda.
Untuk informasi selengkapnya tentang akselerasi perangkat keras dengan TensorFlow Lite, lihat halaman Delegasi TensorFlow Lite .
Memeriksa kompatibilitas perangkat
Tidak semua perangkat mendukung akselerasi perangkat keras GPU dengan TFLite. Untuk mengurangi kesalahan dan potensi kerusakan, gunakan metode TfLiteGpu.isGpuDelegateAvailable
untuk memeriksa apakah perangkat kompatibel dengan delegasi GPU.
Gunakan metode ini untuk mengonfirmasi apakah perangkat kompatibel dengan GPU, dan gunakan CPU atau delegasi NNAPI sebagai pengganti ketika GPU tidak didukung.
useGpuTask = TfLiteGpu.isGpuDelegateAvailable(context)
Setelah Anda memiliki variabel seperti useGpuTask
, Anda dapat menggunakannya untuk menentukan apakah perangkat menggunakan delegasi GPU. Contoh berikut menunjukkan bagaimana hal ini dapat dilakukan dengan Task Library dan Interpreter API.
Dengan Tugas Api
Kotlin
lateinit val optionsTask = useGpuTask.continueWith { task -> val baseOptionsBuilder = BaseOptions.builder() if (task.result) { baseOptionsBuilder.useGpu() } ObjectDetectorOptions.builder() .setBaseOptions(baseOptionsBuilder.build()) .setMaxResults(1) .build() }
Jawa
Task<ObjectDetectorOptions> optionsTask = useGpuTask.continueWith({ task -> BaseOptions baseOptionsBuilder = BaseOptions.builder(); if (task.getResult()) { baseOptionsBuilder.useGpu(); } return ObjectDetectorOptions.builder() .setBaseOptions(baseOptionsBuilder.build()) .setMaxResults(1) .build() });
Dengan Penerjemah Api
Kotlin
val interpreterTask = useGpuTask.continueWith { task -> val interpreterOptions = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) if (task.result) { interpreterOptions.addDelegateFactory(GpuDelegateFactory()) } InterpreterApi.create(FileUtil.loadMappedFile(context, MODEL_PATH), interpreterOptions) }
Jawa
Task<InterpreterApi.Options> interpreterOptionsTask = useGpuTask.continueWith({ task -> InterpreterApi.Options options = new InterpreterApi.Options().setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY); if (task.getResult()) { options.addDelegateFactory(new GpuDelegateFactory()); } return options; });
GPU dengan API Perpustakaan Tugas
Untuk menggunakan delegasi GPU dengan Task API:
Perbarui dependensi proyek untuk menggunakan delegasi GPU dari layanan Play:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
Inisialisasi delegasi GPU dengan
setEnableGpuDelegateSupport
. Misalnya, Anda dapat menginisialisasi delegasi GPU untukTfLiteVision
dengan yang berikut ini:Kotlin
TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())
Jawa
TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());
Aktifkan opsi delegasi GPU dengan
BaseOptions
:Kotlin
val baseOptions = BaseOptions.builder().useGpu().build()
Jawa
BaseOptions baseOptions = BaseOptions.builder().useGpu().build();
Konfigurasikan opsi menggunakan
.setBaseOptions
. Misalnya, Anda dapat mengatur GPU diObjectDetector
dengan yang berikut ini:Kotlin
val options = ObjectDetectorOptions.builder() .setBaseOptions(baseOptions) .setMaxResults(1) .build()
Jawa
ObjectDetectorOptions options = ObjectDetectorOptions.builder() .setBaseOptions(baseOptions) .setMaxResults(1) .build();
GPU dengan API Interpreter
Untuk menggunakan delegasi GPU dengan Interpreter API:
Perbarui dependensi proyek untuk menggunakan delegasi GPU dari layanan Play:
implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'
Aktifkan opsi delegasi GPU di inisialisasi TFlite:
Kotlin
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build())
Jawa
TfLite.initialize(context, TfLiteInitializationOptions.builder() .setEnableGpuDelegateSupport(true) .build());
Aktifkan delegasi GPU dalam opsi penerjemah: atur pabrik delegasi ke GpuDelegateFactory dengan memanggil
addDelegateFactory() within
InterpreterApi.Options()`:Kotlin
val interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(GpuDelegateFactory())
Jawa
Options interpreterOption = InterpreterApi.Options() .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) .addDelegateFactory(new GpuDelegateFactory());
Bermigrasi dari TensorFlow Lite yang berdiri sendiri
Jika Anda berencana memigrasikan aplikasi dari TensorFlow Lite yang berdiri sendiri ke API layanan Play, tinjau panduan tambahan berikut untuk memperbarui kode proyek aplikasi Anda:
- Tinjau bagian Batasan di halaman ini untuk memastikan kasus penggunaan Anda didukung.
- Sebelum mengupdate kode, lakukan pemeriksaan performa dan akurasi untuk model Anda, terutama jika Anda menggunakan versi TensorFlow Lite sebelum versi 2.1, sehingga Anda memiliki dasar untuk membandingkannya dengan implementasi baru.
- Jika Anda telah memigrasikan semua kode untuk menggunakan API layanan Play untuk TensorFlow Lite, Anda harus menghapus dependensi pustaka waktu proses TensorFlow Lite yang ada (entri dengan
org.tensorflow: tensorflow-lite :*
) dari file build.gradle sehingga Anda dapat mengurangi ukuran aplikasi Anda. - Identifikasi semua kemunculan pembuatan objek
new Interpreter
dalam kode Anda, dan modifikasi setiap kemunculannya sehingga menggunakan panggilan InterpreterApi.create(). TfLite.initialize yang baru bersifat asinkron, yang berarti dalam banyak kasus ini bukan pengganti drop-in: Anda harus mendaftarkan pendengar ketika panggilan selesai. Lihat cuplikan kode pada kode Langkah 3 . - Tambahkan
import org.tensorflow.lite.InterpreterApi;
danimport org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime;
ke file sumber apa pun menggunakan kelasorg.tensorflow.lite.Interpreter
atauorg.tensorflow.lite.InterpreterApi
. - Jika salah satu panggilan yang dihasilkan ke
InterpreterApi.create()
hanya memiliki satu argumen, tambahkannew InterpreterApi.Options()
ke daftar argumen. - Tambahkan
.setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY)
ke argumen terakhir dari setiap panggilan keInterpreterApi.create()
. - Ganti semua kemunculan kelas
org.tensorflow.lite.Interpreter
lainnya denganorg.tensorflow.lite.InterpreterApi
.
Jika Anda ingin menggunakan TensorFlow Lite yang berdiri sendiri dan API layanan Play secara berdampingan, Anda harus menggunakan TensorFlow Lite 2.9 (atau lebih baru). TensorFlow Lite 2.8 dan versi sebelumnya tidak kompatibel dengan versi API layanan Play.