CLI do LiteRT 101: otimize seus fluxos de trabalho de IA de borda

1. 🏁 Introdução e visão geral da CLI

Este é o codelab prático da CLI LiteRT 101. Este guia foi criado para mostrar as etapas, desde a configuração do ambiente até a implantação da inteligência de borda otimizada.

🌟 Contexto

A IA de ponta exige a incorporação de modelos neurais complexos diretamente em smartphones, wearables e hardware incorporado.

• LiteRT (antigo TensorFlow Lite / TFLite): framework no dispositivo do Google para implantação de ML e IA generativa de alta performance em plataformas de borda, usando conversão, tempo de execução e otimização eficientes.
• A CLI LiteRT integra as stacks do Google AI Edge a um comando de shell independente (litert) para simplificar os fluxos de trabalho de desenvolvimento relacionados ao LiteRT, incluindo conversão, quantização, compilação, execução, comparativo de mercado e visualização de modelos LiteRT (TFLite) em vários hardwares (CPU / GPU / NPU) em plataformas (computador, dispositivo móvel ou nuvem).

2. 🔄 Fluxos de trabalho básicos: conversão, quantização e execução

Nesta seção, vamos executar um ciclo de vida completo de modelagem de IA de borda com a CLI do LiteRT: wrapper de modelo do PyTorch ➔ conversão de rastreamento ➔ quantização de modelo ➔ inferência de desktop ➔ comparativos de performance.

Para suporte interativo do Jupyter Notebook nesta seção, tente executar como um notebook.

📝 Etapa 1: preparar um script de wrapper de modelo do PyTorch

Crie resnet18.py no diretório atual. Ele expõe hooks de rastreamento dinâmico para que o criador de gráficos possa 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: converter um modelo PyTorch em LiteRT usando o LiteRT Torch

Invoque o conversor do LiteRT Torch para criar um modelo de destino Float32 .tflite padrão:

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

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

📉 Estágio 3: quantizar pesos para INT8

Aplique cards de receitas dinâmicos e somente com peso para reduzir os tamanhos em cerca de 4 vezes:

# 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: executar a inferência localmente

Execute operações de teste com parâmetros de entrada fictícios para verificar bloqueios de performance:

# 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: comparar o desempenho do modelo

Meça métricas de alta precisão, incluindo latência média, custos de inicialização, capacidade de processamento de execução da CPU e pegadas de memória ativa 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. 🔌 Configuração e verificação do ambiente local

Vamos criar um sandbox isolado e limpo na sua estação de trabalho (macOS ou Linux)

Recomendamos o uv (um gerenciador de pacotes Python de última geração baseado em Rust) para downloads de dependências ultrarrápidos e configuração dinâmica. Você também pode usar o pip padrão em um ambiente virtual Python.

🔌 Opção A: configuração ultrarrápida (uv)

Usar uv isola bibliotecas em segundos, eliminando conflitos de cache de ambiente.

# 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

🐍 Opção B: configuração padrão (pip)

Se uv não estiver presente, use as configurações padrão do ambiente virtual do 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

🛠️ Opção C: configuração local editável

Se você estiver desenvolvendo ou testando diretamente no clone do diretório de origem do repositório:

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

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

🔍 Verificação de configuração

Verifique se o caminho roteia corretamente o comando litert:

litert --help

Bloqueadores de credenciais de proxy corporativo / índice simples particular:se as instalações de build falharem com 401 Unauthorized devido a regras de índice personalizadas particulares, force a pesquisa a encaminhar diretamente para o PyPI padrão:

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

💡 O catálogo central de referências de modelo (model-ref)

Para manter scripts e desenvolvimento robustos, a CLI LiteRT implementa um Catálogo de modelos centralizado:

• Formato: atribua um nome exclusivo (alias) a um modelo baixado ou importado, como mobilenet.
• Variantes: use dois-pontos de destino para se referir a variações otimizadas, como mobilenet:int8 ou mobilenet:gpu.
• Simplicidade: todos os comandos da CLI aceitam esse alias sem caminho diretamente, resolvendo automaticamente o armazenamento físico de arquivos na hora.

4. 📲 Implantação e criação de perfis de dispositivos

Vamos otimizar ainda mais executando comparativos de mercado locais de alta precisão, fazendo a implantação em destinos de hardware USB reais, implementando delegados de hardware, compilando Ahead-of-Time e fazendo comparativos de mercado na nuvem.

