Hardware para edge AI comparado: Jetson, Coral, Hailo, Raspberry Pi y ESP32-S3

Elegir hardware para edge AI es un equilibrio entre el tamaño del modelo, la tasa de fotogramas, el presupuesto energético, el coste y la complejidad de herramientas que tu equipo puede asumir. Esta comparativa repasa las opciones principales, desde los módulos NVIDIA Jetson y los aceleradores Coral y Hailo hasta las CPU de una Raspberry Pi sin más y los microcontroladores ESP32-S3, explica dónde encaja cada una y te da un script de benchmark que publica por MQTT la latencia de tu propio modelo para que compares placas con cifras reales y no con hojas de datos.

Cómo comparar hardware para edge AI

Las hojas de datos de los fabricantes suelen citar operaciones por segundo máximas, pero esas cifras pico rara vez predicen lo que hará tu modelo. En la práctica importan más varios factores:

1. Compatibilidad de operadores. Un acelerador solo acelera los operadores que admite su compilador. Las capas no compatibles se ejecutan en la CPU, lo que a veces anula la ganancia.
2. Precisión. La mayoría de las NPU y TPU necesitan modelos cuantizados a int8. Las GPU también pueden ejecutar FP16 y FP32.
3. Memoria. Los pesos del modelo, las activaciones y los búferes de la cámara tienen que caber. En los microcontroladores es el primer límite con el que te topas.
4. Consumo y temperatura. Una placa que reduce su frecuencia por calor dentro de una carcasa cerrada es más lenta que en su benchmark.
5. Herramientas y ciclo de vida. Cómo se convierten los modelos, cuánto tiempo mantiene el fabricante las imágenes del sistema operativo y las librerías, y si la placa estará disponible durante toda la vida de tu producto.
6. Conectividad. Todas las opciones de esta lista pueden publicar resultados en un broker MQTT; la diferencia está en si tienen Wi-Fi integrado, Ethernet o necesitan un gateway.

Tabla comparativa de hardware para edge AI

Las clases de consumo son deliberadamente amplias, porque el consumo real depende de la carga de trabajo, las frecuencias y los periféricos. Mide tu propia configuración.

Microcontroladores: ESP32-S3

El ESP32-S3 se sitúa en el extremo más bajo de consumo y coste y es la única opción de esta lista que puede funcionar con una batería pequeña durante largos periodos. Sus instrucciones vectoriales aceleran los kernels de redes neuronales en las librerías de Espressif, y las variantes con PSRAM pueden albergar pequeños modelos de visión. Es ideal cuando la tarea del modelo es convertir un flujo de sensor en un evento ocasional. Los límites son firmes: modelos de kilobytes a pocos megabytes e imágenes de baja resolución únicamente. Consulta TinyML en ESP32 para un montaje completo y qué es TinyML para conocer las limitaciones.

Raspberry Pi con y sin aceleradores

Una Raspberry Pi 5 por sí sola ejecuta pequeños modelos de clasificación y detección en la CPU, lo que basta para prototipos, para contar ocupación a unos pocos fotogramas por segundo o para clasificar audio. Su punto fuerte es el ecosistema de software: Python, OpenCV, librerías de cámara y clientes MQTT sencillos.

Añadir una NPU Hailo mediante el Raspberry Pi AI Kit o el AI HAT+ cambia el panorama para la visión. La detección de objetos en tiempo real se vuelve viable mientras la CPU queda libre para la lógica de la aplicación. Los modelos deben compilarse con las herramientas de Hailo, y la documentación oficial de IA de Raspberry Pi explica la configuración y la integración con la cámara. Raspberry Pi también ofrece una AI Camera que ejecuta la inferencia en el propio sensor de imagen, adecuada para despliegues con una sola cámara.

Coral Edge TPU

Los aceleradores Coral ejecutan modelos TensorFlow Lite int8 compilados para el Edge TPU y son muy eficientes energéticamente con modelos cuyos operadores el compilador mapea por completo. Se presentan como memorias USB, tarjetas M.2 y PCIe y una placa de desarrollo. Antes de comprometerte, comprueba el estado actual del soporte de software de Coral para tu sistema operativo y tu versión de Python, ya que históricamente ha avanzado más despacio que el hardware al que se conecta. La guía de Coral Edge TPU explica en detalle la configuración y la publicación por MQTT.

NVIDIA Jetson

Los módulos Jetson llevan una GPU CUDA completa al edge. Gestionan varios flujos de cámara, detectores más grandes, segmentación, estimación de pose y, en los módulos de gama alta, pequeños modelos de lenguaje y modelos de visión y lenguaje. TensorRT optimiza los modelos para la GPU y DeepStream construye pipelines de vídeo multiflujo. Las contrapartidas son un mayor consumo, refrigeración activa en la mayoría de las carcasas y una pila de software más pesada ligada a las versiones de JetPack. Lee la guía de Jetson Nano con MQTT para ver un ejemplo práctico.

