Edge-AI-Hardware im Vergleich: Jetson, Coral, Hailo, Raspberry Pi und ESP32-S3

Die Wahl der Edge-AI-Hardware ist ein Abwägen zwischen Modellgröße, Bildrate, Energiebudget, Kosten und dem Maß an Toolchain-Schmerz, das Ihr Team verkraften kann. Dieser Vergleich behandelt die wichtigsten Optionen, von NVIDIA-Jetson-Modulen über Coral- und Hailo-Beschleuniger bis hin zu einfachen Raspberry-Pi-CPUs und ESP32-S3-Mikrocontrollern, erklärt, wo jede davon passt, und liefert Ihnen ein Benchmark-Skript, das die Latenz Ihres eigenen Modells über MQTT veröffentlicht, damit Sie Boards anhand echter Zahlen statt Datenblättern vergleichen können.

So vergleichen Sie Edge-AI-Hardware

Herstellerdatenblätter nennen meist Spitzenwerte an Operationen pro Sekunde, doch Spitzenwerte sagen selten voraus, was Ihr Modell leisten wird. In der Praxis zählen mehrere Faktoren mehr:

1. Unterstützte Operatoren. Ein Beschleuniger beschleunigt nur die Operatoren, die sein Compiler unterstützt. Nicht unterstützte Schichten fallen auf die CPU zurück und machen den Gewinn mitunter zunichte.
2. Präzision. Die meisten NPUs und TPUs benötigen int8-quantisierte Modelle. GPUs können auch FP16 und FP32 ausführen.
3. Speicher. Modellgewichte, Aktivierungen und Kamerapuffer müssen hineinpassen. Auf Mikrocontrollern ist das die erste Grenze, an die Sie stoßen.
4. Energie und Wärme. Ein Board, das in einem geschlossenen Gehäuse drosselt, ist langsamer als sein Benchmark.
5. Toolchain und Lebenszyklus. Wie Modelle konvertiert werden, wie lange der Hersteller Betriebssystem-Images und Bibliotheken unterstützt und ob das Board über die Lebensdauer Ihres Produkts verfügbar ist.
6. Konnektivität. Jede Option hier kann Ergebnisse an einen MQTT-Broker veröffentlichen; der Unterschied liegt darin, ob WLAN oder Ethernet integriert ist oder ein Gateway nötig ist.

Vergleichstabelle für Edge-AI-Hardware

Die Leistungsklassen sind bewusst grob gefasst, denn der tatsächliche Verbrauch hängt von Arbeitslast, Taktraten und Peripherie ab. Messen Sie Ihren eigenen Aufbau.

Mikrocontroller: ESP32-S3

Der ESP32-S3 liegt am unteren Ende der Energie- und Kostenskala und ist die einzige Option hier, die über lange Zeit mit einem kleinen Akku laufen kann. Seine Vektorbefehle beschleunigen die Kernels neuronaler Netze in den Bibliotheken von Espressif, und Varianten mit PSRAM können kleine Bildverarbeitungsmodelle aufnehmen. Er ist ideal, wenn ein Modell einen Sensordatenstrom in gelegentliche Ereignisse verwandeln soll. Die Grenzen sind klar: Modelle im Bereich von Kilobytes bis wenigen Megabytes und nur niedrig aufgelöste Bilder. Einen vollständigen Aufbau finden Sie in TinyML auf dem ESP32, die Einschränkungen unter was TinyML ist.

Raspberry Pi mit und ohne Beschleuniger

Ein Raspberry Pi 5 allein führt kleine Klassifikations- und Erkennungsmodelle auf der CPU aus, was für Prototypen, Belegungszählung mit wenigen Bildern pro Sekunde oder Audioklassifikation genügt. Seine Stärke ist das Software-Ökosystem: Python, OpenCV, Kamerabibliotheken und einfache MQTT-Clients.

