Menguasai kecerdasan di perangkat dengan ML Kit dan LiteRT di layanan Google Play

Selamat malam, semuanya.

Kita akan memulai diskusi.

Jadi, saat orang mengatakan "AI di perangkat" saat ini, yang mereka maksud sering kali adalah LLM.

Sebelumnya, Anda telah melihat beberapa pembahasan tentang Gemini Nano yang dibahas dengan ML Kit, Firebase, dan banyak produk Google lainnya.

Sesi ini membahas bagian lainnya: ML klasik dan model yang Anda bawa sendiri.

Anda mungkin telah menggunakannya beberapa kali hari ini tanpa menyadarinya.

Pikirkan penggunaan aplikasi apa pun yang Anda gunakan untuk memburamkan latar belakang, menggunakan pemindai kode batang, atau menggunakan semacam pengeditan gambar.

Sebagian besar di antaranya menggunakan ML klasik, dan biasanya bahkan berjalan di perangkat.

Jika Anda pernah menambahkan salah satu fitur ini ke aplikasi atau APK Anda sendiri, Anda sering kali menghadapi konsekuensi ini: apakah saya pada dasarnya menggunakan API siap pakai, atau apakah saya membawa model saya sendiri?

Apa dampaknya terhadap ukuran aplikasi saya?

Hari ini, Anda akan melihat bahwa Anda tidak perlu memilih antara solusi siap pakai atau membawa model Anda sendiri.

Anda dapat melakukan keduanya dengan satu runtime yang ramping.

Nama saya Chintan Parikh.

Saya adalah product manager untuk LiteRT, dan bersama saya adalah Fergus, engineering lead untuk layanan ML Android.

Halo.

Pada akhirnya, Anda akan melihat cara membuat satu aplikasi yang menjalankan dua model di setiap frame kamera dengan kecepatan sekitar 30 frame per detik.

Jadi, ada empat bagian dalam pembahasan ini.

Bagian pertama adalah kita akan membahas solusi AI di perangkat Google yang berfokus pada ML klasik, yaitu ML Kit dan LiteRT.

Kedua, kita juga akan membahas hal baru di LiteRT dan Layanan Play.

Video ini juga akan membahas CompiledModel API baru dari LiteRT dan perangkat yang kami dukung.

Ketiga, kami akan menunjukkan cara membuat aplikasi baru.

Fergus akan membahas cara membuat aplikasi dengan ML Kit dan model kustom, semuanya dalam satu APK.

Terakhir, kami akan menunjukkan cara mengupgrade aplikasi yang ada menggunakan Mode Agen.

Selain itu, Anda bahkan dapat membuat scaffold aplikasi baru dengan dukungan agen ini.

Oke.

Pertama, mari kita mulai dengan, apa itu LiteRT?

LiteRT adalah runtime inferensi di perangkat dari Google untuk model Anda sendiri.

Model ini menggunakan format file .tflite yang sama dengan yang Anda gunakan sebelumnya dengan TensorFlow Lite.

Framework ini direkayasa ulang untuk performa dan juga mendukung multi-framework.

Artinya, Anda dapat menggunakan model dari PyTorch, TensorFlow, dan bahkan JAX untuk diturunkan ke format flat buffer untuk LiteRT.

Sekarang, sejak tahun 2022, TensorFlow Lite di layanan Google Play telah menjadi runtime di perangkat resmi Android untuk model kustom.

Hari ini, Gemini mendapatkan upgrade besar, dan itulah yang akan banyak dibahas dalam presentasi ini.

Upgrade ini akan menghadirkan API LiteRT CompiledModel terbaru, termasuk inferensi GPU baru yang ditingkatkan dan akan 1,4x lebih cepat, serta memungkinkan Anda membangun aplikasi yang lebih kecil dalam ukuran APK yang jauh lebih ramping.

Jadi, mengapa mengirimkannya melalui Layanan Play?

Ada beberapa keuntungan, dan ini jelas merupakan masalah besar yang saya lihat dalam banyak diskusi yang saya dengar, di mana ukuran aplikasi dan APK yang membengkak menjadi tantangan nyata, bukan?

Jadi, Anda akan mendapatkan runtime yang kecil.

Runtime tidak ada dalam APK Anda, jadi Anda mengandalkan thin client, dan hal itu membuat APK Anda lebih kecil sekitar 8 MB.

Manfaat kedua adalah efisiensi.

Anda memiliki satu salinan runtime, sehingga runtime yang merupakan runtime LiteRT digunakan bersama di semua aplikasi.

Jadi, bayangkan jika Anda memiliki banyak aplikasi, masing-masing dapat menghemat 8 MB.

Jumlah ini akan bertambah dengan sangat cepat saat Anda mencoba menghemat kapasitas disk dan memiliki aplikasi yang lebih ramping.

