CLI LiteRT 101: Menyederhanakan Alur Kerja AI Edge Anda

1. 🏁 Pengantar & ringkasan CLI

Selamat datang di codelab praktis LiteRT CLI 101! Panduan ini dirancang untuk memandu Anda langkah demi langkah dari penyiapan lingkungan nol hingga men-deploy kecerdasan edge yang dioptimalkan.

🌟 Latar belakang

Edge AI memerlukan penerapan model saraf kompleks langsung ke ponsel, perangkat wearable, dan hardware sematan.

• LiteRT (sebelumnya TensorFlow Lite / TFLite) adalah framework di perangkat Google untuk deployment ML & GenAI berperforma tinggi di platform edge, melalui konversi, runtime, dan pengoptimalan yang efisien.
• CLI LiteRT mengintegrasikan stack AI Edge Google ke dalam perintah shell mandiri (litert) untuk menyederhanakan alur kerja pengembangan terkait LiteRT, termasuk mengonversi, menguantisasi, mengompilasi, menjalankan, melakukan tolok ukur, dan memvisualisasikan model LiteRT (TFLite) di berbagai hardware (CPU / GPU / NPU) di seluruh platform (desktop, seluler, atau cloud).

2. 🔄 Alur kerja dasar: konversi, kuantisasi & jalankan

Di bagian ini, mari kita jalankan siklus proses pemodelan Edge AI lengkap dengan LiteRT CLI: Pembungkus model PyTorch ➔ konversi pelacakan ➔ kuantisasi model ➔ inferensi desktop ➔ tolok ukur performa.

Untuk dukungan Notebook Jupyter interaktif di bagian ini, coba jalankan sebagai notebook.

📝 Tahap 1: Siapkan skrip wrapper model PyTorch

Buat resnet18.py di direktori saat ini. Ekspor ini menampilkan hook pelacakan dinamis sehingga pembuat grafik dapat merekam bentuk:

import torch
import torchvision

def get_model(batch_size: int = 1) -> torch.nn.Module:
  model = torchvision.models.resnet18(
      weights=torchvision.models.ResNet18_Weights.IMAGENET1K_V1
  )
  model.eval()
  return model

def get_args(batch_size: int = 1) -> tuple[torch.Tensor, ...]:
  return (torch.randn(batch_size, 3, 224, 224),)

🔄 Tahap 2: Mengonversi model PyTorch ke LiteRT menggunakan LiteRT Torch

Panggil konverter Torch LiteRT untuk membuat model target .tflite Float32 standar:

# Convert PyTorch source to LiteRT
litert convert resnet18.py --output resnet18

# Verify target was exported
ls -lh resnet18/resnet18.tflite

📉 Tahap 3: Menguantisasi bobot ke INT8

Terapkan kartu resep dinamis dan hanya berat untuk mengecilkan ukuran hingga ~4x:

# 1. Dynamic Range Quantization (Dynamic activations + static INT8 weights)
litert quantize resnet18/resnet18.tflite \
  --recipe dynamic_wi8_afp32 \
  --output resnet18/resnet18_int8_dynamic.tflite

# 2. Weight-Only Quantization (Float32 activations + static INT8 weights)
litert quantize resnet18/resnet18.tflite \
  --recipe weight_only_wi8_afp32 \
  --output resnet18/resnet18_int8_weight_only.tflite

🚀 Tahap 4: Jalankan Inferensi secara lokal

Jalankan operasi pengujian dengan parameter input dummy untuk memverifikasi pemblokiran performa:

# Run original Float32 model inference
litert run resnet18/resnet18.tflite --desktop --cpu

# Run optimized Dynamic INT8 model inference
litert run resnet18/resnet18_int8_dynamic.tflite --cpu --iterations 1

📊 Tahap 5: Tolok ukur performa model

Ukur metrik presisi tinggi termasuk latensi rata-rata, biaya inisialisasi, throughput eksekusi CPU, dan jejak memori aktif dinamis:

# Benchmark original Float32 model
litert benchmark resnet18/resnet18.tflite --desktop --cpu

# Benchmark optimized Dynamic range INT8 model
litert benchmark resnet18/resnet18_int8_dynamic.tflite --desktop --cpu

3. 🔌 Penyiapan & verifikasi lingkungan lokal

Mari buat sandbox yang bersih dan terisolasi di workstation Anda (macOS atau Linux)

Sebaiknya gunakan uv (pengelola paket Python berbasis Rust generasi berikutnya) untuk mendownload dependensi yang sangat cepat dan penyiapan dinamis, dan Anda juga dapat menggunakan pip standar dalam lingkungan virtual Python.

🔌 Opsi A: Penyiapan sangat cepat (uv)

Menggunakan uv mengisolasi library dalam hitungan detik, sehingga menghilangkan konflik cache lingkungan.

