Phase 17 - Lesson 12

Edge Inference — Apple Neural Engine, Qualcomm Hexagon, WebGPU/WebLLM, Jetson

A principal restrição no edge é a largura de banda de memória, não a computação. A DRAM móvel opera a 50-90 GB/s; a HBM3 de data centers ultrapassa 2-3 TB/s — uma lacuna de 30-50x. O decode é limitado pela memória (memory-bound), de modo que essa diferença é decisiva. Em 2026, o cenário se divide em quatro caminhos. O Apple M4/A18 Neural Engine atinge o pico de 38 TOPS com memória unificada (sem cópia CPU↔NPU). O Qualcomm Snapdragon X Elite / 8 Gen 4 Hexagon alcança 45 TOPS. O WebGPU + WebLLM executa o Llama 3.1 8B (Q4) a ~41 tok/s no M3 Max (cerca de 70-80% do nativo); 17.6k estrelas no GitHub, API compatível com OpenAI, ~70-75% de cobertura móvel. O NVIDIA Jetson Orin Nano Super (8GB) suporta Llama 3.2 3B / Phi-3; o AGX Orin executa o gpt-oss-20b via vLLM a ~40 tok/s; o Jetson T4000 (JetPack 7.1) tem o dobro do desempenho do AGX Orin. O TensorRT Edge-LLM suporta EAGLE-3, NVFP4, chunked prefill — apresentado na CES 2026 pela Bosch, ThunderSoft e MediaTek.

Type: Learn Languages: Python (stdlib, toy bandwidth-bound decode simulator) Prerequisites: Phase 17 · 04 (vLLM Serving Internals), Phase 17 · 09 (Production Quantization) Time: ~60 minutos

Learning Objectives

• Explicar por que a inferência de LLMs em dispositivos móveis é limitada pela largura de banda da memória e a computação é secundária.
• Enumerar os quatro alvos de edge (Apple ANE, Qualcomm Hexagon, WebGPU/WebLLM, NVIDIA Jetson) e associar cada um a um caso de uso.
• Identificar a lacuna de cobertura do WebGPU em 2026 (Firefox Android se atualizando) e o lançamento do Safari iOS 26.
• Escolher um formato de quantização por alvo (Core ML INT4 + FP16 para ANE, QNN INT8/INT4 para Hexagon, WebGPU Q4 para navegador, NVFP4 para Jetson Thor).

O Problema

Um cliente deseja um chatbot no dispositivo: focado em voz, privado por padrão, que funcione offline. Em um MacBook Pro M3 Max, o Llama 3.1 8B Q4 roda a ~55 tok/s — aceitável. Em um iPhone 16 Pro, o mesmo modelo roda a 3 tok/s — inaceitável. Em um Android intermediário com Snapdragon 8 Gen 3, roda a 7 tok/s. No navegador via WebGPU no Chrome Android v121+, roda a 4-8 tok/s dependendo do dispositivo.

A variação de vazão (throughput) não é um problema de portabilidade. É o produto da lacuna de largura de banda pelo formato de quantização e pela possibilidade de acessar a NPU a partir do espaço do usuário. A inferência no edge em 2026 se resume a quatro problemas diferentes com quatro soluções diferentes.

O Conceito

A largura de banda é o verdadeiro teto

O decode lê o conjunto completo de pesos para cada token. Um modelo de 7B em Q4 tem 3.5 GB. Ler 3.5 GB a 50 GB/s leva 70 ms — um teto teórico de ~14 tok/s. A 90 GB/s (DRAM móvel de ponta), o teto sobe para ~25 tok/s. Nenhuma quantidade de computação ajuda abaixo desse número.

A memória HBM3 de data center a 3 TB/s carrega os mesmos 3.5 GB em 1.2 ms — o teto é de 830 tok/s. Mesmo modelo, mesmos pesos. Subsistema de memória diferente.

Apple Neural Engine (M4 / A18)

• Até 38 TOPS. Memória unificada (CPU e ANE compartilham o mesmo pool) — sem sobrecarga de cópia.
• Acesso via Core ML + modelos compilados .mlmodel, ou via Metal Performance Shaders (MPS) através do PyTorch.
• O backend Metal do Llama.cpp usa MPS, não a ANE diretamente; a ANE nativa exige a conversão para Core ML.
• Melhor caminho prático para aplicativos iOS em 2026: Core ML com pesos INT4 + ativações FP16.

Qualcomm Hexagon (Snapdragon X Elite / 8 Gen 4)

• Até 45 TOPS. Integrado com a CPU e GPU no SoC, mas com domínio de memória separado.
• O SDK do QNN (Qualcomm Neural Network) e o AI Hub fornecem conversão a partir de PyTorch/ONNX.
• Templates de chat, Llama 3.2, Phi-3 são todos distribuídos como artefatos de primeira classe no AI Hub.

