Comparatif du matériel edge AI : Jetson, Coral, Hailo, Raspberry Pi et ESP32-S3

Choisir du matériel edge AI revient à arbitrer entre taille du modèle, fréquence d'images, budget énergétique, coût et complexité des outils que votre équipe peut absorber. Ce comparatif couvre les principales options, des modules NVIDIA Jetson et des accélérateurs Coral et Hailo aux simples CPU de Raspberry Pi et aux microcontrôleurs ESP32-S3, explique la place de chacune et vous fournit un script de benchmark qui publie la latence de votre propre modèle via MQTT, pour comparer les cartes sur des chiffres réels plutôt que sur des fiches techniques.

Comment comparer le matériel edge AI

Les fiches techniques des fabricants indiquent généralement un nombre maximal d'opérations par seconde, mais ces valeurs de crête prédisent rarement le comportement de votre modèle. Plusieurs facteurs comptent davantage en pratique :

1. La prise en charge des opérateurs. Un accélérateur n'accélère que les opérateurs pris en charge par son compilateur. Les couches non prises en charge retombent sur le CPU, ce qui peut annuler le gain.
2. La précision. La plupart des NPU et TPU exigent des modèles quantifiés en int8. Les GPU peuvent aussi exécuter du FP16 et du FP32.
3. La mémoire. Les poids du modèle, les activations et les tampons de la caméra doivent tenir. Sur les microcontrôleurs, c'est la première limite que l'on atteint.
4. La consommation et la thermique. Une carte qui réduit sa fréquence dans un boîtier étanche est plus lente que son benchmark.
5. Les outils et le cycle de vie. La façon dont les modèles sont convertis, la durée pendant laquelle le fabricant maintient les images système et les bibliothèques, et la disponibilité de la carte pendant toute la durée de vie de votre produit.
6. La connectivité. Toutes les options présentées ici peuvent publier leurs résultats vers un broker MQTT ; la différence tient à la présence du Wi-Fi intégré, de l'Ethernet ou au besoin d'une passerelle.

Tableau comparatif du matériel edge AI

Les classes de consommation sont volontairement larges, car la consommation réelle dépend de la charge, des fréquences et des périphériques. Mesurez votre propre configuration.

Microcontrôleurs : ESP32-S3

L'ESP32-S3 se situe au bas de la gamme en consommation et en coût, et c'est la seule option présentée ici capable de fonctionner longtemps sur une petite batterie. Ses instructions vectorielles accélèrent les noyaux de réseaux de neurones des bibliothèques d'Espressif, et les variantes avec PSRAM peuvent accueillir de petits modèles de vision. Il est idéal lorsque le rôle d'un modèle est de transformer un flux de capteur en événement occasionnel. Les limites sont strictes : des modèles de l'ordre du kilo-octet à quelques méga-octets et uniquement des images basse résolution. Consultez TinyML sur ESP32 pour un montage complet et ce qu'est le TinyML pour les contraintes.

Raspberry Pi avec et sans accélérateur

Un Raspberry Pi 5 seul exécute de petits modèles de classification et de détection sur le CPU, ce qui suffit pour des prototypes, du comptage d'occupation à quelques images par seconde ou de la classification audio. Sa force est son écosystème logiciel : Python, OpenCV, bibliothèques caméra et clients MQTT faciles à utiliser.

Ajouter un NPU Hailo via le Raspberry Pi AI Kit ou l'AI HAT+ change la donne pour la vision. La détection d'objets en temps réel devient possible tandis que le CPU reste libre pour la logique applicative. Les modèles doivent être compilés avec la chaîne d'outils de Hailo, et la documentation IA officielle de Raspberry Pi couvre l'installation et l'intégration de la caméra. Raspberry Pi propose aussi une AI Camera qui exécute l'inférence sur le capteur d'image lui-même, ce qui convient aux déploiements à caméra unique.

Coral Edge TPU

Les accélérateurs Coral exécutent des modèles TensorFlow Lite int8 compilés pour l'Edge TPU et sont très économes en énergie pour les modèles dont le compilateur prend entièrement en charge les opérateurs. Ils existent en clés USB, cartes M.2 et PCIe, ainsi qu'en carte de développement. Avant de vous engager, vérifiez l'état actuel du support logiciel de Coral pour votre système d'exploitation et votre version de Python, car il a historiquement évolué plus lentement que le matériel auquel il se connecte. Le guide Coral Edge TPU détaille l'installation et la publication MQTT.

NVIDIA Jetson

Les modules Jetson apportent un GPU CUDA complet en périphérie. Ils gèrent plusieurs flux caméra, des détecteurs plus grands, la segmentation, l'estimation de pose et, sur les modules haut de gamme, de petits modèles de langage et modèles vision-langage. TensorRT optimise les modèles pour le GPU, et DeepStream permet de construire des pipelines vidéo multiflux. Les contreparties sont une consommation plus élevée, un refroidissement actif dans la plupart des boîtiers et une pile logicielle plus lourde liée aux versions de JetPack. Lisez le guide Jetson Nano MQTT pour un exemple pratique.