# Create active workspace sandbox
uv venv --clear --python=3.13 --seed
source .venv/bin/activate

# Install litert-cli from pypi
uv pip install litert-cli-nightly

🐍 Opsi B: Penyiapan standar (pip)

Jika uv tidak ada, gunakan konfigurasi lingkungan virtual Python standar:

# Create active workspace sandbox
python3 -m venv .venv
source .venv/bin/activate

# Install litert-cli from pypi
pip install --upgrade pip setuptools wheel
pip install litert-cli-nightly

🛠️ Opsi C: Penyiapan lokal yang dapat diedit

Jika Anda mengembangkan atau menguji langsung di dalam clone direktori sumber repositori:

# Create active workspace sandbox
uv venv --clear --python=3.13 --seed
source .venv/bin/activate

# Install from local directory root
uv pip install -e .

🔍 Verifikasi penyiapan

Pastikan jalur Anda merutekan perintah litert dengan benar:

litert --help

Pemblokir kredensial proxy perusahaan / indeks sederhana pribadi: Jika penginstalan build gagal dengan 401 Unauthorized karena aturan indeks kustom pribadi, paksa pencarian untuk merutekan langsung ke PyPI standar:

export UV_INDEX_URL=https://pypi.org/simple

💡 Katalog Referensi Model (model-ref) pusat

Untuk menjaga agar skrip dan pengembangan tetap andal, CLI LiteRT menerapkan Katalog Model terpusat:

• Format: Tetapkan nama unik (alias) ke model yang didownload atau diimpor, seperti mobilenet.
• Varian: Gunakan titik dua target untuk merujuk ke variasi yang dioptimalkan, seperti mobilenet:int8 atau mobilenet:gpu.
• Kesederhanaan: Semua perintah CLI menerima alias tanpa jalur ini secara langsung, yang secara otomatis menyelesaikan penyimpanan file fisik dengan cepat.

4. 📲 Deployment & pembuatan profil perangkat

Mari kita lanjutkan pengoptimalan dengan menjalankan tolok ukur lokal presisi tinggi, men-deploy ke target hardware USB yang sebenarnya, menerapkan delegasi hardware, mengompilasi Ahead-of-Time, dan tolok ukur cloud.

Untuk bagian ini, Anda perlu menghubungkan perangkat Android dengan ADB yang diaktifkan. Untuk mengaktifkan proses debug USB di perangkat Anda:

• Buka Setelan > Tentang ponsel.
• Ketuk Nomor build 7 kali hingga Anda melihat "Anda sekarang adalah developer".
• Kembali ke Setelan > Sistem > Opsi developer (atau Setelan > Opsi developer di beberapa perangkat).
• Aktifkan Proses debug USB.

📊 Metrik pembuatan profil lokal

Download EfficientNet-B1 dan profil statistik performa di host desktop Anda:

# Download and register model alias in central catalog
litert download litert-community/efficientnet_b1 --file "*.tflite" --output efficientnet
litert import efficientnet/efficientnet_b1.tflite --model-ref efficientnet_b1

# Run high-precision benchmark on desktop CPU
litert benchmark efficientnet_b1 --desktop --cpu

Amati header performa utama dalam log tolok ukur:

• Model initialization: Waktu untuk mem-boot jaringan struktural.
• Warmup (avg): Waktu overhead kompilasi.
• Inference (avg): Waktu pemrosesan matematika mentah.
• Overall footprint: RAM puncak yang digunakan selama eksekusi.

📲 Target A: CPU Seluler (koneksi USB)

Hubungkan perangkat Android dengan Proses Debug USB yang diaktifkan, lalu deploy:

# 1. Confirm device connection
adb devices

# 2. Push and execute model on mobile CPU
litert run efficientnet_b1 --android --cpu

CLI akan otomatis mengirimkan model ke perangkat target, menjalankan loop inferensi, dan mengirimkan kembali output.

🎮 Target B: GPU Seluler

Memindahkan workload berat secara dinamis ke GPU menggunakan OpenCL atau WebGPU:

# Benchmark model performance on mobile GPU
litert benchmark efficientnet_b1 --android --gpu

# Run inference with GPU acceleration and CPU fallback
litert run efficientnet_b1 --android --accelerator gpu,cpu

⚙️ Target C: JIT Android NPU

Menurunkan parameter eksekusi langsung ke NPU pada chipset modern:

# Run with on-device JIT NPU acceleration
litert run efficientnet_b1 --android --accelerator npu,cpu

• Peringatan: Build grafik dinamis di dalam runtime di perangkat mengalami penundaan pemanasan JIT inisialisasi yang signifikan.

🚀 Target D: NPU yang dikompilasi AOT

Kompilasi offline terlebih dahulu untuk melewati overhead JIT runtime dan mencapai akselerasi maksimum:

# 1. Offline compile for Qualcomm SM8750 NPU (Linux host)
litert compile efficientnet/efficientnet_b1.tflite --target sm8750

# 2. Execute compiled AOT binary with zero JIT warmup latency
litert run efficientnet_b1_Qualcomm_SM8750.tflite --android --npu

☁️ Pembuatan profil cloud (Google AI Edge Portal)

Mendorong pengujian ke profil hardware jarak jauh di farm perangkat Google Cloud.

# Log in to your Google Cloud project
gcloud auth login

# Push benchmark metrics to Pixel 7 CPU
litert benchmark efficientnet_b1 --gcp --device "pixel 7" --cpu --gcp-project "your-project-id"

# Push benchmark metrics to Snapdragon GPU targets
litert benchmark efficientnet_b1 --gcp --devices "pixel 7, sm-s931u1" --gpu --gcp-project "your-project-id"

5. 🧠 Topik lanjutan: LLM & pengenalan ucapan

Mari jelajahi model tingkat lanjut dengan mengonversi dan menjalankan model Bahasa Besar (LLM) dan Pengenalan Ucapan Otomatis (ASR).

💬 AI Generatif (LLM)

LLM Edge dibatasi oleh memori. Kami menyelesaikan masalah ini dengan menerapkan kuantisasi Weight-Only INT4/INT8, yang mengompresi bobot sambil mempertahankan saluran eksekusi di Float32:

# 1. Automated download & conversion from Hugging Face
litert convert Qwen/Qwen1.5-0.5B-Chat --output models/qwen

# 2. Quantize model weights to INT4
litert convert Qwen/Qwen1.5-0.5B-Chat \
  --quantize-recipe weight_only_wi4_afp32 \
  --output models/qwen_w4

# 3. Generation once
litert lm run models/qwen/model.litertlm --prompt "Introduce San Francisco."

# 4. Interactive chat
litert lm run models/qwen/model.litertlm

🎙️ Pemrosesan ucapan (ASR)

Model ASR seperti Whisper atau Parakeet memiliki modul encoder dan decoder. Kita dapat melakukan tolok ukur untuk modul tertentu menggunakan Kunci Tanda Tangan:

# 1. Download prepackaged Whisper-Tiny
litert download litert-community/whisper-tiny --file "whisper_tiny_30s_f32.tflite" --output "models/whisper_tiny"

# 2. Profile audio encoding
litert benchmark models/whisper_tiny/whisper_tiny_30s_f32.tflite --android --gpu --signature-key "encode"

# 3. Profile text token decoding loop
litert benchmark models/whisper_tiny/whisper_tiny_30s_f32.tflite --android --cpu --signature-key "decode"

6. 🤖 Penggunaan dalam coding agentic

CLI LiteRT kompatibel dengan agen, dan Anda dapat mengintegrasikannya langsung dengan agen coding.

Berikut ini beberapa contohnya. Tambahkan kemampuan CLI LiteRT SKILL.md ke agen coding Anda (seperti Google Antigravity) dan coba perintah seperti di bawah.

💡 Konversi, kuantisasi, tolok ukur, dan laporan perintah

"Download model FP32 litert-community/efficientnet_b1 , lakukan kuantisasi ke rentang dinamis INT8 (–recipe dynamic_wi8_afp32), lalu lakukan tolok ukur pada model FP32 asli dan model INT8 yang baru dikuantisasi di GPU perangkat Android yang terhubung. Bandingkan latensi rata-rata dan laporkan peningkatan kecepatan throughput."

💡 Perintah kompilasi dan tolok ukur NPU

"Konfirmasi apakah saya memiliki perangkat Android yang terhubung untuk proses debug USB. Jika aktif, download litert-community/efficientnet_b1 dan kompilasi offline (AOT) untuk NPU Qualcomm sm8750. Tulis model target ke ./models/compiled, kirim model ke ponsel, jalankan inferensi di perangkat, dan verifikasi latensi pemanasan JIT nol."

7. 🚀 Selamat & langkah berikutnya

🎉 Luar biasa! Anda telah menyelesaikan codelab LiteRT CLI 101.

Anda kini memiliki keterampilan untuk menguasai pengembangan ML di perangkat edge:

• Mengonversi model PyTorch menjadi model LiteRT.
• Kuantisasi bobot model ke INT4/INT8.
• Jalankan model di CPU/GPU/NPU seluler.
• Kompilasi untuk NPU.
• Benchmark di desktop, perangkat seluler, dan cloud.
• Mengonversi dan menjalankan model LLM.
• Penggunaan dalam coding agentic.

🔗 Referensi

• CLI LiteRT: https://github.com/google-ai-edge/LiteRT-CLI
• LiteRT: https://ai.google.dev/edge/litert
• Contoh: https://github.com/google-ai-edge/LiteRT-CLI/tree/main/examples