Kedua, model ini dikelola.

Google mengirimkan perbaikan bug, mengatasi tantangan driver GPU yang tidak perlu Anda lakukan, dan juga update keamanan lainnya yang semuanya masuk melalui update otomatis.

Seperti yang saya sebutkan, GPU-nya lebih cepat, jadi Anda mendapatkan GPU 1,4x lebih cepat, dan kami juga akan membahasnya secara lebih mendetail.

Dari sudut pandang cakupan, kami dapat mengirimkan ke perangkat Android yang lebih lama.

LiteRT di layanan Play mendukung Android 7 dari tahun 2016.

Dan seperti yang akan ditunjukkan Fergus kepada Anda, perangkat baru lainnya yang kami perluas ketersediaannya di slide mendatang.

Jadi, ini adalah kendaraan pengiriman, dan mari kita bahas langkah berikutnya, yaitu runtime.

Jadi, LiteRT bukanlah hal baru dan bukan eksperimental.

TensorFlow Lite dan LiteRT sudah berjalan di lebih dari 250.000 aplikasi saat ini.

Android juga berjalan di lebih dari 3,8 miliar perangkat saat ini.

Jadi, banyak aplikasi yang mungkin Anda gunakan, yang mungkin bahkan tidak Anda ketahui, semuanya menjalankan ini.

Dan ini juga setara dengan lebih dari satu triliun inferensi setiap hari, bukan?

Pada skala tersebut, kami tentu telah mengalami setiap masalah chipset yang aneh, kami telah dapat mengatasi masalah ROM atau masalah driver GPU, dan kami memiliki solusi khusus untuk Anda.

LiteRT juga dijalankan Google di aplikasi unggulannya, di berbagai aplikasi, platform, dan bahkan beberapa perangkat.

Efek video YouTube Shorts, segmentasi latar belakang Meet, Penghilangan Blur Foto, adalah beberapa contoh tempat video real-time dan model gambar berat dijalankan di LiteRT.

Hal ini juga sangat penting karena membuat kasus penggunaan menjadi cepat dan menarik bagi pengguna sangatlah penting, bukan?

Jadi, ini adalah runtime yang sama dengan yang telah kami perkuat untuk fitur-fitur unggulan ini, dan inilah yang Anda dapatkan melalui layanan Google Play.

Jadi, mari kita bahas juga alasan menggunakan AI di perangkat.

Latensi, privasi, bekerja secara offline, atau biaya rendah, jika salah satu dari hal ini penting bagi Anda, jalankan secara offline, bukan?

Mungkin ada lebih banyak alasan, tetapi ini adalah beberapa alasan paling jelas yang kami dengar untuk menjalankan model di perangkat.

Menjalankan model di perangkat juga tidak selalu gratis.

Hal ini memiliki beberapa nuansa dan tantangan.

Jadi, kami juga akan membahas beberapa tantangan ini dan memberikan solusi untuk Anda, bukan?

Jadi, performa: Seperti yang Anda lihat, bukan, beberapa contoh dari aplikasi sebelumnya, anggaran latensi dan memori selalu ketat, bukan?

Video dan audio real-time memerlukan efisiensi yang sangat tinggi.

Fitur interaktif yang sederhana pun harus cepat.

Jika tidak, Anda akan kehilangan engagement pengguna.

Keberagaman hardware: Ada ratusan SoC dengan konfigurasi CPU dan konfigurasi GPU yang berbeda.

Anda tidak dapat menulis kode untuk semua ini, bukan?

Bagaimana cara Anda mengatasi semua itu?

Ukuran APK: Memaketkan runtime native juga membuat setiap download menjadi lebih besar, yang dapat memengaruhi rasio konversi Anda.

Penyesuaian: Pelatihan model, kualitas, ukuran model, semuanya akan sangat penting bahkan sebelum Anda men-deploy.

Jadi, ya, membuat aplikasi di perangkat yang bagus bisa jadi sulit.

Namun, dalam setiap situasi ini, kami ingin platform melakukan pekerjaan untuk Anda, bukan sebaliknya, bukan?

Portofolio di perangkat Google hadir untuk mengatasi tantangan ini, dan kita akan membahasnya selanjutnya.

Jadi, kita akan berfokus pada dua solusi sederhana hari ini, oke?

Ada dua cara mudah untuk menambahkan AI di perangkat melalui Layanan Play.

Jalur 1 adalah jalur siap pakai menggunakan ML Kit, bukan?

API ini adalah API vision dan bahasa yang siap pakai, hanya memerlukan sedikit keahlian ML, menyediakan banyak model, dan semuanya dikirimkan melalui layanan Play.

Kita juga akan membahas beberapa contohnya di slide berikutnya.

