LiteRT untuk Android

LiteRT memungkinkan Anda menjalankan model TensorFlow, PyTorch, dan JAX di aplikasi Android Anda. Sistem LiteRT menyediakan lingkungan eksekusi siap pakai dan yang dapat disesuaikan untuk menjalankan model di Android dengan cepat dan efisien, termasuk opsi untuk akselerasi hardware.

Untuk contoh aplikasi Android yang menggunakan LiteRT, lihat repositori contoh LiteRT.

Model machine learning

LiteRT menggunakan model TensorFlow, PyTorch, dan JAX yang dikonversi menjadi format model machine learning yang lebih kecil, portabel, dan efisien. Anda dapat menggunakan model bawaan dengan LiteRT di Android, atau membuat model Anda sendiri dan mengonversinya ke format LiteRT.

Halaman ini membahas penggunaan model machine learning yang sudah dibuat dan tidak mencakup pembuatan, pelatihan, pengujian, atau konversi model. Pelajari lebih lanjut cara memilih, mengubah, membuat, dan mengonversi model machine learning untuk LiteRT di halaman Model.

Menjalankan model di Android

Model LiteRT yang berjalan di dalam aplikasi Android menerima data, memproses data, dan menghasilkan prediksi berdasarkan logika model. Model LiteRT memerlukan lingkungan runtime khusus untuk dieksekusi, dan data yang diteruskan ke dalam model harus dalam format data tertentu, yang disebut tensor. Saat memproses data, yang dikenal sebagai menjalankan inferensi, model menghasilkan hasil prediksi sebagai tensor baru, dan meneruskannya ke aplikasi Android sehingga aplikasi dapat mengambil tindakan, seperti menampilkan hasil kepada pengguna atau menjalankan logika bisnis tambahan.

Gambar 1. Alur eksekusi fungsional untuk model LiteRT di aplikasi Android.

Pada tingkat desain fungsional, aplikasi Android Anda memerlukan elemen berikut untuk menjalankan model LiteRT:

• Lingkungan runtime LiteRT untuk mengeksekusi model
• Handler input model untuk mengubah data menjadi tensor
• Handler output model untuk menerima tensor hasil output dan menafsirkannya sebagai hasil prediksi

Bagian berikut menjelaskan cara library dan alat LiteRT menyediakan elemen fungsional ini.

Membangun aplikasi dengan LiteRT

Bagian ini menjelaskan jalur yang direkomendasikan dan paling umum untuk menerapkan LiteRT di Aplikasi Android Anda. Anda harus memperhatikan bagian lingkungan runtime dan library pengembangan. Jika Anda telah mengembangkan model kustom, pastikan untuk meninjau bagian Jalur pengembangan lanjutan.

Opsi lingkungan runtime

Ada beberapa cara untuk mengaktifkan lingkungan runtime guna mengeksekusi model di aplikasi Android Anda. Berikut adalah opsi yang disarankan:

• LiteRT di lingkungan runtime layanan Google Play (direkomendasikan)
• Lingkungan runtime LiteRT mandiri

Secara umum, Anda harus menggunakan lingkungan runtime yang disediakan oleh layanan Google Play karena lebih hemat ruang daripada lingkungan standar karena dimuat secara dinamis, sehingga ukuran aplikasi Anda lebih kecil. Layanan Google Play juga secara otomatis menggunakan rilis runtime LiteRT yang paling baru dan stabil, sehingga memberi Anda fitur tambahan dan performa yang lebih baik dari waktu ke waktu. Jika Anda menawarkan aplikasi di perangkat yang tidak menyertakan layanan Google Play atau Anda perlu mengelola lingkungan runtime ML dengan cermat, Anda harus menggunakan runtime LiteRT standar. Opsi ini menggabungkan kode tambahan ke dalam aplikasi Anda, sehingga Anda dapat memiliki kontrol lebih besar atas runtime ML di aplikasi Anda dengan biaya peningkatan ukuran download aplikasi.

Anda mengakses lingkungan runtime ini di aplikasi Android dengan menambahkan library pengembangan LiteRT ke lingkungan pengembangan aplikasi Anda. Untuk mengetahui informasi tentang cara menggunakan lingkungan runtime standar di aplikasi Anda, lihat bagian berikutnya.

Perpustakaan

Anda dapat mengakses Interpreter API menggunakan layanan Google Play. Anda dapat menggunakan library LiteRT core dan support di aplikasi Android Anda. Untuk detail pemrograman tentang penggunaan library LiteRT dan lingkungan runtime, lihat Alat pengembangan untuk Android.

