TF Lite Delegate: apa itu, delegasi GPU dan NNAPI

Apa itu TF Lite Delegate: arsitektur dan prinsip kerja

TF Lite Delegate — adalah adaptor perangkat lunak antara TensorFlow Lite Runtime dan akselerator perangkat keras perangkat. Delegasi mencegat operasi grafik model (konvolusi, pooling, perkalian matriks) dan menjalankannya pada komputator khusus alih-alih CPU. Jika delegasi tidak mendukung operasi tertentu, operasi tersebut dijalankan pada CPU — ini disebut partial delegation.

Arsitektur TF Lite Delegate dibangun di sekitar antarmuka SimpleDelegate API dan struktur TfLiteDelegate dalam C++. Setiap delegasi mengimplementasikan metode pendelegasian simpul grafik, alokasi memori, dan eksekusi pada perangkat target. Pengembang menghubungkan delegasi melalui Interpreter::ModifyGraphWithDelegate sebelum memanggil Invoke. Menurut TensorFlow Guide, delegasi diterapkan secara otomatis ke semua operasi yang didukung model.

Pemeriksaan kompatibilitas — tahap wajib. Tidak semua operasi didukung oleh setiap delegasi. TensorFlow Lite menyediakan alat Delegation Compatibility Check: jalankan model dengan delegasi dan periksa berapa banyak operasi (ops) yang didelegasikan. Jika kurang dari 80% — lebih baik pilih delegasi lain atau tetap menggunakan CPU. Menurut TensorFlow (2025), GPU Delegate mendukung 45 operasi, NNAPI — 60+.

Dalam proyek IT Sectr kami menggunakan delegasi GPU untuk iOS dan XNNPACK untuk Android dengan pemeriksaan kompatibilitas bawaan: model diuji pada semua delegasi, yang tercepat dengan kelengkapan delegasi setidaknya 90% dipilih.

// Koneksi GPU Delegate di Android
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

Pemeriksaan operasi yang didelegasikan — kontrol kompatibilitas melalui Interpreter. Secara default, delegasi menerima semua operasi yang didukungnya. Untuk debugging, gunakan pencatatan jumlah simpul yang didelegasikan. Jika model berisi operasi kustom (custom ops), delegasi tidak mempercepatnya tetapi juga tidak merusaknya — operasi tersebut dijalankan pada CPU.

// Periksa jumlah operasi yang didelegasikan
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Didelegasikan: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // Ambang 80% — pilih delegasi lain
}

GPU Delegate: akselerasi pada prosesor grafis

GPU Delegate — delegasi TensorFlow Lite untuk menjalankan model pada GPU melalui OpenGL ES 3.1+ (Android) atau Metal (iOS). Prosesor grafis dioptimalkan untuk operasi matriks paralel — Core ML dan jaringan saraf konvolusional (CNN) mendapatkan peningkatan terbesar. GPU Delegate mengurangi latensi inferensi 4–8 kali untuk model seperti MobileNet, EfficientNet, Inception.

Keterbatasan GPU Delegate: tidak mendukung semua operasi (hanya 45 dari ~120 di TF Lite), memerlukan OpenGL ES 3.1 atau Metal, mengonsumsi lebih banyak energi daripada CPU. GPU tidak efisien untuk batch size > 1 dalam skenario seluler. Menurut benchmark TensorFlow (2025), pada perangkat Pixel 8 dengan GPU Adreno 740, model MobileNetV2 berjalan dalam 4.2 ms pada GPU dibandingkan 18.7 ms pada CPU — akselerasi 4.4x.

Konfigurasi GPU Delegate mencakup pemilihan presisi: float16 mengurangi akurasi tetapi mempercepat inferensi sebesar 30–40% tanpa kehilangan kualitas yang terlihat (untuk sebagian besar tugas). Aktifkan allow_precision_loss=true untuk kinerja maksimal pada GPU. Untuk tugas dengan presisi tinggi (medis, keuangan) gunakan float32.

// GPU Delegate dengan optimasi presisi
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate di iOS menggunakan Metal Performance Shaders melalui Metal Delegate. Di iOS, delegasi bekerja melalui Core ML delegate untuk Apple Neural Engine atau langsung melalui Metal. Apple A17 Pro menjalankan MobileNetV2 dalam 1.3 ms — 6 kali lebih cepat dari CPU. Metal delegate tersedia sejak iOS 12 dan mendukung semua perangkat dengan chip A7+.

