Ringkasan LiteRT Next

LiteRT Next adalah kumpulan API baru yang meningkatkan LiteRT, terutama dalam hal akselerasi hardware dan performa untuk aplikasi ML dan AI di perangkat. API ini adalah rilis alfa dan tersedia di Kotlin dan C++.

LiteRT Next Compiled Model API dibuat berdasarkan TensorFlow Lite Interpreter API, dan menyederhanakan proses pemuatan dan eksekusi model untuk machine learning di perangkat. API baru ini menyediakan cara baru yang disederhanakan untuk menggunakan akselerasi hardware, sehingga Anda tidak perlu menangani FlatBuffers model, interoperabilitas buffer I/O, dan delegasi. LiteRT Next API tidak kompatibel dengan LiteRT API. Untuk menggunakan fitur dari LiteRT Next, lihat panduan Mulai Mulai.

Misalnya, implementasi LiteRT Next, lihat aplikasi demo berikut:

Panduan memulai

Menjalankan inferensi dengan LiteRT Next API melibatkan langkah-langkah utama berikut:

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

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

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));

Kotlin

// 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 informasi selengkapnya, lihat panduan Mulai Menggunakan Kotlin dan Mulai Menggunakan C++.

Fitur utama

LiteRT Next berisi manfaat dan fitur utama berikut:

  • LiteRT API baru: Menyederhanakan pengembangan dengan pemilihan accelerator otomatis, eksekusi asinkron sejati, dan penanganan buffering I/O yang efisien.
  • Performa GPU Terbaik di Kelasnya: Menggunakan akselerasi GPU canggih untuk ML di perangkat. Interoperabilitas buffering baru memungkinkan zero-copy dan meminimalkan latensi di berbagai jenis buffering GPU.
  • Inferensi AI Generatif yang unggul: Mengaktifkan integrasi paling sederhana dengan performa terbaik untuk model GenAI.
  • Unified NPU Acceleration: Menawarkan akses yang lancar ke NPU dari penyedia chipset utama dengan pengalaman developer yang konsisten. Akselerasi LiteRT NPU tersedia melalui Program Akses Awal.

Peningkatan utama

LiteRT Next (Compiled Model API) berisi peningkatan utama berikut pada LiteRT (TFLite Interpreter API). Untuk panduan lengkap menyiapkan aplikasi dengan LiteRT Next, lihat panduan Memulai.

  • Penggunaan akselerator: Menjalankan model di GPU dengan LiteRT memerlukan pembuatan delegator, panggilan fungsi, dan modifikasi grafik eksplisit. Dengan LiteRT Berikutnya, cukup tentukan akselerator.
  • Interoperabilitas buffer hardware native: LiteRT tidak menyediakan opsi buffer, dan memaksa semua data melalui memori CPU. Dengan LiteRT Next, Anda dapat meneruskan Buffer Hardware Android (AHWB), buffer OpenCL, buffer OpenGL, atau buffer khusus lainnya.
  • Eksekusi asinkron: LiteRT Next dilengkapi dengan API asinkron yang didesain ulang, yang menyediakan mekanisme asinkron sejati berdasarkan pembatasan sinkronisasi. Hal ini memungkinkan waktu eksekusi keseluruhan yang lebih cepat melalui penggunaan hardware yang beragam – seperti CPU, GPU, CPU, dan NPU – untuk berbagai tugas.
  • Pemuatan model: LiteRT Next tidak memerlukan langkah builder terpisah saat memuat model.