Mendapatkan model

Menjalankan model di aplikasi Android memerlukan model berformat LiteRT. Anda dapat menggunakan model bawaan atau membangun model dan mengonversinya ke format Lite. Untuk mengetahui informasi selengkapnya tentang cara mendapatkan model untuk aplikasi Android Anda, lihat halaman Model LiteRT.

Menangani data input

Setiap data yang Anda teruskan ke model ML harus berupa tensor dengan struktur data tertentu, yang sering disebut bentuk tensor. Untuk memproses data dengan model, kode aplikasi Anda harus mengubah data dari format aslinya, seperti data gambar, teks, atau audio, menjadi tensor dalam bentuk yang diperlukan untuk model Anda.

Menjalankan inferensi

Memproses data melalui model untuk menghasilkan hasil prediksi dikenal sebagai menjalankan inferensi. Menjalankan inferensi di aplikasi Android memerlukan lingkungan runtime LiteRT, model, dan data input.

Kecepatan model dalam menghasilkan inferensi pada perangkat tertentu bergantung pada ukuran data yang diproses, kompleksitas model, dan resource komputasi yang tersedia seperti memori dan CPU, atau prosesor khusus yang disebut akselerator. Model machine learning dapat berjalan lebih cepat di prosesor khusus ini seperti unit pemrosesan grafis (GPU) dan Tensor Processing Unit (TPU), menggunakan driver hardware LiteRT yang disebut delegasi. Untuk mengetahui informasi selengkapnya tentang delegasi dan akselerasi hardware pemrosesan model, lihat Ringkasan akselerasi hardware.

Menangani hasil output

Model menghasilkan hasil prediksi sebagai tensor, yang harus ditangani oleh aplikasi Android Anda dengan mengambil tindakan atau menampilkan hasil kepada pengguna. Hasil output model dapat sesederhana angka yang sesuai dengan satu hasil (0 =, 1 = kucing, 2 = burung) untuk klasifikasi gambar, hingga hasil yang jauh lebih kompleks, seperti beberapa kotak pembatas untuk beberapa objek yang diklasifikasikan dalam gambar, dengan rating keyakinan prediksi antara 0 dan 1.

Jalur pengembangan lanjutan

Saat menggunakan model LiteRT yang lebih canggih dan disesuaikan, Anda mungkin perlu menggunakan pendekatan pengembangan yang lebih canggih daripada yang dijelaskan di atas. Bagian berikut menjelaskan teknik lanjutan untuk mengeksekusi model dan mengembangkannya untuk LiteRT di aplikasi Android.

Lingkungan runtime lanjutan

Selain lingkungan runtime standar dan lingkungan runtime layanan Google Play untuk LiteRT, ada lingkungan runtime tambahan yang dapat Anda gunakan dengan aplikasi Android Anda. Penggunaan yang paling mungkin untuk lingkungan ini adalah jika Anda memiliki model machine learning yang menggunakan operasi ML yang tidak didukung oleh lingkungan runtime standar untuk LiteRT.

• Runtime fleksibel untuk LiteRT
• Runtime LiteRT buatan kustom

Dengan Flex runtime LiteRT, Anda dapat menyertakan operator spesifik yang diperlukan untuk model Anda. Sebagai opsi lanjutan untuk menjalankan model, Anda dapat membuat LiteRT untuk Android guna menyertakan operator dan fungsi lain yang diperlukan untuk menjalankan model machine learning TensorFlow. Untuk informasi selengkapnya, lihat Membangun LiteRT untuk Android.

API C dan C++

LiteRT juga menyediakan API untuk menjalankan model menggunakan C dan C++. Jika aplikasi Anda menggunakan Android NDK, Anda harus mempertimbangkan penggunaan API ini. Anda juga dapat mempertimbangkan untuk menggunakan API ini jika ingin dapat membagikan kode di beberapa platform. Untuk mengetahui informasi selengkapnya tentang opsi pengembangan ini, lihat halaman Alat pengembangan.

Eksekusi model berbasis server

Secara umum, Anda harus menjalankan model di aplikasi pada perangkat Android untuk memanfaatkan latensi yang lebih rendah dan privasi data yang lebih baik bagi pengguna Anda. Namun, ada kasus ketika menjalankan model di server cloud, di luar perangkat, adalah solusi yang lebih baik. Misalnya, jika Anda memiliki model besar yang tidak mudah dikompresi ke ukuran yang sesuai di perangkat Android pengguna, atau dapat dieksekusi dengan performa yang wajar di perangkat tersebut. Pendekatan ini juga dapat menjadi solusi pilihan Anda jika performa model yang konsisten di berbagai perangkat menjadi prioritas utama.