Jalur kustom, ini melalui LiteRT.

LiteRT memungkinkan Anda membawa model sendiri, menjalankannya di CPU, GPU.

Runtime juga berasal dari Layanan Play.

Jadi, ini ada di-- jadi, Anda tidak memaketkannya di APK.

Ini bukan pilihan salah satu.

Keduanya juga dapat digunakan bersama dengan lebih baik.

Dan itulah yang akan kita buat hari ini dalam beberapa menit ke depan.

Namun, pertama-tama, mari kita bahas apa saja yang tercakup dalam ML Kit.

Berikut hal-hal yang dicakup ML Kit secara langsung.

Jadi, jika Anda sudah berpikir bahwa beberapa kemampuan ini memenuhi kebutuhan Anda, itu adalah titik awal yang bagus, dan Anda sudah memiliki keunggulan.

Kami memiliki cakupan untuk visi, kode batang, dokumen, teks, pose, banyak dari kemampuan ini, API bahasa seperti terjemahan, smart reply, dan bahkan ekstraksi entity, bukan?

Poin utamanya adalah banyak API visi dan bahasa ini berjalan dengan LiteRT di balik layar.

Jadi, jika ML Kit dapat memenuhi kebutuhan Anda, Anda dapat memulai dari sini.

Dan jika tidak, Anda memiliki kesempatan untuk membawa model Anda sendiri.

Dan inilah poin utamanya: ML Kit dan model kustom Anda tidak akan menjadi dua runtime, seperti yang saya sebutkan.

Anggap saja keduanya sebagai dua pintu depan yang mengarah ke LiteRT yang sama yang akan berjalan di balik layar.

Jadi, LiteRT akan menjadi runtime Play yang akan mengorkestrasi kedua kapabilitas ini.

Jadi, jika aplikasi Anda sudah menggunakan Google Play Store, untuk ML Kit, lanjutkan saja.

Jika tidak, kita juga akan membahas jalur LiteRT.

Jadi, mari kita bahas juga hal baru di LiteRT.

Seperti yang saya sebutkan, LiteRT adalah evolusi dari TensorFlow Lite, bukan?

Jadi, peningkatan terbesarnya adalah GPU yang lebih cepat.

GPU yang lebih cepat mendukung OpenCL, OpenGL, dan juga memiliki dukungan lintas platform bahkan untuk backend Metal.

Jadi, Anda tentu dapat menggunakannya untuk beberapa platform sesuai kebutuhan.

Prosesnya juga lebih sederhana.

Kami memiliki satu alur kerja terpadu untuk akselerasi CPU, GPU, dan NPU.

CPU dan GPU saat ini ada di layanan Play, sedangkan NPU dipaketkan melalui LiteRT saat ini, dan hal ini sedang dalam proses.

Jadi, sebelumnya, setiap akselerator berarti penyiapan delegasi yang berbeda, bukan?

Anda hanya perlu melakukannya sekali.

Jadi, ada satu API dengan penggantian otomatis ke CPU, dan Anda tidak perlu melakukan penyiapan khusus yang didelegasikan.

Anda juga dapat menggunakan panggilan akselerator yang dapat mengelola hal ini dengan jauh lebih mudah dan dengan lebih sedikit kode.

Model ini juga andal, model yang sama berjalan di beberapa platform, seperti yang saya sebutkan.

Hal ini akan sangat penting, yaitu bagian fleksibilitasnya.

Jadi, format .tflite tetap sama.

Jika Anda memiliki aplikasi yang sudah ada, Anda masih dapat menggunakan format ini.

Jika Anda membuat aplikasi baru, Anda dapat menggunakan format file ini sekali lagi.

Yang juga menarik adalah kami mendukung Interpreter API, yang sebelumnya ada di TensorFlow Lite.

Jadi, jika Anda ingin bermigrasi secara bertahap, Interpreter API disertakan, yang juga merupakan bagian dari LiteRT baru, sehingga memudahkan Anda untuk bermigrasi.

Jadi, itulah runtime.

Mari kita bahas apa yang dapat Anda bangun dengan ini.

Jadi, inilah yang sedang dibuat oleh aplikasi Android saat ini.

Semuanya, mulai dari efek kamera, pengeditan foto, pengetikan cerdas, game, dan avatar, bukan?

Banyak dari aplikasi ini akan memerlukan kemampuan real-time.

GPU mengirimkan frame langsung dari kamera, sehingga kecepatan dan real-time akan menjadi penting.

Beberapa model pengeditan foto ini juga semakin berat.

Hal yang sama berlaku untuk kemampuan AR/VR yang juga Anda lihat dalam beberapa demo dengan kacamata, banyak di antaranya menjalankan LiteRT di balik layar.

