LiteRT CLI 101 : simplifier vos workflows Edge AI

1. 🏁 Introduction et présentation de la CLI

Bienvenue dans l'atelier de programmation pratique sur la CLI LiteRT 101 ! Ce guide vous explique étape par étape comment passer d'une configuration d'environnement nulle au déploiement d'une intelligence de périphérie optimisée.

🌟 Contexte

L'IA de périphérie nécessite d'intégrer des modèles neuronaux complexes directement dans les téléphones mobiles, les objets connectés et le matériel embarqué.

• LiteRT (anciennement TensorFlow Lite / TFLite) est le framework sur appareil de Google pour le déploiement de ML et d'IA générative hautes performances sur les plates-formes de périphérie, via une conversion, une exécution et une optimisation efficaces.
• La CLI LiteRT intègre les piles Google AI Edge dans une commande shell autonome (litert) pour simplifier les workflows de développement liés à LiteRT, y compris la conversion, la quantification, la compilation, l'exécution, l'analyse comparative et la visualisation des modèles LiteRT (TFLite) sur différents matériels (processeur / GPU / NPU) sur différentes plates-formes (ordinateur, mobile ou cloud).

2. 🔄 Workflows de base : conversion, quantification et exécution

Dans cette section, nous allons exécuter un cycle de vie complet de modélisation de l'IA de périphérie avec la CLI LiteRT : wrapper de modèle PyTorch ➔ conversion de traçage ➔ quantification de modèle ➔ inférence sur ordinateur ➔ benchmarks de performances.

Pour une compatibilité interactive avec Jupyter Notebook dans cette section, essayez d'exécuter le code sous forme de notebook.

📝 Étape 1 : Préparer un script de wrapper de modèle PyTorch

Créez resnet18.py dans votre répertoire actuel. Il expose des hooks de traçage dynamique afin que le générateur de graphes puisse capturer des formes :

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

🔄 Étape 2 : Convertir un modèle PyTorch en LiteRT à l'aide de LiteRT Torch

Appelez le convertisseur LiteRT Torch pour créer un modèle cible Float32 .tflite standard :

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

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

📉 Étape 3 : Quantifier les pondérations en INT8

Appliquez des fiches de recette dynamiques et uniquement de pondération pour réduire la taille d'environ 4 fois :

# 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

🚀 Étape 4 : Exécuter l'inférence en local

Exécutez des opérations de test avec des paramètres d'entrée factices pour vérifier les blocs de performances :

# 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

📊 Étape 5 : Analyser les performances du modèle

Mesurez des métriques de haute précision, y compris la latence moyenne, les coûts d'initialisation, le débit d'exécution du processeur et les empreintes de mémoire active dynamique :

# 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. 🔌 Configuration et vérification de l'environnement local

Créons un bac à sable propre et isolé sur votre poste de travail (macOS ou Linux).

Nous vous recommandons d'utiliser uv (un gestionnaire de packages Python de nouvelle génération basé sur Rust) pour des téléchargements de dépendances ultra-rapides et une configuration dynamique. Vous pouvez également utiliser pip standard dans un environnement Python virtuel.

🔌 Option A : Configuration ultra-rapide (uv)

L'utilisation de uv isole les bibliothèques en quelques secondes, ce qui élimine les conflits de cache d'environnement.

# 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

🐍 Option B : Configuration standard (pip)

Si uv n'est pas présent, utilisez les configurations d'environnement Python virtuel standard :

# 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

🛠️ Option C : Configuration locale modifiable

Si vous développez ou testez directement dans le clone du répertoire source du dépôt :

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

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

🔍 Vérification de la configuration

Vérifiez que votre chemin d'accès achemine correctement la commande litert :

litert --help

Blocage des identifiants de proxy d'entreprise / d'index simple privé : si l'installation de la compilation échoue avec le message 401 Unauthorized en raison de règles d'index personnalisé privé, forcez la recherche à acheminer directement vers PyPI standard :

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

💡 Catalogue central de références de modèles (model-ref)

Pour que les scripts et le développement soient robustes, la CLI LiteRT implémente un catalogue de modèles centralisé :

• Format : attribuez un nom unique (alias) à un modèle téléchargé ou importé, tel que mobilenet.
• Variantes : utilisez des deux-points cibles pour faire référence à des variantes optimisées, telles que mobilenet:int8 ou mobilenet:gpu.
• Simplicité : toutes les commandes de la CLI acceptent directement cet alias sans chemin d'accès, ce qui résout automatiquement le stockage physique des fichiers à la volée.

4. 📲 Déploiement et profilage d'appareils

Allons plus loin dans l'optimisation en exécutant des benchmarks locaux de haute précision, en déployant sur des cibles matérielles USB réelles, en implémentant des délégués matériels, en compilant à l'avance et en effectuant des benchmarks dans le cloud.

