LiteRT CLI 101: usprawnij przepływy pracy związane z AI na urządzeniach brzegowych

1. 🏁 Wprowadzenie i omówienie interfejsu wiersza poleceń

Witamy w praktycznym ćwiczeniu z programowania LiteRT CLI 101. Ten przewodnik przeprowadzi Cię krok po kroku od konfiguracji środowiska do wdrożenia zoptymalizowanej inteligencji brzegowej.

🌟 Informacje ogólne

AI na urządzeniach brzegowych wymaga przeniesienia złożonych modeli neuronowych bezpośrednio na telefony komórkowe, urządzenia do noszenia i sprzęt wbudowany.

• LiteRT (wcześniej TensorFlow Lite / TFLite) to opracowana przez Google platforma do wdrażania na urządzeniach brzegowych modeli ML i GenAI o wysokiej wydajności dzięki wydajnej konwersji, środowisku wykonawczemu i optymalizacji.
• LiteRT CLI integruje stosy Google AI Edge z samodzielnym poleceniem powłoki (litert), aby usprawnić przepływy pracy związane z LiteRT, w tym konwersję, kwantyzację, kompilację, uruchamianie, testowanie i wizualizację modeli LiteRT (TFLite) na różnych platformach (komputer, urządzenie mobilne lub chmura) i sprzęcie (procesor, GPU, NPU).

2. 🔄 Podstawowe przepływy pracy: konwersja, kwantyzacja i uruchamianie

W tej sekcji wykonamy pełny cykl życia modelowania AI na urządzeniach brzegowych za pomocą LiteRT CLI: otoka modelu PyTorch ➔ konwersja śledzenia ➔ kwantyzacja modelu ➔ wnioskowanie na komputerze ➔ testy wydajności.

Aby uzyskać interaktywną obsługę notatnika Jupyter w tej sekcji, spróbuj uruchomić go jako notatnik.

📝 Etap 1. Przygotuj skrypt otoki modelu PyTorch

W bieżącym katalogu utwórz plik resnet18.py. Udostępnia on dynamiczne haki śledzenia, dzięki czemu narzędzie do tworzenia wykresów może przechwytywać kształty:

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

🔄 Etap 2. Skonwertuj model PyTorch na LiteRT za pomocą LiteRT Torch

Wywołaj konwerter LiteRT Torch, aby utworzyć standardowy model docelowy Float32 .tflite:

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

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

📉 Etap 3. Skwantyzuj wagi do INT8

Zastosuj karty dynamiczne i karty tylko z wagami, aby zmniejszyć rozmiar około 4-krotnie:

# 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

🚀 Etap 4. Uruchom wnioskowanie lokalnie

Wykonaj operacje testowe z fikcyjnymi parametrami wejściowymi, aby sprawdzić bloki wydajności:

# 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

📊 Etap 5. Przeprowadź testy wydajności modelu

Zmierz dane o wysokiej precyzji, w tym średnie opóźnienie, koszty inicjowania, przepustowość wykonywania na procesorze i dynamiczne ślady pamięci aktywnej:

# 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. 🔌 Konfiguracja i weryfikacja środowiska lokalnego

Utwórzmy izolowane, czyste środowisko testowe na Twojej stacji roboczej (macOS lub Linux).

Do pobierania zależności i dynamicznej konfiguracji zalecamy używanie uv (menedżera pakietów Pythona nowej generacji opartego na Rust), ale możesz też używać standardowego narzędzia pip w środowisku wirtualnym Pythona.

🔌 Opcja A. Szybka konfiguracja (uv)

Użycie uv izoluje biblioteki w ciągu kilku sekund, usuwając konflikty pamięci podręcznej środowiska.

# 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

🐍 Opcja B. Standardowa konfiguracja (pip)

Jeśli uv nie jest dostępne, użyj standardowych konfiguracji środowiska wirtualnego Pythona:

# 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

🛠️ Opcja C. Konfiguracja lokalna z możliwością edycji

Jeśli tworzysz lub testujesz bezpośrednio w sklonowanym katalogu źródłowym repozytorium:

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

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

🔍 Sprawdzanie konfiguracji

Sprawdź, czy ścieżka prawidłowo kieruje polecenie litert:

litert --help

Blokery proxy firmowego / poświadczeń prywatnego prostego indeksu: jeśli instalacje kompilacji nie powiodą się z powodu błędu 401 Unauthorized ze względu na prywatne reguły indeksu niestandardowego, wymuś wyszukiwanie, aby kierować bezpośrednio do standardowego PyPI:

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

💡 Centralny katalog odniesień do modeli (model-ref)

Aby zapewnić niezawodność skryptów i procesu tworzenia, LiteRT CLI implementuje scentralizowany katalog modeli:

• Format: przypisz pobranemu lub zaimportowanemu modelowi unikalną nazwę (alias), np. mobilenet.
• Warianty: używaj dwukropków docelowych, aby odwoływać się do zoptymalizowanych wariantów, np. mobilenet:int8 lub mobilenet:gpu.
• Prostota: wszystkie polecenia CLI akceptują ten alias bez ścieżki bezpośrednio, automatycznie rozwiązując fizyczne przechowywanie plików w locie.

4. 📲 Wdrażanie i profilowanie na urządzeniu