Runtime ini sama dengan yang kini mendukung fitur unggulan Google, dan juga di layanan Play, sehingga Anda mendapatkan semua ini tanpa memaketkan apa pun ke APK Anda.

Sekarang, mari kita buat aplikasi, dan Fergus akan menunjukkan caranya.

Mari kita coba.

Terima kasih, Chintan.

Jadi, kami akan membahas sedikit tentang hal baru di LiteRT di layanan Google Play.

Jadi, sebelum kita membangun, ada satu lagi berita, semua yang baru saja Anda lihat kini berjalan di luar ponsel, LiteRT di Layanan Play juga tersedia di Wear OS dan Android Automotive OS.

Jadi, Anda dapat menjalankan model di perangkat di smartwatch atau perangkat wearable lainnya, atau di mobil itu sendiri.

Sebelumnya, Anda dapat menggunakan aplikasi di ponsel yang akan menjadi aplikasi pendamping untuk Wear, tetapi sekarang Anda dapat menjalankannya di perangkat wearable itu sendiri, dan hal yang sama berlaku untuk Android Automotive.

Jadi, Anda memiliki API yang sama, model .tflite yang sama, tetapi lebih banyak platform.

Tidak perlu menerapkan implementasi terpisah per faktor bentuk, Anda dapat menggunakan implementasi yang sama untuk semua perangkat yang berbeda ini.

Kemudian, keunggulan paradigma distribusi layanan Play adalah kita dapat melakukan backport untuk menjalankannya di perangkat yang lebih lama.

Jadi, untuk Android Automotive OS, kami mendukung hingga Android 11, yang dirilis pada tahun 2020, dan untuk Wear OS, kami mendukung Wear OS 4 dan yang lebih baru.

Oke.

Sekarang, saya akan membahas dua jalur yang berbeda, yaitu membangun aplikasi baru dan mengupgrade aplikasi yang sudah ada.

Hal itu akan dibahas di bagian selanjutnya.

Jadi, saya akan memulai dengan aplikasi contoh yang menggabungkan penggunaan ML Kit dengan model GPU kustom yang berjalan di LiteRT.

Kemudian, untuk mengupgrade aplikasi yang sudah ada, akan ada tiga perubahan kecil, yaitu perubahan Gradle untuk mengupdate dependensi, perubahan init untuk mengaktifkan LiteRT di layanan Play, lalu beralih dari Interpreter API ke CompiledModel API.

Namun, kita akan melakukannya di aplikasi baru terlebih dahulu, karena upgrade akan jauh lebih masuk akal setelah Anda melihat apa yang akan di-upgrade.

Jadi, membangun aplikasi baru.

Berikut adalah aplikasi yang akan kita buat.

Fitur ini akan memiliki tampilan kamera live, yang membuat Anda tetap terlihat tajam, dan latar belakang akan mendapatkan gaya artistik.

Jadi, kita akan mengambil frame kamera.

Gambar dari frame kamera akan di-streaming melalui segmentasi selfie ML Kit.

Itu adalah salah satu API siap pakai ML Kit yang ada.

Dan itu akan menghasilkan mask latar depan yang pada dasarnya akan menunjukkan piksel mana dalam gambar yang sesuai dengan orang dalam gambar.

Kemudian, kita akan mengambil model kustom, yang seperti model jenis transfer gaya, yang akan menerapkan gaya ke gambar.

Kita akan menerapkannya ke seluruh frame kamera, tetapi sebenarnya hanya bagian latar belakang yang kita perhatikan, karena pada akhirnya kita akan mengambil frame kamera asli, mask, dan latar belakang gaya, lalu menggabungkannya dengan sedikit logika sederhana, sehingga kita memiliki frame gabungan yang mempertahankan subjek, dan latar belakangnya memiliki gaya.

Jadi, kami ingin menggunakan API siap pakai jika tersedia, dan API kustom jika dapat membedakan aplikasi kami.

Jadi, ini adalah bagian pertama tempat kita memanggil API segmentasi selfie ML Kit.

// 1. Configure and create segmenter client
val segmenter = Segmentation.getClient(
    SelfieSegmenterOptions.Builder()
        .setDetectorMode(
            SelfieSegmenterOptions.STREAM_MODE)
        .build())

// 2. Prepare image & run inference
fun processFrame(mediaImage: Image) {
  val image = InputImage.fromMediaImage(
      mediaImage, /* rotationDegrees= */ 0)
  segmenter.process(image)
      .addOnSuccessListener { mask -> … }
}

Jadi, ini seperti API biasa, bukan?

Ini seperti makanan pokok bagi developer Android.

Anda tahu, Anda hanya perlu melihat dokumen API atau meminta Gemini untuk membuatnya.