Eine Hailo-NPU über das Raspberry Pi AI Kit oder den AI HAT+ verändert das Bild für die Bildverarbeitung. Objekterkennung in Echtzeit wird praktikabel, während die CPU für die Anwendungslogik frei bleibt. Modelle müssen mit der Toolchain von Hailo kompiliert werden, und die offizielle Raspberry-Pi-AI-Dokumentation beschreibt Einrichtung und Kameraintegration. Raspberry Pi bietet außerdem eine AI Camera, die die Inferenz auf dem Bildsensor selbst ausführt und sich für Installationen mit einer einzelnen Kamera eignet.

Coral Edge TPU

Coral-Beschleuniger führen für die Edge TPU kompilierte int8-Modelle von TensorFlow Lite aus und sind sehr energieeffizient bei Modellen, deren Operatoren der Compiler vollständig abbildet. Es gibt sie als USB-Sticks, M.2- und PCIe-Karten sowie als Dev Board. Prüfen Sie vor einer Festlegung den aktuellen Stand der Coral-Softwareunterstützung für Ihr Betriebssystem und Ihre Python-Version, da sie sich in der Vergangenheit langsamer entwickelt hat als die Hardware, an die sie angeschlossen wird. Der Leitfaden zur Coral Edge TPU behandelt Einrichtung und MQTT-Veröffentlichung im Detail.

NVIDIA Jetson

Jetson-Module bringen eine vollwertige CUDA-GPU an die Edge. Sie bewältigen mehrere Kamerastreams, größere Detektoren, Segmentierung, Posenschätzung und auf leistungsstärkeren Modulen auch kleine Sprach- und Vision-Language-Modelle. TensorRT optimiert Modelle für die GPU, und DeepStream baut Videopipelines mit mehreren Streams. Die Kehrseiten sind höherer Stromverbrauch, aktive Kühlung in den meisten Gehäusen und ein schwererer Software-Stack, der an JetPack-Releases gebunden ist. Ein praktisches Beispiel finden Sie im Leitfaden zu Jetson Nano und MQTT.

Edge-AI-Hardware auswählen: eine Checkliste

1. Aufgabe und Zielrate festlegen: welches Modell, welche Eingabegröße, wie viele Inferenzen pro Sekunde und wie viele Kameras oder Sensoren.
2. Energie- und Umgebungsbudget bestimmen: Akku, PoE, lüfterloses Gehäuse, Temperaturbereich.
3. Operator-Kompatibilität prüfen, indem Sie Ihr tatsächliches Modell für jeden Kandidaten kompilieren, nicht ein Demomodell.
4. Ende-zu-Ende messen, einschließlich Vor- und Nachverarbeitung, die auf kleinen Geräten oft dominieren.
5. Updates planen: Wie gelangt ein neues Modell auf das Gerät, und wie lange werden Betriebssystem und SDK unterstützt?
6. Die kleinste Plattform wählen, die das Ziel mit Reserve erfüllt. Kleinere Hardware ist günstiger, kühler und einfacher zu warten.

Ihr Modell benchmarken und die Ergebnisse über MQTT veröffentlichen

Der fairste Vergleich ist Ihr eigenes Modell auf jedem Board, gemeldet an einen zentralen Ort. Dieses Skript führt ein TensorFlow-Lite-Modell wiederholt mit Zufallseingaben aus, misst die Latenz und veröffentlicht von jedem Board eine Zusammenfassung in denselben Topic-Baum, sodass ein einziger Abonnent alle Ergebnisse nebeneinander sieht. Das Beispiel veröffentlicht auf dem öffentlichen MQTT-Broker broker.connectmq.com, der für Tests und Prototypen gedacht ist; Benchmark-Werte sind dort für jeden lesbar. Es verwendet den LiteRT-Interpreter, falls installiert, greift sonst auf tflite_runtime oder TensorFlow zurück und kann den Delegate der Coral Edge TPU laden.

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()

Führen Sie es auf jedem Board mit demselben Präfix aus und lesen Sie dann alle Ergebnisse auf einmal. Da jedes Ergebnis eine Retained Message ist, erscheinen auch Boards, die gestern gemessen wurden:

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