Para esta parte, você precisa conectar um dispositivo Android com o ADB ativado. Para ativar a depuração USB no dispositivo:

• Acesse Configurações > Sobre o dispositivo.
• Toque em Número da versão sete vezes até aparecer a mensagem "Você agora é um desenvolvedor!".
• Volte para Configurações > Sistema > Opções do desenvolvedor (ou Configurações > Opções do desenvolvedor em alguns dispositivos).
• Ative a depuração USB.

📊 Métricas de criação de perfil local

Faça o download do EfficientNet-B1 e crie um perfil das estatísticas de desempenho no host da área de trabalho:

# 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

Observe os cabeçalhos de performance principais no registro de comparativo de mercado:

• Model initialization: tempo para inicializar redes estruturais.
• Warmup (avg): tempos de sobrecarga de compilação.
• Inference (avg): o tempo bruto de processamento matemático.
• Overall footprint: pico de RAM consumida durante a execução.

📲 Meta A: CPU móvel (conexão USB)

Conecte um dispositivo Android com a depuração USB ativada e implante:

# 1. Confirm device connection
adb devices

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

A CLI envia automaticamente o modelo para o dispositivo de destino, executa o loop de inferência e transmite as saídas de volta.

🎮 Destino B: GPU móvel

Faça o offload dinâmico de cargas de trabalho pesadas para a GPU usando OpenCL ou 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

⚙️ Destino C: JIT Android NPU

Descarregar parâmetros de execução diretamente para a NPU em chipsets modernos:

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

• Aviso: a criação de grafos dinâmicos no ambiente de execução no dispositivo sofre atrasos significativos no pré-aquecimento da inicialização JIT.

🚀 Destino D: NPU compilada com AOT

Pré-compile off-line para evitar sobrecargas de JIT no tempo de execução e alcançar aceleração 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

☁️ Criação de perfil na nuvem (portal do Google AI Edge)

Envie testes para perfis de hardware remotos nos farms de dispositivos do 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. 🧠 Tópicos avançados: LLMs e reconhecimento de fala

Vamos conhecer modelos avançados convertendo e executando modelos de linguagem grandes (LLMs) e de reconhecimento automático de fala (ASR).

💬 IA generativa (LLMs)

Os LLMs de borda têm limite de memória. Para resolver isso, aplicamos a quantização Weight-Only INT4/INT8, comprimindo os pesos e mantendo os canais de execução em 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

🎙️ Processamento de fala (ASR)

Modelos de ASR, como Whisper ou Parakeet, têm um módulo de codificador e um de decodificador. Podemos fazer comparativos de módulos específicos usando chaves de assinatura:

# 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 na programação agêntica

A CLI LiteRT é compatível com agentes e pode ser integrada diretamente a agentes de programação.

Confira alguns exemplos. Adicione a habilidade da CLI LiteRT SKILL.md ao seu agente de programação (como o Google Antigravity) e tente comandos como os abaixo.

💡 Converter, quantizar, comparar e gerar relatórios de comandos

Baixe o modelo FP32 litert-community/efficientnet_b1, quantize-o para o intervalo dinâmico INT8 (–recipe dynamic_wi8_afp32) e faça um comparativo de desempenho do modelo FP32 original e do modelo INT8 recém-quantizado na GPU do meu dispositivo Android conectado. Compare a latência média e informe o aumento da taxa de transferência.

💡 Comando de compilação e comparativo de mercado da NPU

"Confirme se tenho um dispositivo Android conectado com depuração USB. Se estiver ativo, faça o download de litert-community/efficientnet_b1 e compile off-line (AOT) para a NPU Qualcomm sm8750. Grave o modelo de destino em ./models/compiled, envie o modelo para o smartphone, execute a inferência no dispositivo e verifique se não há latências de pré-aquecimento JIT."

7. 🚀 Parabéns e próximas etapas

🎉 Excelente! Você concluiu o codelab da CLI LiteRT 101.

Agora você tem as habilidades para dominar o desenvolvimento de ML de ponta:

• Converter modelos do PyTorch para modelos do LiteRT.
• Quantizar pesos do modelo para INT4/INT8.
• Executar modelos em CPU/GPU/NPU móvel.
• Compile para NPU.
• Comparativo de mercado em computadores, dispositivos móveis e nuvem.
• Converter e executar modelos de LLM.
• Uso na programação com agentes.

🔗 Recursos

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