LiteRT CLI 101: Optimiza tus flujos de trabajo de IA en el borde

1. 🏁 Introducción y descripción general de la CLI

Te damos la bienvenida al codelab práctico de LiteRT CLI 101. Esta guía está diseñada para llevarte paso a paso desde la configuración del entorno hasta la implementación de inteligencia perimetral optimizada.

🌟 Antecedentes

La IA perimetral requiere incorporar modelos neuronales complejos directamente en teléfonos celulares, wearables y hardware integrado.

• LiteRT (antes TensorFlow Lite o TFLite) es el framework integrado en el dispositivo de Google para la implementación de AA y IA generativa de alto rendimiento en plataformas perimetrales, a través de una conversión, un tiempo de ejecución y una optimización eficientes.
• LiteRT CLI integra pilas de Google AI Edge en un comando de shell independiente (litert) para optimizar los flujos de trabajo de desarrollo relacionados con LiteRT, incluida la conversión, la cuantización, la compilación, la ejecución, la comparativa y la visualización de modelos de LiteRT (TFLite) en varios hardware (CPU, GPU o NPU) en diferentes plataformas (computadora, dispositivo móvil o nube).

2. 🔄 Flujos de trabajo básicos: conversión, cuantización y ejecución

En esta sección, ejecutaremos un ciclo de vida completo de modelado de IA perimetral con LiteRT CLI: wrapper de modelo de PyTorch ➔ conversión de seguimiento ➔ cuantización del modelo ➔ inferencia de escritorio ➔ comparativas de rendimiento.

Para obtener asistencia interactiva de Jupyter Notebook en esta sección, intenta ejecutarla como un notebook.

📝 Etapa 1: Prepara una secuencia de comandos de wrapper de modelo de PyTorch

Crea resnet18.py en tu directorio actual. Expone hooks de seguimiento dinámico para que el compilador de gráficos pueda capturar formas:

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

🔄 Etapa 2: Convierte un modelo de PyTorch a LiteRT con LiteRT Torch

Invoca el conversor de LiteRT Torch para compilar un modelo de destino .tflite Float32 estándar:

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

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

📉 Etapa 3: Cuantiza los pesos a INT8

Aplica tarjetas de recetas dinámicas y solo de peso para reducir los tamaños en aproximadamente 4 veces:

# 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

🚀 Etapa 4: Ejecuta la inferencia de forma local

Ejecuta operaciones de prueba con parámetros de entrada ficticios para verificar los bloques de rendimiento:

# 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

📊 Etapa 5: Compara el rendimiento del modelo

Mide métricas de alta precisión, como la latencia promedio, los costos de inicialización, la capacidad de procesamiento de la ejecución de la CPU y las huellas de memoria activa dinámica:

# 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. 🔌 Configuración y verificación del entorno local

Creemos un entorno aislado y limpio en tu estación de trabajo (macOS o Linux).

Recomendamos uv (un administrador de paquetes de Python de próxima generación basado en Rust) para descargas de dependencias ultrarrápidas y configuración dinámica, y también puedes usar pip estándar en un entorno virtual de Python.

🔌 Opción A: Configuración ultrarrápida (uv)

El uso de uv aísla las bibliotecas en segundos y borra los conflictos de caché del entorno.

# 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

🐍 Opción B: Configuración estándar (pip)

Si uv no está presente, usa las configuraciones estándar del entorno virtual de Python:

# 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

🛠️ Opción C: Configuración local editable

Si desarrollas o pruebas directamente dentro del clon del directorio del código fuente del repositorio:

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

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

🔍 Verificación de la configuración

Verifica que tu ruta dirija correctamente el comando litert:

litert --help

Bloqueadores de credenciales de proxy corporativo o índice simple privado: Si las instalaciones de compilación fallan con 401 Unauthorized debido a reglas de índice personalizadas privadas, fuerza la búsqueda para que se dirija directamente a PyPI estándar:

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

💡 El catálogo central de referencias de modelos (model-ref)

Para mantener la solidez de las secuencias de comandos y el desarrollo, la CLI de LiteRT implementa un catálogo de modelos centralizado:

• Formato: Asigna un nombre único (alias) a un modelo descargado o importado, como mobilenet.
• Variantes: Usa dos puntos de destino para hacer referencia a variaciones optimizadas, como mobilenet:int8 o mobilenet:gpu.
• Simplicidad: Todos los comandos de la CLI aceptan este alias sin ruta de acceso directamente, lo que resuelve automáticamente el almacenamiento de archivos físicos sobre la marcha.

4. 📲 Implementación y generación de perfiles de dispositivos

Llevemos la optimización más allá ejecutando comparativas locales de alta precisión, implementando en objetivos de hardware USB reales, implementando delegados de hardware, compilando Ahead-of-Time y realizando comparativas en la nube.

