TF Lite Delegate: o que é, delegados GPU e NNAPI

O que é TF Lite Delegate: arquitetura e princípio de funcionamento

TF Lite Delegate é um adaptador de software entre TensorFlow Lite Runtime e o acelerador de hardware do dispositivo. O delegado intercepta as operações do grafo do modelo (convoluções, pooling, multiplicações de matrizes) e as executa numa unidade de computação especializada em vez da CPU. Se o delegado não suportar uma operação específica, ela é executada na CPU — isto é chamado de delegação parcial.

Arquitetura TF Lite Delegate é construída em torno da interface SimpleDelegate API e da estrutura TfLiteDelegate em C++. Cada delegado implementa métodos de delegação de nós do grafo, alocação de memória e execução no dispositivo alvo. O desenvolvedor conecta o delegado através de Interpreter::ModifyGraphWithDelegate antes de chamar Invoke. De acordo com o Guia TensorFlow, o delegado é aplicado automaticamente a todas as operações suportadas do modelo.

Verificação de compatibilidade é um passo obrigatório. Nem todas as operações são suportadas por cada delegado. TensorFlow Lite fornece a ferramenta Delegation Compatibility Check: execute o modelo com o delegado e verifique quantas operações (ops) são delegadas. Se menos de 80% estiverem delegadas, considere escolher outro delegado ou ficar com a CPU. De acordo com TensorFlow (2025), GPU Delegate suporta 45 operações, NNAPI — 60+.

Nos projetos IT Sectr, usamos delegados GPU para iOS e XNNPACK para Android com verificação de compatibilidade integrada: o modelo é testado em todos os delegados, selecionando o mais rápido com pelo menos 90% de delegação completa.

// Conexão GPU Delegate no Android
val gpuDelegate = GpuDelegate()
val options = Interpreter.Options().apply {
    addDelegate(gpuDelegate)
    setNumThreads(4)
}
val interpreter = Interpreter(modelBuffer, options)
interpreter.run(input, output)
gpuDelegate.close()

Verificação de operações delegadas — controlo de compatibilidade via Interpreter. Por padrão, o delegado aceita todas as operações que suporta. Para depuração, use o registo da contagem de nós delegados. Se o modelo contiver operações personalizadas (custom ops), o delegado não as acelera mas também não as quebra — são executadas na CPU.

// Verificar contagem de operações delegadas
val delegateCount = interpreter.getDelegateOpsCount(gpuDelegate)
val totalNodes = interpreter.getNodesCount()
Log.d("TFLite", "Delegadas: $delegateCount / $totalNodes")
if (delegateCount < totalNodes * 0.8) {
    // Limiar de 80% — escolha outro delegado
}

GPU Delegate: aceleração no processador gráfico

GPU Delegate é um delegado TensorFlow Lite para executar modelos na GPU via OpenGL ES 3.1+ (Android) ou Metal (iOS). Os processadores gráficos são otimizados para operações matriciais paralelas — Core ML e redes neuronais convolucionais (CNN) obtêm o maior benefício. GPU Delegate reduz a latência de inferência em 4–8x para modelos como MobileNet, EfficientNet, Inception.

Limitações do GPU Delegate: não suporta todas as operações (apenas 45 de ~120 no TF Lite), requer OpenGL ES 3.1 ou Metal, consome mais energia que a CPU. GPU é ineficiente para batch size > 1 em cenários móveis. De acordo com benchmarks TensorFlow (2025), no Pixel 8 com GPU Adreno 740, MobileNetV2 executa em 4.2 ms na GPU contra 18.7 ms na CPU — uma aceleração de 4.4x.

Configuração GPU Delegate inclui seleção de precisão: float16 reduz a precisão mas acelera a inferência em 30–40% sem perda de qualidade notável (para a maioria das tarefas). Ative allow_precision_loss=true para máximo desempenho na GPU. Para tarefas de alta precisão (medicina, finanças), use float32.

// GPU Delegate com otimização de precisão
val gpuOptions = GpuDelegateFactory.Options().apply {
    isPrecisionLossAllowed = true
    inferencePreference = GpuDelegateFactory.Options.InferencePreference.SUSTAINED_SPEED
}
val delegate = GpuDelegateFactory.create(gpuOptions)