Namun, Anda tahu, ini cukup mudah.

Anda membuat klien yang meneruskan beberapa opsi saat Anda membuat klien.

Dalam hal ini, kita menentukan mode streaming agar dapat memproses streaming frame video.

Lalu, ada metode proses yang Anda panggil di sana, dan callback dari metode tersebut akan mendapatkan mask yang ditampilkan, yang dihitung oleh segmentasi selfie.

Dan inputnya adalah gambar dari kamera.

Semua API ini menggunakan jenis tingkat aplikasi, bukan tensor mentah, sehingga Anda benar-benar memprogram pada tingkat yang sangat tinggi dan sangat mudah.

Untuk bagian kedua, yaitu model kustom, kita akan menggunakan model PyTorch.

Sepertinya Chintan mendapatkan ini dari salah satu platform seperti Kaggle atau Hugging Face…

Ya.

Ya, dan atau Anda dapat mengonversi milik Anda sendiri.

Anda dapat membangun model Anda sendiri.

Maaf, kembali.

Ya, jadi seperti inilah tampilan stack-nya.

Anda mengambil model PyTorch, Anda dapat mengonversi dan mengkuantisasinya, lalu Anda mendapatkan model LiteRT.

Kemudian, Anda mendistribusikannya dengan aplikasi Anda, sesuai keinginan Anda.

Model ini dapat dipaketkan sebagai bagian dari aplikasi sebagai aset atau dapat didownload secara terpisah.

Kedua cara tersebut dapat digunakan.

Dan itu kemudian berada di atas runtime LiteRT di layanan Play.

Lalu, ada kernel CPU untuk pengoptimalan di CPU, dan ML Drift adalah nama akselerator GPU.

Ya, jadi seperti yang saya katakan, Anda mendapatkan model TFLite, Anda dapat melatih model sendiri, mengambil dan menemukan model yang ada, keduanya bisa digunakan.

Konversi dari PyTorch hanya memerlukan beberapa baris Python.

import litert_torch

model = my_models.Stylizer().eval()

# Convert with torch.export under the hood
edge_model = litert_torch.convert(
    model, sample_inputs)
edge_model.export("stylizer_f32.tflite")

Jadi, Anda menginstal LiteRT-Torch dengan pip, memanggil litert_torch.convert, meneruskan beberapa sample_inputs yang dapat berupa input acak, dan mengekspor file TFLite.

Ngomong-ngomong, LiteRT-Torch adalah nama baru untuk ai-edge-torch, jika Anda sudah familier dengan nama tersebut.

Kemudian, kuantisasi juga sangat mudah.

# Python
# previously ai_edge_quantizer
from litert_quantizer import quantizer, recipe

qt = quantizer.Quantizer("stylizer_f32.tflite")

# int8 weights, float activations
qt.load_quantization_recipe(
    recipe.dynamic_wi8_afp32())

qt.quantize().export_model("stylizer_int8.tflite")

Anda mengimpor quantizer dan resep dari LiteRT Quantizer.

Saat membuat kuantizer, Anda meneruskan model floating point asli, Anda meneruskan resep yang merupakan resep standar yang kami gunakan dan rekomendasikan untuk GPU, yang menggunakan bobot bilangan bulat 8-bit, tetapi mempertahankan aktivasi sebagai floating point 32-bit.

Kemudian, Anda cukup memanggil quantize, lalu export_model untuk menyimpan model output.

Model tersebut akan menjadi model terkuantisasi yang dapat Anda jalankan, dan akan memiliki bobot yang jauh lebih kecil, serta akan dieksekusi dengan lebih efisien.

Oke, jadi ya, API CompiledModel GPU adalah tempat yang sangat cocok untuk itu.

Jadi, seperti yang disebutkan Chintan, Anda tahu, peningkatan kecepatan yang signifikan pada GPU TFLite lama.

Jumlah pastinya akan sedikit bervariasi dari satu model ke model lainnya, tetapi 1,4 kali adalah angka yang dapat Anda harapkan.

Hingga 10 kali lebih cepat daripada inferensi CPU, jadi itulah, Anda tahu, keuntungan besarnya, bukan?

Jika Anda, sebagian besar dari Anda yang menggunakan model saat ini mungkin menjalankannya di CPU, dan kehilangan faktor performa 10 kali lipat yang bisa Anda dapatkan dari GPU.

Jadi, ini adalah insentif yang nyata.

Apa yang membuatnya cepat?

Oke, jadi ada banyak hal yang kami dukung, misalnya, eksekusi asinkron sehingga Anda dapat mengambil AHardwareBuffer dan meneruskannya secara langsung atau buffer OpenGL dari pipeline render kamera tersebut, meneruskannya langsung ke buffer tensor.