Para esta parte, debes conectar un dispositivo Android con ADB habilitado. Para habilitar la depuración por USB en tu dispositivo, sigue estos pasos:

• Ve a Configuración > Acerca del teléfono.
• Presiona Número de compilación 7 veces hasta que veas "Ya eres desarrollador".
• Vuelve a Configuración > Sistema > Opciones para desarrolladores (o Configuración > Opciones para desarrolladores en algunos dispositivos).
• Activa la depuración por USB.

📊 Métricas de generación de perfiles locales

Descarga EfficientNet-B1 y genera estadísticas de rendimiento en tu host de escritorio:

# 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

Observa los encabezados de rendimiento clave en el registro de comparativas:

• Model initialization: Tiempo para iniciar redes estructurales.
• Warmup (avg): Tiempos de sobrecarga de compilación.
• Inference (avg): El tiempo de procesamiento matemático sin procesar.
• Overall footprint: RAM máxima consumida durante la ejecución.

📲 Objetivo A: CPU para dispositivos móviles (conexión USB)

Conecta un dispositivo Android con la depuración por USB habilitada y realiza la implementación:

# 1. Confirm device connection
adb devices

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

La CLI envía automáticamente el modelo al dispositivo de destino, ejecuta el bucle de inferencia y canaliza las salidas.

🎮 Objetivo B: GPU para dispositivos móviles

Descarga cargas de trabajo pesadas de forma dinámica a la GPU con OpenCL o 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

⚙️ Objetivo C: NPU de Android JIT

Transfiere los parámetros de ejecución directamente a la NPU en los chipsets modernos:

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

• Advertencia: Las compilaciones de grafos dinámicos dentro del entorno de ejecución integrado en el dispositivo sufren retrasos significativos en el calentamiento de JIT de inicialización.

🚀 Objetivo D: NPU compilada con AOT

Realiza una compilación previa sin conexión para omitir las sobrecargas de JIT en el tiempo de ejecución y lograr la aceleración máxima:

# 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

☁️ Generación de perfiles en la nube (Portal de Google AI Edge)

Envía pruebas a perfiles de hardware remotos en las granjas de dispositivos 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. 🧠 Temas avanzados: LLMs y reconocimiento de voz

Exploremos modelos avanzados convirtiendo y ejecutando modelos de lenguaje grande (LLMs) y de reconocimiento de voz automático (ASR).

💬 IA generativa (LLMs)

Los LLMs perimetrales están limitados por la memoria. Para resolver este problema, aplicamos la cuantización INT4/INT8 solo de peso , que comprime los pesos mientras mantiene los canales de ejecución en 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

🎙️ Procesamiento de voz (ASR)

Los modelos de ASR, como Whisper o Parakeet, tienen un módulo de codificador y un módulo de decodificador. Podemos realizar comparativas para módulos específicos con claves de firma:

# 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. 🤖 Uso en la programación con agentes

La CLI de LiteRT es compatible con agentes y puedes integrarla directamente con agentes de programación.

Aquí tienes algunos ejemplos. Agrega la habilidad de la CLI de LiteRT SKILL.md a tu agente de programación (como Google Antigravity) y prueba mensajes como los que se muestran a continuación.

💡 Mensaje de conversión, cuantización, comparativa y generación de informes

"Descarga el modelo FP32 litert-community/efficientnet_b1 , cuantízalo al rango dinámico INT8 (–recipe dynamic_wi8_afp32) y, luego, compara el modelo FP32 original y el modelo INT8 recién cuantizado en la GPU de mi dispositivo Android conectado. Compara la latencia promedio y genera un informe sobre la aceleración de la capacidad de procesamiento."

💡 Mensaje de compilación y comparativa de NPU

"Confirma si tengo conectado un dispositivo Android con depuración por USB. Si está activo, descarga litert-community/efficientnet_b1 y realiza una compilación sin conexión (AOT) para la NPU sm8750 de Qualcomm. Escribe el modelo de destino en ./models/compiled, envía el modelo al teléfono, ejecuta la inferencia integrado en el dispositivo y verifica que no haya latencias de calentamiento de JIT."

7. 🚀 Felicitaciones y próximos pasos

🎉 ¡Sobresaliente! Completaste el codelab de LiteRT CLI 101.

Ahora tienes las habilidades para dominar el desarrollo de AA perimetral:

• Convierte modelos de PyTorch a modelos de LiteRT.
• Cuantiza los pesos del modelo a INT4/INT8.
• Ejecuta modelos en CPU, GPU o NPU para dispositivos móviles.
• Realiza compilaciones para NPU.
• Realiza comparativas en computadoras, dispositivos móviles y la nube.
• Convierte y ejecuta modelos de LLM.
• Usa la programación con agentes.

🔗 Recursos

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