GPU Delegate no iOS utiliza Metal Performance Shaders via Metal Delegate. No iOS, o delegado funciona através do delegado Core ML para Apple Neural Engine ou Metal diretamente. Apple A17 Pro executa MobileNetV2 em 1.3 ms — 6x mais rápido que a CPU. Metal delegate está disponível desde iOS 12 e suporta todos os dispositivos com chip A7+.

NNAPI Delegate: redes neurais no Android via Neural Networks API

NNAPI Delegate (Android Neural Networks API) é um delegado TF Lite que utiliza aceleração de hardware através do Android NN HAL (Hardware Abstraction Layer). NNAPI redireciona as operações do modelo para NPU, DSP ou GPU dependendo dos drivers disponíveis do dispositivo. Suportado no Android 8.1+ (API 27+) e é o delegado recomendado por padrão para Android.

Vantagem do NNAPI — seleção automática do acelerador. Se o dispositivo tiver NPU (Qualcomm Hexagon, MediaTek APU, Samsung NPU), NNAPI delega as operações para ele. Se não houver NPU — para GPU via OpenCL. Se GPU também não for suportada — para CPU com otimizações DSP. O desenvolvedor não especifica um acelerador concreto — NNAPI seleciona o ótimo. De acordo com Google I/O 2024, o delegado NNAPI no Snapdragon 8 Gen 3 acelera modelos LLM em 12x.

Limitações do NNAPI: suporte desigual em diferentes dispositivos. Dispositivos antigos (Android 8.1) têm um conjunto limitado de drivers. Huawei com Kirin não suporta NNAPI através do Google Services — use GPU Delegate. Para compatibilidade garantida, Google recomenda NNAPI Delegate como primeira escolha, com fallback para GPU ou XNNPACK.

// NNAPI Delegate com fallback para CPU
val nnApiOptions = NnApiDelegate.Options().apply {
    acceleratorName = null // null = seleção automática
    allowFp16 = true
    executionPreference = NnApiDelegate.ExecutionPreference.SUSTAINED_SPEED
}
val delegate = NnApiDelegate(nnApiOptions)
val interpreter = Interpreter(model, Interpreter.Options().apply {
    addDelegate(delegate)
    setNumThreads(4)
})

Nome do Acelerador NNAPI — um parâmetro para seleção explícita do acelerador. Se for passado null, NNAPI seleciona automaticamente. Para teste, especifique um concreto: "qti", "google-edgetpu", "mediatek". A lista de aceleradores disponíveis é obtida via NnApiDelegate.getAvailableAccelerators(). Em produção, use autosseleção com um limiar de compatibilidade.

XNNPACK Delegate: otimização de CPU via SIMD

XNNPACK Delegate é um delegado TensorFlow Lite para execução otimizada na CPU através de instruções SIMD (ARM NEON, SSE, AVX). XNNPACK não requer GPU ou NPU — é um delegado de CPU puro, mas com aceleração de 2–4x graças a SIMD, fusão de operadores, pré-busca de memória e inferência quantizada (INT8). Ideal para dispositivos sem NPU dedicada ou quando é necessária compatibilidade garantida.

XNNPACK foi desenvolvido pela Google como delegado padrão do TF Lite para CPU (incluído no TFLite Runtime por padrão). Suporta 90+ operações — mais que GPU ou NNAPI. XNNPACK é especialmente eficaz para modelos quantizados (INT8, INT16): as operações executam 2–3x mais rápido que a versão float32. De acordo com benchmarks Google (2025), XNNPACK acelera INT8 MobileNetV2 em 2.8x em relação à CPU base.

XNNPACK vs GPU: em dispositivos sem NPU, XNNPACK é frequentemente mais rápido que GPU Delegate para lotes pequenos (1–4) — a GPU tem sobrecarga na transferência de dados entre CPU e GPU. XNNPACK opera no mesmo espaço de endereço da CPU — sem cópia de memória. Para modelos até 5MB, XNNPACK pode ser mais rápido que GPU. Para grandes modelos CNN, a GPU ganha devido ao paralelismo.

// XNNPACK Delegate ativado por padrão no TFLite 2.18+
// Uso explícito via XnnpackDelegate
val xnnpackOptions = XnnpackDelegate.Options().apply {
    numThreads = 4
    flags = XnnpackDelegate.Flags.USE_XNNPACK
}
val delegate = XnnpackDelegate(xnnpackOptions)
val interpreter = Interpreter(modelBuffer, Interpreter.Options().apply {
    addDelegate(delegate)
})

