LiteRT CLI 101: Edge-KI-Workflows optimieren

1. 🏁 Einführung und Übersicht über die Befehlszeile

Willkommen zum praktischen Codelab zur LiteRT-Befehlszeile 101. In dieser Anleitung erfahren Sie Schritt für Schritt, wie Sie eine Umgebung einrichten und optimierte Edge-Intelligence bereitstellen.

🌟 Hintergrund

Für Edge AI müssen komplexe neuronale Modelle direkt auf Smartphones, Wearables und eingebettete Hardware übertragen werden.

• LiteRT (früher TensorFlow Lite / TFLite): Das On-Device-Framework von Google für die Bereitstellung von leistungsstarkem ML und GenAI auf Edge-Plattformen durch effiziente Konvertierung, Laufzeit und Optimierung.
• Die LiteRT-Befehlszeile integriert Google AI Edge-Stacks in einen eigenständigen Shell-Befehl (litert), um LiteRT-bezogene Entwicklungs-Workflows zu optimieren. Dazu gehören das Konvertieren, Quantisieren, Kompilieren, Ausführen, Benchmarking und Visualisieren von LiteRT-Modellen (TFLite) auf verschiedenen Hardwareplattformen (CPU / GPU / NPU) für verschiedene Plattformen (Desktop, Mobilgerät oder Cloud).

2. 🔄 Einfache Workflows: Conversion, Quantisierung und Ausführung

In diesem Abschnitt führen wir einen vollständigen Edge AI-Modellierungslebenszyklus mit der LiteRT-Befehlszeile aus: PyTorch-Modell-Wrapper ➔ Tracing-Konvertierung ➔ Modellquantisierung ➔ Desktop-Inferenz ➔ Leistungsbenchmarks.

Wenn Sie interaktive Jupyter Notebook-Unterstützung für diesen Abschnitt wünschen, führen Sie ihn als Notebook aus.

📝 Phase 1: Wrapper-Skript für PyTorch-Modell vorbereiten

Erstellen Sie resnet18.py in Ihrem aktuellen Verzeichnis. Es stellt dynamische Tracing-Hooks bereit, damit der Graph Builder Formen erfassen kann:

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

🔄 Phase 2: PyTorch-Modell mit LiteRT Torch in LiteRT konvertieren

Rufen Sie den LiteRT-Torch-Konverter auf, um ein Standard-Float32-.tflite-Zielmodell zu erstellen:

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

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

📉 Phase 3: Gewichte auf INT8 quantisieren

Dynamische Rezeptkarten und Rezeptkarten mit Gewichtsangabe verwenden, um die Größe um das Vierfache zu reduzieren:

# 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

🚀 Phase 4: Inferenz lokal ausführen

Führen Sie Testvorgänge mit Dummy-Eingabeparametern aus, um Leistungsblöcke zu prüfen:

# 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

📊 Phase 5: Modellleistung vergleichen

Messen Sie hochpräzise Messwerte wie durchschnittliche Latenz, Initialisierungskosten, CPU-Ausführungsdurchsatz und dynamische aktive Speicherbelegungen:

# 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. 🔌 Einrichtung und Überprüfung der lokalen Umgebung

Wir erstellen eine isolierte, saubere Sandbox auf Ihrer Workstation (macOS oder Linux).

Wir empfehlen uv, einen auf Rust basierenden Python-Paketmanager der nächsten Generation, für ultraschnelle Abhängigkeitsdownloads und dynamische Einrichtung. Sie können auch das Standardtool pip in einer virtuellen Python-Umgebung verwenden.

🔌 Option A: Ultraschnelle Einrichtung (UV)

Mit uv werden Bibliotheken in Sekundenschnelle isoliert, wodurch Konflikte mit dem Umgebungscache vermieden werden.

# 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: Standardeinrichtung (pip)

Wenn uv nicht vorhanden ist, verwenden Sie die Standardkonfigurationen für virtuelle Python-Umgebungen:

# 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: Bearbeitbare lokale Einrichtung

Wenn Sie direkt im geklonten Quellverzeichnis des Repositorys entwickeln oder testen:

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

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

🔍 Einrichtung überprüfen

Prüfen Sie, ob der Pfad den Befehl litert korrekt weiterleitet:

litert --help

Blockierungen durch Unternehmensproxy / Anmeldedaten für privaten einfachen Index:Wenn Build-Installationen mit 401 Unauthorized aufgrund von Regeln für private benutzerdefinierte Indexe fehlschlagen, erzwingen Sie, dass die Suche direkt an den Standard-PyPI weitergeleitet wird:

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

💡 Zentraler Modellreferenzkatalog (model-ref)

Damit Skripts und die Entwicklung robust bleiben, wird in der LiteRT-CLI ein zentraler Modellkatalog implementiert:

• Format: Weisen Sie einem heruntergeladenen oder importierten Modell einen eindeutigen Namen (Alias) zu, z. B. mobilenet.
• Varianten: Verwenden Sie Doppelpunkte, um auf optimierte Varianten zu verweisen, z. B. mobilenet:int8 oder mobilenet:gpu.
• Einfachheit: Alle CLI-Befehle akzeptieren diesen pfadlosen -Alias direkt und lösen die physische Dateispeicherung automatisch auf.

4. 📲 Gerätebereitstellung und ‑profilierung

Wir können die Optimierung weiter vorantreiben, indem wir hochpräzise lokale Benchmarks ausführen, auf echten USB-Hardwarezielen bereitstellen, Hardware-Delegates implementieren, Ahead-of-Time-Kompilierung durchführen und Cloud-Benchmarks nutzen.