Google Cloud menawarkan rangkaian lengkap layanan untuk menjalankan model AI. Untuk mengetahui informasi selengkapnya, lihat halaman Produk AI dan machine learning Google Cloud.

Pengembangan dan pengoptimalan model kustom

Jalur pengembangan yang lebih canggih kemungkinan akan mencakup pengembangan model machine learning kustom dan pengoptimalan model tersebut untuk digunakan di perangkat Android. Jika Anda berencana membangun model kustom, pastikan Anda mempertimbangkan untuk menerapkan teknik kuantisasi ke model untuk mengurangi biaya memori dan pemrosesan. Untuk mengetahui informasi selengkapnya tentang cara membangun model berperforma tinggi untuk digunakan dengan LiteRT, lihat Praktik terbaik performa di bagian Model.

Versi Android yang Didukung

Penting: Selalu perbarui dependensi Anda untuk memastikan kompatibilitas dengan fitur dan update keamanan terbaru.

Compiled Model API versus Interpreter API

• Compiled Model API – eksekusi yang dikompilasi AOT/JIT yang mengutamakan akselerator dengan interoperabilitas buffer terpadu dan pipeline asinkron.
• Interpreter API – kompatibel mundur dengan kode gaya TensorFlow Lite yang ada.

Anda dapat memilih salah satu API saat runtime; sebagian besar fitur performa dan akselerator baru tersedia di Compiled Model API.

Untuk contoh implementasi, lihat:

• Segmentasi gambar (Kotlin, CPU/GPU)
• Segmentasi asinkron (C++, CPU/GPU/NPU)
• Kemiripan semantik (C++) – sampel lokal

Umum & CPU

GPU

NPU

Panduan memulai (Compiled Model API)

Menjalankan inferensi dengan Compiled Model API melibatkan langkah-langkah utama berikut:

1. Muat model yang kompatibel.
2. Alokasikan buffer tensor input dan output.
3. Panggil model yang dikompilasi.
4. Membaca inferensi ke dalam buffer output.

Cuplikan kode berikut menunjukkan implementasi dasar dari seluruh proses di Kotlin dan C++.

// Load model and initialize runtime
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorCpu));

// Preallocate input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Fill the first input
float input_values[] = { /* your data */ };
input_buffers[0].Write<float>(absl::MakeConstSpan(input_values, /*size*/));

// Invoke
compiled_model.Run(input_buffers, output_buffers);

// Read the output
std::vector<float> data(output_data_size);
output_buffers[0].Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.CPU)
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

Untuk mengetahui informasi selengkapnya, lihat panduan Mulai Menggunakan Kotlin dan Mulai Menggunakan C++.

Kemampuan utama (Compiled Model API)

• Pemilihan akselerator siap pakai & asinkron – pilih CPU/GPU/NPU pada waktu pembuatan dan jalankan asinkron tanpa penyiapan delegasi.
• Buffer salinan nol terpadu – berbagi buffer AHWB/GL/OpenCL/WebGPU/Metal di seluruh pra/pasca-pemrosesan dan inferensi.
• Throughput siap generatif – dioptimalkan untuk model besar dengan penggantian GPU/NPU dan caching memori.

Interpreter API tetap menjadi jalur kompatibilitas untuk codebase TensorFlow Lite yang ada; gunakan API ini saat Anda memerlukan perilaku delegasi yang stabil atau wrapper pihak ketiga yang mengharapkan interpreter klasik.

Akselerator

• CPU (default): Dioptimalkan untuk XNNPACK, mendukung bentuk dinamis.
• GPU: Backend OpenCL saat ini; backend WebGPU dan Metal tersedia melalui Compiled Model API.
• NPU: Qualcomm AI Engine Direct dan MediaTek NeuroPilot didukung untuk AOT/JIT; Pixel AOT tersedia; dukungan NPU Apple/Intel direncanakan.

Kapan harus memilih API

• Gunakan Compiled Model API jika Anda menginginkan jalur tercepat ke GPU/NPU, buffer tanpa salinan, atau eksekusi asinkron.
• Gunakan Interpreter API saat Anda memerlukan kompatibilitas maksimum dengan kode, alat, atau delegasi TensorFlow Lite yang ada.