Hardware para Edge AI Comparado: Jetson, Coral, Hailo, Raspberry Pi e ESP32-S3

Escolher hardware para edge AI é um equilíbrio entre tamanho do modelo, taxa de quadros, orçamento de energia, custo e quanto sofrimento com toolchains a sua equipe consegue absorver. Esta comparação cobre as principais opções, dos módulos NVIDIA Jetson e aceleradores Coral e Hailo até CPUs de Raspberry Pi puras e microcontroladores ESP32-S3, explica onde cada uma se encaixa e oferece um script de benchmark que publica a latência do seu próprio modelo via MQTT, para que você compare placas com números reais em vez de datasheets.

Como comparar hardware para edge AI

Os datasheets dos fabricantes costumam informar o pico de operações por segundo, mas números de pico raramente preveem o que o seu modelo vai fazer. Na prática, vários fatores pesam mais:

1. Suporte a operadores. Um acelerador só acelera os operadores suportados pelo seu compilador. Camadas não suportadas voltam para a CPU, às vezes anulando o ganho.
2. Precisão numérica. A maioria das NPUs e TPUs exige modelos quantizados em int8. GPUs também conseguem rodar FP16 e FP32.
3. Memória. Os pesos do modelo, as ativações e os buffers da câmera precisam caber. Em microcontroladores, esse é o primeiro limite que você atinge.
4. Energia e temperatura. Uma placa que sofre throttling em um gabinete fechado fica mais lenta do que no benchmark.
5. Toolchain e ciclo de vida. Como os modelos são convertidos, por quanto tempo o fabricante dá suporte às imagens de sistema operacional e às bibliotecas e se a placa estará disponível durante toda a vida do seu produto.
6. Conectividade. Todas as opções aqui podem publicar resultados em um broker MQTT; o que muda é se têm Wi-Fi integrado, Ethernet ou se precisam de um gateway.

Tabela comparativa de hardware para edge AI

As faixas de consumo são propositalmente amplas, porque o consumo real depende da carga de trabalho, dos clocks e dos periféricos. Meça a sua própria configuração.

Microcontroladores: ESP32-S3

O ESP32-S3 fica na base da faixa de consumo e custo e é a única opção aqui capaz de funcionar com uma pequena bateria por longos períodos. Suas instruções vetoriais aceleram os kernels de redes neurais nas bibliotecas da Espressif, e as variantes com PSRAM comportam pequenos modelos de visão. Ele é ideal quando a tarefa do modelo é transformar um fluxo de sensor em um evento ocasional. Os limites são rígidos: modelos na faixa de kilobytes a poucos megabytes e apenas imagens de baixa resolução. Veja TinyML no ESP32 para um projeto completo e o que é TinyML para as restrições.

Raspberry Pi com e sem aceleradores

Um Raspberry Pi 5 sozinho executa pequenos modelos de classificação e detecção na CPU, o que basta para protótipos, contagem de ocupação a alguns quadros por segundo ou classificação de áudio. Seu ponto forte é o ecossistema de software: Python, OpenCV, bibliotecas de câmera e clientes MQTT fáceis de usar.

Adicionar uma NPU Hailo por meio do Raspberry Pi AI Kit ou do AI HAT+ muda o cenário para visão. A detecção de objetos em tempo real se torna viável enquanto a CPU fica livre para a lógica da aplicação. Os modelos precisam ser compilados com a toolchain da Hailo, e a documentação oficial de IA do Raspberry Pi cobre a configuração e a integração com a câmera. O Raspberry Pi também oferece uma AI Camera que executa a inferência no próprio sensor de imagem, adequada a implantações com uma única câmera.

Coral Edge TPU

Os aceleradores Coral executam modelos TensorFlow Lite int8 compilados para o Edge TPU e são muito eficientes em consumo para modelos cujos operadores o compilador mapeia por completo. Eles existem como pendrives USB, placas M.2 e PCIe e uma dev board. Antes de se comprometer, verifique o estado atual do suporte de software do Coral para o seu sistema operacional e a sua versão de Python, já que historicamente ele evoluiu mais devagar do que o hardware ao qual se conecta. O guia do Coral Edge TPU detalha a configuração e a publicação via MQTT.