NNAPI Delegate: jaringan saraf di Android melalui Neural Networks API

NNAPI Delegate (Android Neural Networks API) — delegasi TF Lite yang menggunakan akselerasi perangkat keras melalui Android NN HAL (Hardware Abstraction Layer). NNAPI mengarahkan operasi model ke NPU, DSP atau GPU tergantung pada driver perangkat yang tersedia. Didukung pada Android 8.1+ (API 27+) dan merupakan delegasi default yang direkomendasikan untuk Android.

Keunggulan NNAPI — pemilihan akselerator otomatis. Jika perangkat memiliki NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU), NNAPI mendelegasikan operasi ke NPU tersebut. Jika tidak ada NPU — ke GPU melalui OpenCL. Jika GPU juga tidak mendukung — ke CPU dengan optimasi DSP. Pengembang tidak menentukan akselerator tertentu — NNAPI memilih yang optimal. Menurut Google I/O 2024, delegasi NNAPI pada Snapdragon 8 Gen 3 mempercepat model LLM 12 kali.

Keterbatasan NNAPI: dukungan tidak merata di berbagai perangkat. Perangkat lama (Android 8.1) memiliki set driver terbatas. Huawei dengan Kirin tidak mendukung NNAPI melalui Google Services — gunakan GPU Delegate. Untuk kompatibilitas terjamin, Google merekomendasikan NNAPI Delegate sebagai pilihan pertama, dengan fallback ke GPU atau XNNPACK.

// NNAPI Delegate dengan fallback CPU
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = pilih otomatis
    allowFp16 = true
    executionPreference = NnApiDelegate.ExecutionPreference.SUSTAINED_SPEED
}
val delegate = NnApiDelegate(nnApiOptions)
val interpreter = Interpreter(model, Interpreter.Options().apply {
    addDelegate(delegate)
    setNumThreads(4)
})

NNAPI Accelerator Name — parameter untuk pemilihan akselerator secara eksplisit. Jika null diteruskan, NNAPI memilih secara otomatis. Untuk pengujian, tentukan yang spesifik: "qti", "google-edgetpu", "mediatek". Daftar akselerator yang tersedia ditampilkan melalui NnApiDelegate.getAvailableAccelerators(). Dalam produksi, gunakan pemilihan otomatis dengan ambang kompatibilitas.

XNNPACK Delegate: optimasi CPU melalui SIMD

XNNPACK Delegate — delegasi TensorFlow Lite untuk eksekusi yang dioptimalkan pada CPU melalui instruksi SIMD (ARM NEON, SSE, AVX). XNNPACK tidak memerlukan GPU atau NPU — ini adalah delegasi CPU murni, tetapi dengan akselerasi 2–4x berkat SIMD, operator fusion, memory pre-fetching dan quantized inference (INT8). Ideal untuk perangkat tanpa NPU khusus atau ketika kompatibilitas terjamin diperlukan.

XNNPACK dikembangkan oleh Google sebagai delegasi default TF Lite untuk CPU (tertanam dalam TFLite Runtime secara default). Mendukung 90+ operasi — lebih banyak dari GPU atau NNAPI. XNNPACK sangat efisien untuk model terkuantisasi (INT8, INT16): operasi berjalan 2–3 kali lebih cepat dari versi float32. Menurut benchmark Google (2025), XNNPACK mempercepat INT8 MobileNetV2 2.8x relatif terhadap CPU dasar.

XNNPACK vs GPU: pada perangkat tanpa NPU, XNNPACK sering lebih cepat dari GPU Delegate untuk batch kecil (1–4) — GPU memiliki overhead transfer data antara CPU dan GPU. XNNPACK bekerja di ruang alamat CPU yang sama — tidak ada penyalinan memori. Untuk model hingga 5MB, XNNPACK bisa lebih cepat dari GPU. Untuk model CNN besar, GPU menang berkat paralelisme.

// XNNPACK Delegate diaktifkan secara default di TFLite 2.18+
// Penggunaan eksplisit melalui XnnpackDelegate
val xnnpackOptions = XnnpackDelegate.Options().apply {
    numThreads = 4
    flags = XnnpackDelegate.Flags.USE_XNNPACK
}
val delegate = XnnpackDelegate(xnnpackOptions)
val interpreter = Interpreter(modelBuffer, Interpreter.Options().apply {
    addDelegate(delegate)
})