Damit messen Sie nur die Aufrufzeit des Modells. Nehmen Sie Kameraaufnahme und Vorverarbeitung in den gemessenen Abschnitt auf, um einen Ende-zu-Ende-Wert zu erhalten. Für Jetson exportieren Sie dasselbe Netz nach TensorRT und messen es mit einer entsprechenden Schleife; für den ESP32-S3 protokollieren Sie esp_timer_get_time() rund um Invoke(), wie es das TinyML-Tutorial tut, und veröffentlichen das Ergebnis in derselben JSON-Form. Wenn Sie fertig sind, löschen Sie jedes Retained-Ergebnis, indem Sie eine leere Retained Message auf sein Topic veröffentlichen.

Gleiche Ausgabe, unterschiedliche Hardware

Was immer Sie wählen: Halten Sie den Ausgabevertrag über alle Plattformen hinweg identisch, mit derselben Topic-Hierarchie, denselben JSON-Feldern und einem model- und hardware-Feld in jeder Nachricht. Dann können Sie Boards in einem Deployment mischen, etwa ESP32-S3-Knoten an Motoren und einen Jetson an der Kameralinie, und jeder Konsument liest die Ergebnisse auf dieselbe Weise. In der Fertigung hängen Sie die Inferenzergebnisse an den passenden Knoten Ihres Unified Namespace (UNS), dessen Topic-Struktur der ISA-95-Hierarchie folgt, etwa acme/werk-stuttgart/montage/linie-1/zelle-3/vision/defekte; so sehen MES und Qualitätssicherung die KI-Ergebnisse direkt neben den Maschinendaten. Ein Cloud-MQTT-Broker macht das über Standorte hinweg einfach: Mit ConnectMQ verbindet sich jedes Board ausgehend über TLS mit eigenen Zugangsdaten und eigener Client ID, und der Topic-Explorer im Portal zeigt jedes Board, das in denselben Baum veröffentlicht. Hintergründe finden Sie unter was Edge AI ist und im Leitfaden zu KI und IoT.

Jedes Edge-AI-Board mit ConnectMQ verbinden

Vom batteriebetriebenen ESP32-S3 bis zum Jetson mit mehreren Kameras spricht jedes Board MQTT. ConnectMQ ist ein verwalteter MQTT-Broker mit TCP-, TLS- und WebSocket-Endpunkten, MQTT 5 und einem Live-Topic-Explorer, sodass Ergebnisse gemischter Hardware an einem Ort landen. Erstellen Sie einen Broker im kostenlosen Serverless-Plan unter app.connectmq.com, ohne Kreditkarte.

Häufig gestellte Fragen

Welche Edge-AI-Hardware eignet sich am besten für Einsteiger?

Ein Raspberry Pi 5 ist der einfachste Einstieg, weil er Standardwerkzeuge für Python ausführt. Ergänzen Sie einen Hailo- oder Coral-Beschleuniger, wenn Sie Bildverarbeitung in Echtzeit brauchen, und probieren Sie einen ESP32-S3 aus, wenn Sie stromsparende Sensormodelle möchten.

Ist Jetson besser als Coral oder Hailo?

Jetson ist flexibler und führt größere Modelle und mehr Operatortypen aus, verbraucht aber mehr Strom. Coral und Hailo sind für unterstützte int8-Modelle effizient. Die richtige Wahl hängt von Ihrem Modell und Ihrem Energiebudget ab.

Kann ein ESP32-S3 Objekterkennung ausführen?

Er kann sehr kleine Erkennungsmodelle auf niedrig aufgelösten Bildern ausführen, was für Anwesenheitserkennung oder einfaches Zählen genügt. Für universelle Objekterkennung mit brauchbaren Bildraten verwenden Sie ein Linux-Board mit Beschleuniger.

Warum mein eigenes Modell benchmarken statt veröffentlichte Werte zu nutzen?

Veröffentlichte Werte beruhen auf bestimmten Modellen, Eingabegrößen und Einstellungen. Operator-Unterstützung, Quantisierung und Vorverarbeitung unterscheiden sich bei Ihrem Modell, daher sagen nur Ihre eigenen Messungen die reale Leistung voraus.