Zoptymalizujmy jeszcze bardziej, przeprowadzając lokalne testy o wysokiej precyzji, wdrażając na rzeczywistych urządzeniach USB, implementując delegatów sprzętowych, kompilując z wyprzedzeniem i przeprowadzając testy w chmurze.

W tej części musisz podłączyć urządzenie z Androidem z włączonym ADB. Aby włączyć debugowanie USB na urządzeniu:

• Otwórz kolejno Ustawienia > Informacje o telefonie.
• Kliknij Numer kompilacji 7 razy, aż zobaczysz komunikat „Jesteś teraz programistą”.
• Wróć do Ustawienia > System > Opcje programisty (lub Ustawienia > Opcje programisty na niektórych urządzeniach).
• Włącz Debugowanie USB.

📊 Lokalne dane profilowania

Pobierz EfficientNet-B1 i profiluj statystyki wydajności na komputerze:

# 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

Zwróć uwagę na kluczowe nagłówki wydajności w dzienniku testów:

• Model initialization (Inicjowanie modelu): czas uruchamiania sieci strukturalnych.
• Warmup (avg) (Rozgrzewka (średnia)): czasy narzutu kompilacji.
• Inference (avg) (Wnioskowanie (średnia)): czas przetwarzania matematycznego.
• Overall footprint (Całkowity rozmiar): szczytowe zużycie pamięci RAM podczas wykonywania.

📲 Cel A. Procesor mobilny (połączenie USB)

Podłącz urządzenie z Androidem z włączonym debugowaniem USB i wdróż:

# 1. Confirm device connection
adb devices

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

Interfejs wiersza poleceń automatycznie przesyła model na urządzenie docelowe, wykonuje pętlę wnioskowania i przekazuje wyniki.

🎮 Cel B. Mobilny GPU

Dynamicznie przenoś obciążenia do GPU za pomocą OpenCL lub 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

⚙️ Cel C. NPU JIT Android

Przenoś parametry wykonania bezpośrednio do NPU w nowoczesnych chipsetach:

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

• Ostrzeżenie: dynamiczne kompilacje wykresów w środowisku wykonawczym na urządzeniu powodują znaczne opóźnienia rozgrzewki JIT.

🚀 Cel D. NPU skompilowany AOT

Kompiluj offline, aby ominąć narzuty JIT środowiska wykonawczego i uzyskać maksymalne przyspieszenie:

# 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

☁️ Profilowanie w chmurze (AI Edge Portal)

Przesyłaj testy do zdalnych profili sprzętowych w farmach urządzeń 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. 🧠 Zaawansowane tematy: LLM i rozpoznawanie mowy

Poznajmy zaawansowane modele, konwertując i uruchamiając duże modele językowe (LLM) oraz modele automatycznego rozpoznawania mowy (ASR).

💬 Generatywna AI (LLM)

LLM na urządzeniach brzegowych są ograniczone pamięcią. Rozwiązujemy ten problem, stosując kwantyzację Weight-Only INT4/INT8 , która kompresuje wagi, zachowując kanały wykonania w 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

🎙️ Przetwarzanie mowy (ASR)

Modele ASR, takie jak Whisper czy Parakeet, mają moduł enkodera i dekodera. Możemy przeprowadzać testy dla konkretnych modułów za pomocą kluczy podpisu:

# 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. 🤖 Używanie w kodowaniu agentowym

LiteRT CLI jest przyjazny dla agentów i można go zintegrować bezpośrednio z agentami kodowania.

Oto kilka przykładów. Dodaj umiejętność LiteRT CLI SKILL.md do agenta kodowania (np. Google Antigravity) i wypróbuj polecenia takie jak te poniżej.

💡 Polecenie konwersji, kwantyzacji, testowania i raportowania

„Pobierz model FP32 litert-community/efficientnet_b1, skwantyzuj go do zakresu dynamicznego INT8 (–recipe dynamic_wi8_afp32), a następnie przeprowadź testy zarówno oryginalnego modelu FP32, jak i nowo skwantyzowanego modelu INT8 na GPU podłączonego urządzenia z Androidem. Porównaj średnie opóźnienie i zgłoś przyspieszenie przepustowości”.

💡 Polecenie kompilacji i testowania NPU

„Sprawdź, czy mam podłączone urządzenie z Androidem z włączonym debugowaniem USB. Jeśli jest aktywne, pobierz litert-community/efficientnet_b1 i skompiluj offline (AOT) dla NPU Qualcomm sm8750. Zapisz model docelowy w ./models/compiled, prześlij model na telefon, uruchom wnioskowanie na urządzeniu i sprawdź, czy nie ma opóźnień rozgrzewki JIT”.

7. 🚀 Gratulacje i dalsze kroki

🎉 Gratulacje! Udało Ci się ukończyć ćwiczenie z programowania LiteRT CLI 101.

Masz teraz umiejętności, które pozwolą Ci opanować tworzenie modeli ML na urządzeniach brzegowych:

• Konwertowanie modeli PyTorch na modele LiteRT.
• Kwantyzowanie wag modelu do INT4/INT8.
• Uruchamianie modeli na procesorze, GPU i NPU urządzenia mobilnego.
• Kompilowanie dla NPU.
• Testowanie na komputerze, urządzeniu mobilnym i w chmurze.
• Konwertowanie i uruchamianie modeli LLM.
• Używanie w kodowaniu agentowym.

🔗 Zasoby

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