Elegir hardware para edge AI: lista de comprobación

1. Define la tarea y la tasa objetivo: qué modelo, qué tamaño de entrada, cuántas inferencias por segundo y cuántas cámaras o sensores.
2. Fija el presupuesto de energía y de entorno: batería, PoE, carcasa sin ventilador, rango de temperatura.
3. Comprueba la compatibilidad de operadores compilando tu modelo real para cada candidato, no un modelo de demostración.
4. Haz un benchmark de extremo a extremo, incluidos el preprocesamiento y el posprocesamiento, que a menudo dominan en dispositivos pequeños.
5. Planifica las actualizaciones: cómo llegará un nuevo modelo al dispositivo y durante cuánto tiempo se mantendrán el sistema operativo y el SDK.
6. Elige la plataforma más pequeña que cumpla el objetivo con margen. El hardware más pequeño es más barato, se calienta menos y es más sencillo de mantener.

Haz un benchmark de tu modelo y publica los resultados por MQTT

La comparación más justa es tu propio modelo en cada placa, con los resultados reunidos en un solo lugar. Este script ejecuta repetidamente un modelo TensorFlow Lite con una entrada aleatoria, mide la latencia y publica un resumen en el mismo árbol de topics desde todas las placas, de modo que un único suscriptor ve todos los resultados uno junto a otro. Usa el intérprete de LiteRT si está instalado, recurre a tflite_runtime o TensorFlow en caso contrario y puede cargar el delegate del Coral Edge TPU.

pip install "paho-mqtt>=2.0" numpy ai-edge-litert   # o 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):                                   # calentamiento
    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()

Ejecútalo en cada placa con el mismo prefijo y después lee todos los resultados a la vez. Como cada resultado es retenido, las placas que probaste ayer siguen apareciendo:

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

Esto mide solo el tiempo de invocación del modelo. Añade la captura de la cámara y el preprocesamiento a la sección cronometrada para obtener una cifra de extremo a extremo. Para Jetson, exporta la misma red a TensorRT y cronométrala con un bucle equivalente; para el ESP32-S3, registra esp_timer_get_time() alrededor de Invoke() como hace el tutorial de TinyML y publícalo con la misma forma de JSON. Cuando termines, borra cada resultado retenido publicando un mensaje retenido vacío en su topic. El script usa el servidor MQTT público gratuito broker.connectmq.com, que cualquiera puede leer: úsalo solo para pruebas y prototipos, nunca con datos de producción.

La misma salida, distinto hardware

Elijas lo que elijas, mantén idéntico el contrato de salida en todas las plataformas: la misma jerarquía de topics, los mismos campos JSON y un campo model y otro hardware en cada mensaje. Así podrás mezclar placas en un mismo despliegue, como nodos ESP32-S3 en los motores y una Jetson en la línea de cámaras, y todos los consumidores leerán los resultados de la misma manera. Un broker MQTT en la nube lo facilita entre instalaciones: con ConnectMQ, cada placa se conecta hacia fuera por TLS con sus propias credenciales y su client ID, y el explorador de topics del portal muestra todas las placas publicando en el mismo árbol. Como contexto, consulta qué es edge AI y la guía de IA e IoT.

Conecta cualquier placa de edge AI a ConnectMQ

Desde un ESP32-S3 alimentado por batería hasta una Jetson con varias cámaras, todas las placas hablan MQTT. ConnectMQ es un broker MQTT gestionado con endpoints TCP, TLS y WebSocket, MQTT 5 y un explorador de topics en directo, para que los resultados de hardware heterogéneo lleguen a un mismo lugar. Crea un broker con el plan Serverless gratuito en app.connectmq.com, sin tarjeta de crédito.

Preguntas frecuentes

¿Cuál es el mejor hardware para edge AI para principiantes?

Una Raspberry Pi 5 es el punto de partida más fácil porque ejecuta las herramientas estándar de Python. Añade un acelerador Hailo o Coral cuando necesites visión en tiempo real y prueba un ESP32-S3 cuando quieras modelos de sensores de bajo consumo.

¿Es Jetson mejor que Coral o Hailo?

Jetson es más flexible y ejecuta modelos más grandes y más tipos de operadores, pero consume más. Coral y Hailo son eficientes con los modelos int8 compatibles. La elección correcta depende de tu modelo y de tu presupuesto energético.

¿Puede un ESP32-S3 ejecutar detección de objetos?

Puede ejecutar modelos de detección muy pequeños sobre imágenes de baja resolución, lo que basta para detectar presencia o hacer recuentos sencillos. Para una detección de uso general a tasas de fotogramas útiles, usa una placa Linux con un acelerador.

¿Por qué hacer un benchmark de mi propio modelo en lugar de usar las cifras publicadas?

Las cifras publicadas usan modelos, tamaños de entrada y ajustes concretos. La compatibilidad de operadores, la cuantización y el preprocesamiento son distintos para tu modelo, así que solo tus propias mediciones predicen el rendimiento real.