TensorFlow Lite di layanan Google Play

Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

TensorFlow Lite tersedia di waktu proses layanan Google Play untuk semua perangkat Android yang menjalankan versi layanan Play saat ini. Waktu proses ini memungkinkan Anda menjalankan model machine learning (ML) tanpa menggabungkan library TensorFlow Lite secara statis ke dalam aplikasi Anda.

Dengan API layanan Google Play, Anda dapat mengurangi ukuran aplikasi dan mendapatkan peningkatan kinerja dari versi terbaru perpustakaan yang stabil. TensorFlow Lite di layanan Google Play adalah cara yang disarankan untuk menggunakan TensorFlow Lite di Android.

Anda dapat memulai runtime layanan Play dengan Quickstart , yang menyediakan panduan langkah demi langkah untuk mengimplementasikan aplikasi sampel. Jika Anda sudah menggunakan TensorFlow Lite yang berdiri sendiri di aplikasi Anda, lihat bagian Migrasi dari TensorFlow Lite yang berdiri sendiri untuk memperbarui aplikasi yang ada agar menggunakan runtime layanan Play. Untuk informasi lebih lanjut tentang layanan Google Play, lihat situs web layanan Google Play .

Menggunakan runtime layanan Play

TensorFlow Lite di layanan Google Play tersedia melalui TensorFlow Lite Task API dan TensorFlow Lite Interpreter API . Pustaka Tugas 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 dan pustaka dukungan, menyediakan antarmuka yang lebih umum untuk membuat dan menjalankan model ML.

Bagian berikut memberikan petunjuk tentang cara menerapkan Interpreter dan Task Library API di layanan Google Play. Meskipun aplikasi dapat menggunakan Interpreter API dan Task Library API, 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 machine learning umum yang menggunakan data visual, audio, dan teks. Anda harus menggunakan API Tugas jika aplikasi Anda memerlukan salah satu tugas yang didukung .

1. Tambahkan dependensi proyek

Ketergantungan proyek Anda bergantung pada kasus penggunaan pembelajaran mesin Anda. Task API berisi library 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 Google Play Services API 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 yang tepat dalam metode detect() bervariasi tergantung pada perpustakaan 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 data, Anda mungkin juga perlu melakukan praproses dan mengonversi data Anda dalam metode detect() sebelum membuat inferensi. 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 Interpreter API

API Interpreter menawarkan lebih banyak kontrol dan fleksibilitas daripada API Perpustakaan Tugas. Anda harus menggunakan Interpreter API jika tugas machine learning Anda tidak didukung oleh Task library, 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 juru bahasa menggunakan InterpreterApi.create() dan konfigurasikan untuk menggunakan waktu proses layanan Google Play, dengan memanggil InterpreterApi.Options.setRuntime() , seperti yang ditunjukkan dalam kode contoh 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 utas antarmuka pengguna Android. Jika Anda perlu mengelola eksekusi utas lebih dekat, Anda dapat menambahkan panggilan Tasks.await() ke pembuatan juru bahasa:

Kotlin

import androidx.lifecycle.lifecycleScope
...
lifecycleScope.launchWhenStarted { // uses coroutine
  initializeTask.await()
}

Jawa

@BackgroundThread
InterpreterApi initializeInterpreter() {
    Tasks.await(initializeTask);
    return InterpreterApi.create(...);
}

4. Jalankan inferensi

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 kinerja 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 perangkat keras berikut dengan TensorFlow Lite di layanan Google Play:

  • Delegasi GPU (disarankan) - Delegasi ini disediakan melalui layanan Google Play dan dimuat secara dinamis, seperti versi layanan Play dari Task API dan Interpreter API.

  • Delegasi NNAPI - Delegasi ini tersedia sebagai dependensi library yang disertakan dalam proyek pengembangan Android Anda, dan dibundel 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 cadangan saat 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 Interpreter 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 API Tugas:

  1. Perbarui dependensi proyek untuk menggunakan delegasi GPU dari layanan Play:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'

  2. Inisialisasi delegasi GPU dengan setEnableGpuDelegateSupport . Misalnya, Anda dapat menginisialisasi delegasi GPU untuk TfLiteVision dengan yang berikut:

    Kotlin

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build())

    Jawa

        TfLiteVision.initialize(context, TfLiteInitializationOptions.builder().setEnableGpuDelegateSupport(true).build());

  3. Aktifkan opsi delegasi GPU dengan BaseOptions :

    Kotlin

        val baseOptions = BaseOptions.builder().useGpu().build()

    Jawa

        BaseOptions baseOptions = BaseOptions.builder().useGpu().build();

  4. Konfigurasikan opsi menggunakan .setBaseOptions . Misalnya, Anda dapat mengatur GPU di ObjectDetector dengan yang berikut:

    Kotlin

        val options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build()

    Jawa

        ObjectDetectorOptions options =
        ObjectDetectorOptions.builder()
            .setBaseOptions(baseOptions)
            .setMaxResults(1)
            .build();

GPU dengan Interpreter API