Zero-copy mengoptimalkan zero-copy yang kami dukung, jadi pada dasarnya Anda dapat, saat mencoba memproses berbagai hal, dengan anggaran latensi rendah seperti saat Anda harus memproses setiap frame dalam hitungan, beberapa puluh milidetik, bahkan hanya menyalin buffer memori dapat menjadi overhead yang tidak sepele.

Jadi, untuk aplikasi dengan persyaratan real-time yang sangat tinggi, Anda dapat menggunakan pengoptimalan zero-copy, yang kami dukung.

Lalu, seperti yang disebutkan Chintan, ini adalah lintas platform dengan dukungan untuk OpenGL, OpenCL, dan Metal, sebagai backend GPU.

Terakhir, pengoptimal ML Drift bersifat open source.

Alat ini tersedia berdasarkan lisensi Apache.

Model ini baru-baru ini di-open source-kan oleh Google.

Oke, lalu, ini, ini kode aplikasinya.

// Kotlin
// Build once, off the main thread.
private val model: CompiledModel =
    CompiledModel.create(
        context.assets,
        "stylizer_int8.tflite",
        // Simple GPU setup!
        CompiledModel.Options(Accelerator.GPU),
        environment
    )

// Reuse buffers across frames.
private val inputBuffers  = model.createInputBuffers()
private val outputBuffers = model.createOutputBuffers()

fun stylize(input: FloatArray): FloatArray {
    inputBuffers[0].writeFloat(input)
    model.run(inputBuffers, outputBuffers) // sync
    return outputBuffers[0].readFloat()
}

Seperti yang Anda lihat, ukurannya cukup kecil dan sederhana.

Jadi, Anda membuat model sekali, lalu menggunakannya kembali di setiap frame.

Jadi, di sana, CompiledModel.create meneruskan file .tflite.

Anda hanya perlu menentukan bahwa Anda ingin menjalankan di GPU, lalu membuat input dan outputBuffers.

Kemudian, dalam loop utama, tempat Anda benar-benar memproses setiap frame, Anda memanggil model.run ini dengan meneruskan input, output.

Setelah Anda menulis ke inputBuffers, panggil model.run, lalu baca dari outputBuffers.

Oke.

Oh, ya, lalu, jika Anda hanya menentukan GPU di sana, model akan berjalan di GPU.

Jika Anda juga menentukan CPU dan GPU di sana, GPU akan mencoba dijalankan.

Jika GPU tidak tersedia karena alasan apa pun, GPU akan beralih ke CPU.

Jadi, dalam beberapa kasus, penggantian CPU mungkin tidak cukup efisien untuk aplikasi Anda, dan saat itulah Anda ingin menggunakan GPU seperti itu.

Biasanya, Anda ingin memiliki penggantian CPU.

Oke.

Jadi, kami telah membangunnya dengan LiteRT yang dipaketkan, yang belum menggunakan Layanan Play.

Jadi, kami akan menunjukkan cara menggunakan LiteRT di layanan Play.

Jadi, ada tiga perubahan: yang pertama adalah perubahan dependensi.

// Easier with CompiledModel API: 3 steps

// 1. app/build.gradle: replace litert with play-services-litert
- implementation 'com.google.ai.edge.litert:litert:...'
+ implementation 'com.google.android.gms:play-services-litert:17.0.0'  // also pulls in litert-api

Anda hanya perlu mengganti, di file Gradle atau di mana pun, sistem build apa pun yang Anda gunakan, di mana pun Anda menentukan dependensi paket Maven, itulah yang akan Anda ubah.

Lalu, hapus dependensi litert atau dependensi paket Maven TensorFlow Lite yang lebih lama, dan ganti dengan play-services-litert ini.

Tindakan ini juga akan menarik paket litert-api.

Sekarang, jika Anda menulis lapisan tengah yang hanya ingin bergantung pada LiteRT, tetapi tidak terlalu peduli apakah runtime berasal dari aplikasi atau dari layanan Play, Anda dapat bergantung pada LiteRT API, dan mengambil lingkungan sebagai parameter input.

Jadi, langkah kedua adalah parameter lingkungan.

Di situlah Anda memberikan injeksi dependensi, pada dasarnya, untuk menentukan bahwa Anda menggunakan, Anda ingin menggunakan LiteRT layanan Play.

Jadi, Anda mengimpor gms.litert.LiteRt, dan memanggil fungsi initialize, dengan meneruskan konteks, yang merupakan aktivitas Android Anda.

// 2. Initialize the LiteRT Environment from Play services (context = your Activity)
- val environment = Environment.create(...)
+ import com.google.android.gms.litert.LiteRt
+ val environment = LiteRt.initialize(context).await()

// 3. Pass environment whenever you call CompiledModel.create