XNNPACK Flags: USE_XNNPACK — memaksa mengaktifkan delegasi, FLUSH_TO_ZERO — pemrosesan angka denormalisasi untuk akselerasi, ENABLE_XNNPACK_SHAPES — ukuran input dinamis. Untuk kompatibilitas maksimal, gunakan opsi default. Jika terjadi kesalahan pada perangkat lama, nonaktifkan XNNPACK — model masih berjalan di CPU, tetapi lebih lambat.

Core ML dan Metal Delegate: akselerasi di iOS

Core ML Delegate — delegasi TensorFlow Lite untuk iOS yang menggunakan Apple Core ML Framework. Core ML mengonversi model TF Lite ke format .mlmodel dan menjalankannya pada Apple Neural Engine (ANE), GPU (Metal) atau CPU. Apple A17 Pro dan M3 memiliki Neural Engine khusus yang digunakan Core ML secara otomatis. Core ML Delegate mempercepat inferensi 5–10 kali relatif terhadap CPU pada perangkat iOS modern.

Core ML di iOS mendukung flex delegate (pendelegasian dinamis operasi yang tersedia di Core ML) dan full model conversion (konversi seluruh model ke .mlmodel). Apple merekomendasikan flex delegate — lebih cepat karena bekerja saat runtime tanpa konversi sebelumnya. Core ML Delegate mendukung model float32, float16 dan terkuantisasi (INT8).

Metal Delegate — delegasi tingkat lebih rendah yang bekerja langsung dengan Metal Performance Shaders. Gunakan Metal ketika Core ML tidak mendukung operasi tertentu. Metal Delegate memberikan kontrol maksimal atas GPU, tetapi membutuhkan lebih banyak kode. Menurut Apple (WWDC 2024), Metal Delegate untuk model Swift asli bisa 15–20% lebih cepat dari Core ML karena tidak ada overhead konversi.

// Core ML Delegate di iOS melalui TFLite Swift API
import TensorFlowLite

let coreMLDelegate = CoreMLDelegate()
var options = InterpreterOptions()
options.addDelegate(coreMLDelegate)

let interpreter = try Interpreter(modelPath: modelPath, options: options)
try interpreter.invoke(at: 0)

Pilihan antara Core ML dan Metal: Core ML — untuk produksi, Metal — untuk kasus tepi. Core ML secara otomatis mengelola memori NE, mendukung fallback ke CPU dan tidak memerlukan konversi manual. Metal memberikan kontrol atas buffer dan cocok untuk operasi kustom. Dalam proyek IT Sectr kami menggunakan Core ML Delegate untuk semua model iOS dan Metal hanya untuk tugas analisis video real-time.

Cara memilih delegasi untuk proyek

Pemilihan TF Lite Delegate tergantung pada platform target, model dan persyaratan latensi. Tidak ada delegasi universal terbaik — masing-masing memiliki kelebihan dan kekurangan. Strategi optimal: uji semua delegasi yang tersedia pada perangkat target dan pilih yang minimal cukup cepat — bukan yang tercepat, tetapi yang minimal mencukupi.

Rekomendasi pemilihan: untuk Android dengan NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Untuk Android tanpa NPU — XNNPACK Delegate (default). Untuk iOS — Core ML Delegate. Untuk proyek lintas platform, gunakan strategi: NNAPI di Android, Core ML di iOS, XNNPACK sebagai fallback. GPU Delegate — ketika NNAPI tidak tersedia dan XNNPACK tidak cukup cepat.

Pengujian latensi — tahap pemilihan wajib. Ukur inferensi pada suhu minimal (perangkat dingin) dan setelah 5 menit kerja terus-menerus (thermal throttling). GPU dan NNAPI dapat menurunkan kinerja saat memanas. XNNPACK (CPU) lebih tahan. Gunakan TensorFlow Lite Benchmark Tool untuk pengujian otomatis semua delegasi pada perangkat Anda.

// Strategi pemilihan delegasi
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Strategi Fallback — muat model tanpa pengecualian: jika delegasi tidak didukung, jalankan di CPU. TensorFlow Lite melempar IllegalArgumentException saat kesalahan pembuatan delegasi. Bungkus pembuatan delegasi dalam try-catch dan saat kesalahan jalankan model tanpa delegasi. AI yang lambat tetapi berfungsi lebih baik daripada error bagi pengguna.