Flags do XNNPACK: USE_XNNPACK — ativa forçadamente o delegado, FLUSH_TO_ZERO — lida com números desnormalizados para aceleração, ENABLE_XNNPACK_SHAPES — tamanhos de entrada dinâmicos. Para máxima compatibilidade, use opções padrão. Se ocorrerem erros em dispositivos antigos, desative XNNPACK — o modelo ainda funciona na CPU mas mais lento.

Core ML e Metal Delegate: aceleração no iOS

Core ML Delegate é um delegado TensorFlow Lite para iOS que utiliza Apple Core ML Framework. Core ML converte o modelo TF Lite para formato .mlmodel e executa-o no Apple Neural Engine (ANE), GPU (Metal) ou CPU. Apple A17 Pro e M3 têm um Neural Engine dedicado que Core ML utiliza automaticamente. Core ML Delegate acelera a inferência em 5–10x em comparação com a CPU em dispositivos iOS modernos.

Core ML no iOS suporta flex delegate (delegação dinâmica de operações disponíveis para Core ML) e conversão completa do modelo (conversão de todo o modelo para .mlmodel). Apple recomenda flex delegate — é mais rápido porque funciona em tempo de execução sem conversão prévia. Core ML Delegate suporta modelos float32, float16 e quantizados (INT8).

Metal Delegate é um delegado de baixo nível que funciona diretamente com Metal Performance Shaders. Use Metal quando Core ML não suportar operações específicas. Metal Delegate fornece controlo máximo sobre a GPU mas requer mais código. De acordo com Apple (WWDC 2024), Metal Delegate para modelos Swift nativos pode ser 15–20% mais rápido que Core ML devido à ausência de sobrecarga de conversão.

// Core ML Delegate no iOS via TFLite Swift API
import TensorFlowLite

let coreMLDelegate = CoreMLDelegate()
var options = InterpreterOptions()
options.addDelegate(coreMLDelegate)

let interpreter = try Interpreter(modelPath: modelPath, options: options)
try interpreter.invoke(at: 0)

Escolha entre Core ML e Metal: Core ML para produção, Metal para casos extremos. Core ML gere automaticamente a memória NE, suporta fallback para CPU e não requer conversão manual. Metal fornece controlo sobre buffers e é adequado para operações personalizadas. Nos projetos IT Sectr, usamos Core ML Delegate para todos os modelos iOS e Metal apenas para tarefas de videoanálise em tempo real.

Como escolher um delegado para o seu projeto

Escolha de um TF Lite Delegate depende da plataforma alvo, modelo e requisitos de latência. Não existe um delegado universalmente melhor — cada um tem pontos fortes e fracos. A estratégia ótima: testar todos os delegados disponíveis no dispositivo alvo e escolher o minimamente rápido — não o mais rápido, mas o minimamente suficiente.

Recomendações por escolha: para Android com NPU (Snapdragon 8 Gen 2+, Dimensity 9000+) — NNAPI Delegate. Para Android sem NPU — XNNPACK Delegate (padrão). Para iOS — Core ML Delegate. Para projetos multiplataforma, use a estratégia: NNAPI no Android, Core ML no iOS, XNNPACK como fallback. GPU Delegate — quando NNAPI não estiver disponível e XNNPACK não for suficientemente rápido.

Testes de latência são um passo obrigatório na seleção. Meça a inferência à temperatura mínima (dispositivo frio) e após 5 minutos de operação contínua (thermal throttling). GPU e NNAPI podem reduzir o desempenho quando aquecidos. XNNPACK (CPU) é menos afetado. Use TensorFlow Lite Benchmark Tool para testes automáticos de todos os delegados no seu dispositivo.

// Estratégia de seleção de delegado
fun selectDelegate(): TfLiteDelegate {
    return when {
        NnApiDelegate.getAvailableAccelerators()?.isNotEmpty == true ->
            NnApiDelegate()
        GpuDelegateFactory.isGpuDelegateAvailable() ->
            GpuDelegate()
        else -> XnnpackDelegate()
    }
}

Estratégia de fallback — carregue o modelo sem exceções: se o delegado não for suportado, execute na CPU. TensorFlow Lite lança IllegalArgumentException ao ocorrer um erro de criação do delegado. Envolva a criação do delegado em try-catch e execute o modelo sem delegado em caso de erro. Uma IA lenta mas funcional é melhor do que um erro para o utilizador.