Intel / AMD NPUs (Lunar Lake, Ryzen AI 300)

• 40-50 TOPS. O ecossistema de software está atrás da Apple/Qualcomm; o OpenVINO está melhorando, mas ainda é de nicho.
• Ideal para aplicativos copilot de Windows ARM; nativo em desktops AMD/Intel para cenários local-first.

WebGPU + WebLLM

• Executa modelos no navegador via compute shaders do WebGPU; sem necessidade de instalação.
• Llama 3.1 8B Q4 a ~41 tok/s no M3 Max — cerca de 70-80% do nativo usando o mesmo backend.
• 17.6k estrelas no GitHub para o WebLLM; API JS compatível com OpenAI; licença Apache 2.0.
• Cobertura em 2026: Chrome Android v121+, Safari iOS 26 GA, Firefox Android ainda se atualizando. Cobertura móvel geral de ~70-75%.

Família NVIDIA Jetson

• Orin Nano Super (8GB): suporta Llama 3.2 3B, Phi-3 com boa taxa de tok/s.
• AGX Orin: executa o gpt-oss-20b via vLLM a ~40 tok/s.
• Thor / T4000 (JetPack 7.1): 2x o desempenho do AGX Orin, com suporte a EAGLE-3 e NVFP4.
• O TensorRT Edge-LLM (2026) suporta decodificação especulativa EAGLE-3, pesos NVFP4, chunked prefill — as otimizações de data center portadas para o edge.

Escolha de quantização por alvo

A armadilha do contexto longo no edge

O contexto de 128K do Llama 3.1 é um recurso de data center. Em um telefone com 8 GB de RAM, modelo de 4 GB + 2 GB de KV cache para 32K tokens + sobrecarga do sistema operacional = OOM (Out Of Memory). Implantações em edge mantêm o contexto em 4K-8K, a menos que uma quantização agressiva de KV (Q4 KV) seja aceita.

Voz é a aplicação matadora

Agentes de voz são sensíveis à latência (primeiro token < 500 ms). A inferência local elimina completamente a latência de rede. Combinando com conversão de fala em texto (variantes do Whisper Turbo rodam no edge), a inferência no edge se torna o loop de voz ideal para produção.

Números que você deve lembrar

• Apple M4 / A18 ANE: 38 TOPS.
• Qualcomm Hexagon SD X Elite: 45 TOPS.
• WebLLM M3 Max: ~41 tok/s no Llama 3.1 8B Q4.
• AGX Orin: ~40 tok/s no gpt-oss-20b via vLLM.
• Diferença de largura de banda data center-edge: 30-50x.
• Cobertura móvel do WebGPU: ~70-75% (Firefox Android atrasado).

Use na Prática

code/main.py calcula tetos teóricos de vazão de decodificação com base em cálculos de largura de banda de memória em vários alvos de edge. Compara com benchmarks observados e destaca onde a largura de banda, e não o processamento, é o gargalo.

Envie para Produção

Esta lição produz outputs/skill-edge-target-picker.md. Dada a plataforma (iOS/Android/navegador/Jetson), o modelo e o orçamento de latência/memória, escolhe um formato de quantização e um pipeline de conversão.

Exercícios

1. Execute code/main.py. Para um modelo 7B em Q4 em um Snapdragon 8 Gen 3 (~77 GB/s de largura de banda), calcule o teto de decodificação. Compare com os 6-8 tok/s observados — o runtime é eficiente?
2. O WebGPU no Android exige Chrome v121+. Projete um fallback para navegadores mais antigos — no lado do servidor via a mesma API compatível com OpenAI.
3. Seu aplicativo iOS precisa de streaming com contexto de 4K. Qual combinação de modelo/formato permite que você permaneça abaixo de 4 GB de memória ativa em um iPhone 16?
4. O Jetson AGX Orin executa o gpt-oss-20b a 40 tok/s. O Jetson Nano suporta apenas um modelo de 3B. Se o seu produto tem ambos como alvo, como você unifica a stack de inferência?
5. Argumente se o "WebLLM está pronto para produção em 2026". Cite a cobertura, o desempenho e a lacuna do Firefox Android.

Termos-Chave

Leitura Adicional

• On-Device LLMs State of the Union 2026 — cenário e benchmarks.
• NVIDIA Jetson Edge AI — Orin / AGX / Thor.
• NVIDIA TensorRT Edge-LLM — anúncio da versão edge de 2026.
• WebLLM (arXiv:2412.15803) — arquitetura e benchmarks.
• Apple Core ML — conversão nativa para ANE.
• Qualcomm AI Hub — modelos pré-convertidos para Hexagon.