// That's it! The rest of your app uses the normal CompiledModel APIs from litert-api.

Dan itu adalah hal asinkron, jadi Anda harus memanggil .await atau membuat sisanya didasarkan pada callback.

Dan terakhir, setelah Anda mendapatkan lingkungan tersebut, Anda cukup meneruskan lingkungan tersebut setiap kali Anda memanggil CompiledModel.create.

Hal ini akan membuatnya menggunakan runtime LiteRT layanan Play dari layanan Play.

Jadi, selesai.

Artinya, bagian lain aplikasi Anda menggunakan LiteRT CompiledModel API yang sama persis dari LiteRT API.

Kode inferensi Anda lainnya tidak berubah untuk menggunakan layanan Play.

Dan Anda dapat melakukan migrasi tersebut secara bertahap.

Anda tidak perlu melakukan semuanya sekaligus, Anda dapat memigrasikan satu komponen dalam satu waktu.

Jika Anda memiliki aplikasi besar, sebaiknya migrasikan setiap komponen yang menggunakan LiteRT, lalu Anda dapat memigrasikan satu per satu, menguji satu per satu.

Satu-satunya peringatan adalah Anda hanya mendapatkan keuntungan ukuran, penghematan ruang hanya akan terjadi saat Anda menghapus dependensi terakhir pada runtime yang dipaketkan.

Selain itu, jika Anda menggunakannya, peringatan lainnya adalah Anda tidak boleh mencampur objek antara LiteRT di layanan Google Play dan LiteRT yang dipaketkan.

Jadi, jika Anda-- jika Anda mendapatkan Tensor atau model yang dikompilasi atau penafsir dari LiteRT di Layanan Play, Anda tidak boleh meneruskannya ke LiteRT yang dibundel atau sebaliknya.

Namun, selain itu, menggabungkan hal-hal ini akan berfungsi dengan baik.

Oke.

Jadi, itulah cara membuat aplikasi baru.

Sekarang saya akan membahas cara mengupgrade aplikasi yang sudah ada.

Jadi, Anda mungkin memiliki aplikasi yang sudah ada yang menggunakan Interpreter API.

Ini adalah API TFLite lama yang menggunakan penafsir sebagai class utama.

Jadi, kode di sebelah kiri menggunakan Interpreter API, dan di sebelah kanan, Anda akan melihat kode CompiledModel API baru.

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
TfLite.initialize(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }

val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val environment =
  LiteRt.initialize(context).await()