Untuk menggunakan delegasi GPU dengan Interpreter API:

  1. Perbarui dependensi proyek untuk menggunakan delegasi GPU dari layanan Play:

    implementation 'com.google.android.gms:play-services-tflite-gpu:16.1.0'

  2. Aktifkan opsi delegasi GPU dalam inisialisasi TFlite:

    Kotlin

        TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build())

    Jawa

        TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
       .setEnableGpuDelegateSupport(true)
       .build());

  3. Setel delegasi GPU dalam opsi juru bahasa untuk menggunakan DelegateFactory dengan memanggil addDelegateFactory() dalam 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 untuk memigrasikan aplikasi Anda dari TensorFlow Lite yang berdiri sendiri ke API layanan Play, tinjau panduan tambahan berikut untuk memperbarui kode proyek aplikasi Anda:

  1. Tinjau bagian Batasan halaman ini untuk memastikan kasus penggunaan Anda didukung.
  2. Sebelum memperbarui kode Anda, lakukan pemeriksaan kinerja dan akurasi untuk model Anda, terutama jika Anda menggunakan versi TensorFlow Lite lebih awal dari versi 2.1, sehingga Anda memiliki dasar untuk dibandingkan dengan implementasi baru.
  3. Jika Anda telah memigrasikan semua kode untuk menggunakan API layanan Play untuk TensorFlow Lite, Anda harus menghapus dependensi library runtime TensorFlow Lite yang ada (entri dengan org.tensorflow: tensorflow-lite :* ) dari file build.gradle sehingga Anda dapat mengurangi ukuran aplikasi Anda.
  4. Identifikasi semua kemunculan pembuatan objek new Interpreter dalam kode Anda, dan modifikasi sehingga menggunakan panggilan InterpreterApi.create(). API baru ini tidak sinkron, yang berarti dalam banyak kasus ini bukan pengganti drop-in, dan Anda harus mendaftarkan pendengar saat panggilan selesai. Lihat cuplikan kode pada kode Langkah 3 .
  5. Tambahkan import org.tensorflow.lite.InterpreterApi; dan import org.tensorflow.lite.InterpreterApi.Options.TfLiteRuntime; ke file sumber apa pun menggunakan kelas org.tensorflow.lite.Interpreter atau org.tensorflow.lite.InterpreterApi .
  6. Jika salah satu panggilan yang dihasilkan ke InterpreterApi.create() hanya memiliki satu argumen, tambahkan new InterpreterApi.Options() ke daftar argumen.
  7. Tambahkan .setRuntime(TfLiteRuntime.FROM_SYSTEM_ONLY) ke argumen terakhir dari setiap panggilan ke InterpreterApi.create() .
  8. Ganti semua kemunculan lain dari kelas org.tensorflow.lite.Interpreter dengan org.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.

Keterbatasan

TensorFlow Lite di layanan Google Play memiliki batasan berikut:

  • Dukungan untuk delegasi akselerasi perangkat keras terbatas pada delegasi yang terdaftar di bagian Akselerasi perangkat keras . Tidak ada delegasi akselerasi lain yang didukung.
  • Akses ke TensorFlow Lite melalui API asli tidak didukung. Hanya TensorFlow Lite Java API yang tersedia melalui layanan Google Play.
  • API TensorFlow Lite eksperimental atau yang tidak digunakan lagi, termasuk operasi kustom, tidak didukung.

Dukungan dan umpan balik

Anda dapat memberikan masukan dan mendapatkan dukungan melalui Pelacak Masalah TensorFlow. Laporkan masalah dan permintaan dukungan menggunakan template Masalah untuk TensorFlow Lite di layanan Google Play.

Persyaratan layanan

Penggunaan TensorFlow Lite di API layanan Google Play tunduk pada Persyaratan Layanan Google API .

Privasi dan pengumpulan data

Saat Anda menggunakan TensorFlow Lite di API layanan Google Play, pemrosesan data input, seperti gambar, video, teks, sepenuhnya terjadi di perangkat, dan TensorFlow Lite di API layanan Google Play tidak mengirimkan data tersebut ke server Google. Akibatnya, Anda dapat menggunakan API kami untuk memproses data yang tidak boleh keluar dari perangkat.

TensorFlow Lite di API layanan Google Play dapat menghubungi server Google dari waktu ke waktu untuk menerima hal-hal seperti perbaikan bug, model yang diperbarui, dan informasi kompatibilitas akselerator perangkat keras. TensorFlow Lite di API layanan Google Play juga mengirimkan metrik tentang kinerja dan pemanfaatan API di aplikasi Anda ke Google. Google menggunakan data metrik ini untuk mengukur kinerja, men-debug, memelihara dan meningkatkan API, dan mendeteksi penyalahgunaan atau penyalahgunaan, seperti yang dijelaskan lebih lanjut dalam Kebijakan Privasi kami .

Anda bertanggung jawab untuk memberi tahu pengguna aplikasi Anda tentang pemrosesan TensorFlow Lite oleh Google di data metrik API layanan Google Play sebagaimana diwajibkan oleh hukum yang berlaku.

Data yang kami kumpulkan meliputi:

  • Informasi perangkat (seperti pabrikan, model, versi dan build OS) dan akselerator perangkat keras ML yang tersedia (GPU dan DSP). Digunakan untuk diagnostik dan analitik penggunaan.
  • Pengenal perangkat yang digunakan untuk diagnostik dan analisis penggunaan.
  • Informasi aplikasi (nama paket, versi aplikasi). Digunakan untuk diagnostik dan analitik penggunaan.
  • Konfigurasi API (seperti delegasi mana yang digunakan). Digunakan untuk diagnostik dan analitik penggunaan.
  • Jenis peristiwa (seperti pembuatan juru bahasa, inferensi). Digunakan untuk diagnostik dan analitik penggunaan.
  • Kode kesalahan. Digunakan untuk diagnostik.
  • Metrik kinerja. Digunakan untuk diagnostik.

Langkah selanjutnya

Untuk informasi selengkapnya tentang menerapkan pembelajaran mesin di aplikasi seluler Anda dengan TensorFlow Lite, lihat Panduan Pengembang TensorFlow Lite . Anda dapat menemukan model TensorFlow Lite tambahan untuk klasifikasi gambar, deteksi objek, dan aplikasi lain di TensorFlow Hub .