Pour cette partie, vous devez connecter un appareil Android sur lequel ADB est activé. Pour activer le débogage USB sur votre appareil :

• Accédez à Paramètres > À propos du téléphone.
• Appuyez sept fois sur Numéro de version jusqu'à ce que le message "Vous êtes désormais un développeur !" s'affiche.
• Revenez à Paramètres > Système > Options pour les développeurs (ou Paramètres > Options pour les développeurs sur certains appareils).
• Activez le débogage USB.

📊 Métriques de profilage local

Téléchargez EfficientNet-B1 et profilez les statistiques de performances sur votre hôte de bureau :

# 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

Observez les en-têtes de performances clés dans le journal de benchmark :

• Model initialization : temps nécessaire au démarrage des réseaux structurels.
• Warmup (avg) : délais de surcharge de compilation.
• Inference (avg) : temps de traitement mathématique brut.
• Overall footprint : pic de RAM consommé lors de l'exécution.

📲 Cible A : Processeur mobile (connexion USB)

Connectez un appareil Android sur lequel le débogage USB est activé, puis déployez-le :

# 1. Confirm device connection
adb devices

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

La CLI transfère automatiquement le modèle vers l'appareil cible, exécute la boucle d'inférence et renvoie les sorties.

🎮 Cible B : GPU mobile

Déchargez dynamiquement les charges de travail lourdes sur le GPU à l'aide d'OpenCL ou de 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

⚙️ Cible C : NPU Android JIT

Déchargez les paramètres d'exécution directement sur le NPU des chipsets modernes :

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

• Avertissement : Les compilations de graphes dynamiques dans l'environnement d'exécution sur appareil souffrent de délais d'échauffement JIT importants lors de l'initialisation.

🚀 Cible D : NPU compilé AOT

Précompilez hors connexion pour contourner les surcharges JIT d'exécution et obtenir une accélération maximale :

# 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

☁️ Profilage dans le cloud (Google AI Edge Portal)

Transférez les tests vers des profils matériels à distance dans les fermes d'appareils de 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. 🧠 Sujets avancés : LLM et reconnaissance vocale

Explorons des modèles avancés en convertissant et en exécutant des grands modèles de langage (LLM) et des modèles de reconnaissance vocale automatique (ASR).

💬 IA générative (LLM)

Les LLM de périphérie sont limités par la mémoire. Nous résolvons ce problème en appliquant une quantification INT4/INT8 uniquement de pondération, en compressant les pondérations tout en conservant les canaux d'exécution dans 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

🎙️ Traitement de la parole (ASR)

Les modèles ASR tels que Whisper ou Parakeet comportent un module d'encodeur et un module de décodeur. Nous pouvons effectuer des benchmarks pour des modules spécifiques à l'aide de clés de signature :

# 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. 🤖 Utilisation dans le codage agentique

La CLI LiteRT est compatible avec les agents et vous pouvez l'intégrer directement aux agents de codage.

Voici quelques exemples : Ajoutez la compétence de la CLI LiteRT SKILL.md à votre agent de codage (comme Google Antigravity) et essayez des invites comme celles ci-dessous.

💡 Invite de conversion, de quantification, de benchmark et de rapport

"Téléchargez le modèle FP32 litert-community/efficientnet_b1 , quantifiez-le en plage dynamique INT8 (–recipe dynamic_wi8_afp32), puis comparez le modèle FP32 d'origine et le nouveau modèle INT8 quantifié sur le GPU de mon appareil Android connecté. Comparez la latence moyenne et indiquez l'accélération du débit. "

💡 Invite de compilation et de benchmark NPU

"Vérifiez si un appareil Android de débogage USB est connecté. Si c'est le cas, téléchargez litert-community/efficientnet_b1 et compilez-le hors connexion (AOT) pour le NPU sm8750 Qualcomm. Écrivez le modèle cible dans ./models/compiled, transférez-le sur le téléphone, exécutez l'inférence sur l'appareil et vérifiez que les latences d'échauffement JIT sont nulles."

7. 🚀 Félicitations et étapes suivantes

🎉 Remarquable ! Vous avez terminé l'atelier de programmation sur la CLI LiteRT 101 !

Vous possédez désormais les compétences nécessaires pour maîtriser le développement de ML de périphérie :

• Convertir des modèles PyTorch en modèles LiteRT
• Quantifier les pondérations de modèle en INT4/INT8
• Exécuter des modèles sur un processeur/GPU/NPU mobile
• Compiler pour NPU
• Effectuer des benchmarks sur ordinateur, mobile et cloud
• Convertir et exécuter des modèles LLM
• Utiliser dans le codage agentique

🔗 Ressources

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