Für diesen Teil müssen Sie ein Android-Gerät mit aktiviertem ADB verbinden. So aktivieren Sie das USB-Debugging auf Ihrem Gerät:

• Gehen Sie zu den Einstellungen > Über das Telefon.
• Tippen Sie siebenmal auf Build-Nummer, bis „Du bist jetzt Entwickler!“ angezeigt wird.
• Gehen Sie zurück zu Einstellungen > System > Entwickleroptionen (oder auf einigen Geräten zu Einstellungen > Entwickleroptionen).
• Aktivieren Sie USB-Debugging.

📊 Lokale Profiling-Messwerte

Laden Sie EfficientNet-B1 herunter und erstellen Sie Leistungsprofilstatistiken auf Ihrem Desktop-Host:

# 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

Sehen Sie sich die Überschriften der wichtigsten Leistungsindikatoren im Benchmark-Log an:

• Model initialization: Zeit zum Booten von strukturellen Netzwerken.
• Warmup (avg): Zeitaufwand für die Kompilierung.
• Inference (avg): Die reine mathematische Verarbeitungszeit.
• Overall footprint: Spitzenwert des RAM, der während der Ausführung verbraucht wurde.

📲 Ziel A: Mobile CPU (USB-Verbindung)

Verbinden Sie ein Android-Gerät, auf dem das USB-Debugging aktiviert ist, und stellen Sie die App bereit:

# 1. Confirm device connection
adb devices

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

Die CLI überträgt das Modell automatisch auf das Zielgerät, führt die Inferenzschleife aus und leitet die Ausgaben zurück.

🎮 Ziel B: Mobile GPU

Schwere Arbeitslasten mit OpenCL oder WebGPU dynamisch auf die GPU auslagern:

# 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

⚙️ Ziel C: JIT Android NPU

Ausführungsparameter direkt an die NPU auf modernen Chipsets auslagern:

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

• Warnung: Das Erstellen dynamischer Grafiken in der On-Device-Laufzeitumgebung ist mit erheblichen JIT-Warm-up-Verzögerungen bei der Initialisierung verbunden.

🚀 Ziel D: AOT-kompilierte NPU

Offline vorkompilieren, um JIT-Overheads zur Laufzeit zu umgehen und eine maximale Beschleunigung zu erzielen:

# 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

☁️ Cloud-Profiling (Google AI Edge Portal)

Tests auf Remote-Hardwareprofile in den Geräteparks von Google Cloud übertragen

# 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. 🧠 Erweiterte Themen: LLMs und Spracherkennung

Wir sehen uns erweiterte Modelle an, indem wir Large Language Models (LLMs) und Modelle für die automatische Spracherkennung (Automatic Speech Recognition, ASR) konvertieren und ausführen.

💬 Generative KI (LLMs)

Edge-LLMs sind speicherbegrenzt. Wir beheben dieses Problem, indem wir die Weight-Only INT4/INT8-Quantisierung anwenden. Dabei werden die Gewichte komprimiert, während die Ausführungschannels in Float32 bleiben:

# 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

🎙️ Sprachverarbeitung (ASR)

ASR-Modelle wie Whisper oder Parakeet haben sowohl ein Encoder- als auch ein Decoder-Modul. Mit Signaturschlüsseln können wir Benchmarks für bestimmte Module erstellen:

# 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. 🤖 Im agentischen Programmieren verwenden

Die LiteRT CLI ist agentenfreundlich und kann direkt in Coding-Agents eingebunden werden.

Hier einige Beispiele: Fügen Sie Ihrem Coding-Agent (z. B. Google Antigravity) den LiteRT CLI-Skill SKILL.md hinzu und probieren Sie Prompts wie unten aus.

💡 Aufforderung zum Konvertieren, Quantisieren, Benchmarking und Erstellen von Berichten

„Lade das FP32-Modell litert-community/efficientnet_b1 herunter, quantisiere es mit dem dynamischen INT8-Bereich (–recipe dynamic_wi8_afp32) und führe dann Benchmarks für das ursprüngliche FP32-Modell und das neu quantisierte INT8-Modell auf der GPU meines verbundenen Android-Geräts aus. Vergleiche die durchschnittliche Latenz und gib die Durchsatzsteigerung an.“

💡 NPU-Kompilierung und Benchmark-Prompt

„Bestätige, ob ein Android-Gerät mit USB-Debugging verbunden ist. Wenn dies der Fall ist, lade litert-community/efficientnet_b1 herunter und kompiliere es offline (AOT) für die Qualcomm-sm8750-NPU. Schreibe das Zielmodell in ./models/compiled, übertrage das Modell auf das Smartphone, führe die Inferenz auf dem Gerät aus und prüfe, ob es keine JIT-Warmup-Latenzen gibt.“

7. 🚀 Herzlichen Glückwunsch und nächste Schritte

🎉 Hervorragend! Sie haben das Codelab „LiteRT CLI 101“ abgeschlossen.

Sie haben jetzt die erforderlichen Kenntnisse, um Edge ML-Anwendungen zu entwickeln:

• PyTorch-Modelle in LiteRT-Modelle konvertieren
• Modellgewichte auf INT4/INT8 quantisieren.
• Modelle auf mobilen CPUs, GPUs und NPUs ausführen.
• Für NPU kompilieren
• Benchmarks auf Computern, Mobilgeräten und in der Cloud
• LLM-Modelle konvertieren und ausführen
• Für agentisches Programmieren verwenden.

🔗 Ressourcen

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