// Load
val modelOptions = CompiledModel.Options(Accelerator.CPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers

Jadi, Anda hanya mengubah TfLite.initialize menjadi LiteRt.initialize, dan sekarang menampilkan lingkungan.

Kemudian, Anda meneruskan lingkungan ke CompiledModel.create.

Jadi, itu adalah perubahan kecil, tanpa pertumbuhan APK.

Dan Anda akan melihat, di slide berikutnya, kami akan menunjukkan cara melakukannya dengan GPU, dan itu hanyalah satu opsi lagi.

Jadi, ini adalah kode tambahan yang Anda perlukan untuk mengaktifkan GPU.

// Dependencies (Gradle):
// play-services-tflite-java and/or litert (bundled)

// Init
val initOptions = TfLiteInitializationOptions.builder()
    .setEnableGpuDelegateSupport(true).build()
TfLite.initialize(context, initOptions).await()
val useGpu =
    TfLiteGpu.isGpuDelegateAvailable(context).await()

// Load
val interpreterOptions =
    InterpreterApi.Options().apply {
      runtime = TfLiteRuntime.FROM_SYSTEM_ONLY
    }
if (useGpu) {
    interpreterOptions.addDelegateFactory(
        GpuDelegateFactory());
}
val interpreter =
    InterpreterApi.create(modelFile, interpreterOptions)

// Prepare inputs/outputs
val inputs = …
val outputs = …

// Execute
interpreter.run(inputs, outputs)

// Dependencies (Gradle):
// play-services-litert

// Init
val initOptions = LiteRtInitializationOptions.builder()
    .setEnableGpu(true).build()
val environment = LiteRt.initialize(context, initOptions).await()

// Load
val modelOptions =
    CompiledModel.Options(Accelerator.CPU, Accelerator.GPU)

val model =
    CompiledModel.create(modelPath, modelOptions, environment)

// Prepare inputs/outputs
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Execute
model.run(inputBuffers, outputBuffers)

Seperti yang Anda lihat, kode di API baru untuk mengaktifkan GPU sedikit lebih sed-- ya, lebih sederhana daripada kode sebelumnya.

Jadi, panggilan pertama ke setEnableGpu dalam opsi inisialisasi LiteRT yang Anda teruskan ke LiteRt.initialize, akan menyebabkan kode untuk akselerator GPU dimuat ke dalam aplikasi Anda.

Kemudian, saat Anda membuat modelOptions, dan meneruskannya ke CompiledModel.create, di situlah Anda menentukan akselerator yang akan digunakan untuk model tertentu, apakah Anda ingin model lain berjalan hanya di GPU, atau GPU dengan penggantian CPU, atau hanya di CPU.

Oke.

Ya, seperti yang Anda lihat, mengaktifkan GPU jauh lebih mudah dengan API baru.

Jadi, apa yang sebenarnya Anda dapatkan?

Chintan akan memberi tahu Anda.

Oke.

Baiklah, terima kasih Fergus.

Jadi, mari kita bahas apa yang kita dapatkan dari semua ini, bukan?

Jadi, ingat bahwa kita akan membuat aplikasi, jadi mari kita lihat apa yang sebenarnya kita buat, bukan?

Jadi, itulah saya, dan yang kami lakukan di sini adalah menggunakan ML Kit untuk menemukan saya, sehingga segmentasi dilakukan oleh API siap pakai seperti ML Kit.

Jadi, itu hanya menemukan kepala saya di sana.

Kemudian, LiteRT menggunakan model lain yang mirip dengan transfer gaya untuk melukis latar belakang.

Manfaat lainnya seperti yang kami sebutkan adalah Anda mendapatkan penghematan ruang sekitar 8 MB, Anda sekarang memiliki satu runtime yang digunakan di antara semua aplikasi Anda, atau setidaknya seperti yang dibagikan di sini, dan Anda mendapatkan update otomatis, serta Anda juga memiliki GPU yang lebih cepat yang memberi Anda hampir 30 frame per detik pada sesuatu yang harus real-time untuk pengalaman pengguna yang kaya.

Hal baik lainnya adalah Anda tidak perlu melakukan semua ini secara manual.

Ada juga keterampilan baru yang baru saja kami luncurkan di Android, yaitu keterampilan LiteRT Android yang meningkatkan ML di perangkat Anda dalam hitungan menit, bukan?

Jadi, Anda dapat melakukan beberapa hal dengan ini: Anda dapat mengupgrade aplikasi yang ada, Anda dapat membuat scaffold aplikasi baru, Anda juga dapat mengupgrade aplikasi untuk menggunakan integrasi layanan Play baru ini.

Jadi, semua ini tersedia.

Link-nya ada di slide, juga ada di GitHub, dan akan muncul di dokumentasi serta blog kami.

Dan ya, jadi itu juga akan berguna bagi siapa saja yang ingin segera melakukan perubahan.

Jadi, Fergus akan memberi tahu kita ke mana arahnya selanjutnya.

Oleh karena itu, kami berkomitmen untuk menghadirkan AI di perangkat dengan LiteRT.

Kami terus berinvestasi secara signifikan dalam meningkatkan akselerasi GPU dan cakupan model, serta terus memberikan update rutin untuk LiteRT 2.x, baik untuk LiteRT paket open source maupun untuk paket Maven LiteRT layanan Play, yaitu LiteRT di layanan Play.

Kami juga akan terus menyediakan kompatibilitas mundur.

Runtime layanan Play akan terus mendukung aplikasi yang dibuat dengan SDK lama.

Ya.

Hal itu sangat penting bagi pengguna kami, dan sangat penting bagi kami.

Untuk SDK LiteRT 1.x, SDK tersebut kini dalam mode pemeliharaan, sehingga hanya perbaikan keamanan penting yang akan diberikan.

NNAPI, yang kami hentikan penggunaannya pada tahun 2024, akan dihapus, dan kemungkinan akan dihapus mulai tahun 2027.

Jadi, jika Anda menggunakan NNAPI, beralihlah ke akselerasi GPU atau akselerasi NPU dengan LiteRT yang dipaketkan.

Oke.

Ya.

Jadi, makin cepat Anda beralih ke 2.x dan CompiledModel, makin sedikit yang harus Anda lakukan nanti.

Jadi, ada tiga hal yang perlu diingat.

Jadi, bangunlah.

Mulailah dengan ML Kit, dan jika sudah sesuai dengan kebutuhan Anda, itu bagus.

Namun, jika tidak, gunakan LiteRT untuk model kustom Anda.

Upgrade ke LiteRT di layanan Google Play untuk penghematan APK dan runtime bersama.

Pertimbangkan juga untuk menggunakan CompiledModel API untuk inferensi GPU yang lebih cepat dan sederhana.

Ya.

Semuanya didokumentasikan di situs dokumentasi LiteRT kami di AI Edge pada URL yang ditampilkan.

Jadi, ya.

Terima kasih telah bergabung bersama kami, dan kami tidak sabar untuk melihat-- menantikan karya Anda.