NVIDIA Jetson

Os módulos Jetson levam uma GPU CUDA completa para a borda. Eles lidam com múltiplos streams de câmera, detectores maiores, segmentação, estimativa de pose e, nos módulos mais avançados, pequenos modelos de linguagem e de visão e linguagem. O TensorRT otimiza os modelos para a GPU, e o DeepStream monta pipelines de vídeo com múltiplos streams. Os trade-offs são maior consumo, resfriamento ativo na maioria dos gabinetes e uma pilha de software mais pesada, atrelada às versões do JetPack. Leia o guia de Jetson Nano com MQTT para um exemplo prático.

Escolhendo hardware para edge AI: um checklist

1. Defina a tarefa e a taxa-alvo: qual modelo, qual tamanho de entrada, quantas inferências por segundo e quantas câmeras ou sensores.
2. Estabeleça o orçamento de energia e ambiente: bateria, PoE, gabinete sem ventoinha, faixa de temperatura.
3. Verifique a compatibilidade de operadores compilando o seu modelo real para cada candidato, e não um modelo de demonstração.
4. Faça o benchmark de ponta a ponta, incluindo o pré e o pós-processamento, que muitas vezes dominam em dispositivos pequenos.
5. Planeje as atualizações: como um novo modelo chegará ao dispositivo e por quanto tempo o sistema operacional e o SDK terão suporte?
6. Escolha a menor plataforma que atinja a meta com folga. Hardware menor é mais barato, esquenta menos e é mais simples de manter.

Faça o benchmark do seu modelo e publique os resultados via MQTT

A comparação mais justa é o seu próprio modelo em cada placa, com os resultados reunidos em um só lugar. Este script executa um modelo TensorFlow Lite repetidamente com entrada aleatória, mede a latência e publica um resumo na mesma árvore de topics a partir de todas as placas, para que um único assinante veja todos os resultados lado a lado. Os resultados vão para o servidor MQTT público (gratuito) em broker.connectmq.com, que serve para testes e protótipos; números de benchmark não são sensíveis, mas use um prefixo aleatório próprio. Ele usa o interpretador LiteRT se estiver instalado, recorre ao tflite_runtime ou ao TensorFlow caso contrário e pode carregar o delegate do Coral Edge TPU.

pip install "paho-mqtt>=2.0" numpy ai-edge-litert   # ou tflite-runtime / tensorflow

import argparse
import json
import platform
import statistics
import time
import uuid

import numpy as np
import paho.mqtt.client as mqtt

try:
    from ai_edge_litert.interpreter import Interpreter, load_delegate
except ImportError:
    try:
        from tflite_runtime.interpreter import Interpreter, load_delegate
    except ImportError:
        import tensorflow as tf
        Interpreter, load_delegate = tf.lite.Interpreter, tf.lite.experimental.load_delegate

ap = argparse.ArgumentParser()
ap.add_argument("model")
ap.add_argument("--board", required=True, help="label, e.g. rpi5-cpu or rpi5-coral")
ap.add_argument("--prefix", required=True, help="e.g. connectmq/demo/<random-id>/bench")
ap.add_argument("--edgetpu", action="store_true", help="load the Coral Edge TPU delegate")
ap.add_argument("--runs", type=int, default=100)
args = ap.parse_args()

delegates = [load_delegate("libedgetpu.so.1")] if args.edgetpu else None
interp = Interpreter(model_path=args.model, experimental_delegates=delegates)
interp.allocate_tensors()
inp = interp.get_input_details()[0]

if np.issubdtype(inp["dtype"], np.integer):
    info = np.iinfo(inp["dtype"])
    data = np.random.randint(info.min, info.max + 1, size=inp["shape"], dtype=inp["dtype"])
else:
    data = np.random.rand(*inp["shape"]).astype(inp["dtype"])

for _ in range(10):                                   # aquecimento
    interp.set_tensor(inp["index"], data)
    interp.invoke()

times = []
for _ in range(args.runs):
    t0 = time.perf_counter()
    interp.set_tensor(inp["index"], data)
    interp.invoke()
    times.append((time.perf_counter() - t0) * 1000)