Choisir son matériel edge AI : une checklist

1. Définissez la tâche et la cadence cible : quel modèle, quelle taille d'entrée, combien d'inférences par seconde, combien de caméras ou de capteurs.
2. Fixez le budget énergétique et environnemental : batterie, PoE, boîtier sans ventilateur, plage de température.
3. Vérifiez la compatibilité des opérateurs en compilant votre modèle réel pour chaque candidat, et non un modèle de démonstration.
4. Mesurez de bout en bout, prétraitement et post-traitement compris, car ils dominent souvent sur les petits appareils.
5. Planifiez les mises à jour : comment un nouveau modèle atteindra-t-il l'appareil, et combien de temps l'OS et le SDK seront-ils maintenus ?
6. Choisissez la plus petite plateforme qui atteint la cible avec une marge. Un matériel plus petit est moins cher, chauffe moins et se maintient plus facilement.

Mesurez votre modèle et publiez les résultats via MQTT

La comparaison la plus juste consiste à exécuter votre propre modèle sur chaque carte et à rassembler les résultats en un seul endroit. Ce script exécute un modèle TensorFlow Lite de manière répétée avec une entrée aléatoire, mesure la latence et publie un résumé dans la même arborescence de topics depuis chaque carte, de sorte qu'un seul abonné voit tous les résultats côte à côte. Il publie sur le serveur MQTT public gratuit broker.connectmq.com, adapté à ce type de test et aux prototypes, mais pas aux données de production. Il utilise l'interpréteur LiteRT s'il est installé, se rabat sur tflite_runtime ou TensorFlow, et peut charger le delegate Coral Edge TPU.

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

Exécutez-le sur chaque carte avec le même préfixe, puis lisez tous les résultats d'un coup. Comme chaque résultat est en retained, les cartes mesurées la veille apparaissent toujours :

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

Ce script mesure uniquement le temps d'appel du modèle. Ajoutez la capture caméra et le prétraitement à la section chronométrée pour obtenir un chiffre de bout en bout. Pour Jetson, exportez le même réseau vers TensorRT et chronométrez-le avec une boucle équivalente ; pour l'ESP32-S3, journalisez esp_timer_get_time() autour de Invoke() comme le fait le tutoriel TinyML et publiez-le dans le même format JSON. Une fois terminé, effacez chaque résultat retained en publiant un retained message vide sur son topic.

Même sortie, matériel différent

Quel que soit votre choix, gardez un contrat de sortie identique sur toutes les plateformes : la même hiérarchie de topics, les mêmes champs JSON, et un champ model et hardware dans chaque message. Vous pourrez alors mélanger les cartes dans un même déploiement, par exemple des nœuds ESP32-S3 sur les moteurs et un Jetson sur la ligne caméra, et chaque consommateur lira les résultats de la même manière. Un broker MQTT cloud facilite cela entre plusieurs sites : avec ConnectMQ, chaque carte se connecte en sortie via TLS avec ses propres identifiants et son client ID, et l'explorateur de topics du portail montre chaque carte publiant dans la même arborescence. Pour le contexte, consultez ce qu'est l'edge AI et le guide IA et IoT.

Connectez n'importe quelle carte edge AI à ConnectMQ

D'un ESP32-S3 sur batterie à un Jetson multicaméra, toutes les cartes parlent MQTT. ConnectMQ est un broker MQTT managé avec des endpoints TCP, TLS et WebSocket, MQTT 5 et un explorateur de topics en direct, pour que les résultats d'un matériel hétérogène arrivent au même endroit. Créez un broker avec l'offre gratuite Serverless sur app.connectmq.com, sans carte bancaire.

Questions fréquentes

Quel est le meilleur matériel edge AI pour débuter ?

Un Raspberry Pi 5 est le point de départ le plus simple, car il exécute les outils Python standard. Ajoutez un accélérateur Hailo ou Coral lorsque vous avez besoin de vision en temps réel, et essayez un ESP32-S3 si vous voulez des modèles de capteurs basse consommation.

Jetson est-il meilleur que Coral ou Hailo ?

Jetson est plus flexible et exécute des modèles plus grands et davantage de types d'opérateurs, mais consomme plus. Coral et Hailo sont efficaces pour les modèles int8 pris en charge. Le bon choix dépend de votre modèle et de votre budget énergétique.

Un ESP32-S3 peut-il faire de la détection d'objets ?

Il peut exécuter de très petits modèles de détection sur des images basse résolution, ce qui suffit pour la présence ou un comptage simple. Pour une détection généraliste à des fréquences d'images utiles, utilisez une carte Linux avec un accélérateur.

Pourquoi mesurer mon propre modèle plutôt que d'utiliser les chiffres publiés ?

Les chiffres publiés reposent sur des modèles, des tailles d'entrée et des réglages spécifiques. La prise en charge des opérateurs, la quantification et le prétraitement diffèrent pour votre modèle : seules vos propres mesures prédisent les performances réelles.