times.sort()
result = {
    "board": args.board,
    "machine": platform.machine(),
    "model": args.model.rsplit("/", 1)[-1],
    "input": [int(d) for d in inp["shape"]],
    "runs": args.runs,
    "median_ms": round(statistics.median(times), 2),
    "p95_ms": round(times[int(0.95 * len(times)) - 1], 2),
    "fps_est": round(1000 / statistics.median(times), 1),
}
print(result)

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=f"bench-{args.board}-{uuid.uuid4().hex[:6]}")
client.connect("broker.connectmq.com", 1883, keepalive=30)
client.loop_start()
client.publish(f"{args.prefix}/{args.board}", json.dumps(result), qos=1, retain=True).wait_for_publish()
client.loop_stop()
client.disconnect()

Execute-o em cada placa com o mesmo prefixo e depois leia todos os resultados de uma vez. Como cada resultado é retido, as placas testadas ontem continuam aparecendo:

python bench.py detect_int8.tflite --board rpi5-cpu --prefix connectmq/demo/8d2f41/bench
python bench.py detect_int8_edgetpu.tflite --board rpi5-coral --edgetpu --prefix connectmq/demo/8d2f41/bench
mosquitto_sub -h broker.connectmq.com -p 1883 -i bench-viewer-3 -t 'connectmq/demo/8d2f41/bench/#' -v

Isso mede apenas o tempo de invoke do modelo. Adicione a captura da câmera e o pré-processamento à seção cronometrada para obter um número de ponta a ponta. No Jetson, exporte a mesma rede para TensorRT e cronometre-a com o loop equivalente; no ESP32-S3, registre esp_timer_get_time() em volta de Invoke(), como faz o tutorial de TinyML, e publique no mesmo formato JSON. Ao terminar, limpe cada resultado retido publicando uma mensagem retida vazia no respectivo topic.

Mesma saída, hardware diferente

Seja qual for a sua escolha, mantenha o contrato de saída idêntico entre as plataformas: a mesma hierarquia de topics, os mesmos campos JSON e um campo model e hardware em todas as mensagens. Assim você pode misturar placas em uma mesma implantação, como nós ESP32-S3 em motores e um Jetson na linha de câmeras, e todos os consumidores leem os resultados da mesma forma. Um broker MQTT na nuvem facilita isso entre plantas: com o ConnectMQ, cada placa se conecta de saída via TLS com suas próprias credenciais e client ID, e o explorador de topics do portal mostra todas as placas publicando na mesma árvore. Para contexto, veja o que é edge AI e o guia de IA e IoT.

Conecte qualquer placa de edge AI ao ConnectMQ

De um ESP32-S3 alimentado por bateria a um Jetson com várias câmeras, todas as placas falam MQTT. O ConnectMQ é um broker MQTT gerenciado com endpoints TCP, TLS e WebSocket, MQTT 5 e um explorador de topics em tempo real, para que os resultados de hardware misto cheguem a um só lugar. Crie um broker no plano Serverless (Free) em app.connectmq.com, sem cartão de crédito.

Perguntas frequentes

Qual é o melhor hardware de edge AI para iniciantes?

Um Raspberry Pi 5 é o começo mais fácil, porque roda as ferramentas Python padrão. Adicione um acelerador Hailo ou Coral quando precisar de visão em tempo real e experimente um ESP32-S3 quando quiser modelos de sensores de baixo consumo.

O Jetson é melhor do que o Coral ou o Hailo?

O Jetson é mais flexível e roda modelos maiores e mais tipos de operadores, mas consome mais energia. O Coral e o Hailo são eficientes para modelos int8 suportados. A escolha certa depende do seu modelo e do seu orçamento de energia.

Um ESP32-S3 consegue rodar detecção de objetos?

Ele consegue rodar modelos de detecção muito pequenos em imagens de baixa resolução, o que basta para presença ou contagem simples. Para detecção de uso geral com taxas de quadros úteis, use uma placa Linux com acelerador.

Por que fazer benchmark do meu próprio modelo em vez de usar números publicados?

Os números publicados usam modelos, tamanhos de entrada e configurações específicos. O suporte a operadores, a quantização e o pré-processamento são diferentes para o seu modelo, então só as suas próprias medições preveem o desempenho real.