Objekterkennung auf dem Raspberry Pi: YOLO26 auf der CPU eines Pi 5, ohne Beschleuniger
YOLO26n benötigt mit NCNN auf der CPU eines Raspberry Pi 5 67,03 ms pro Bild. Arm misst mit seiner Open-Source-Laufzeitumgebung im eigenen Test 36,60 ms. So führst du beide aus.
Onuralp Sezer11 Min. Lesezeit
Kann ein Raspberry Pi 5 Objekterkennung allein auf seiner CPU ausführen, ohne AI HAT oder USB-Beschleuniger? Ja. In unserem eigenen Benchmark benötigt Ultralytics YOLO26n, exportiert nach NCNN, auf den vier Arm Cortex-A76-Kernen des Pi 5 67,03 ms Inferenzzeit pro Bild, also etwa 15 Inferenzbilder pro Sekunde. Arm hat außerdem eine speziell für dieses Modell und diese Platine entwickelte Open-Source-Laufzeitumgebung veröffentlicht. In Arms eigenem Test benötigt sie 36,60 ms pro Bild, also etwa 27 Inferenz-FPS.
Dieser Artikel erläutert die Bedingungen hinter den einzelnen Zahlen und erklärt, was sie aussagen. Anschließend wird Schritt für Schritt gezeigt, wie du YOLO26n auf der CPU eines Raspberry Pi 5 ausführst – von der Installation bis zur Live-Kamera. Außerdem erfährst du, wie du Arms Laufzeitumgebung auf derselben Platine ausführst und wann sich ein zusätzlicher Beschleuniger lohnt.
Wenn du die Aufgabe selbst noch nicht kennst, beginne mit einer Erklärung der Objekterkennung. Auf dieser Seite geht es darum, sie auf einem Pi zum Laufen zu bringen.
Arms Laufzeitumgebung führt YOLO26n auf der CPU eines Raspberry Pi 5 mit 36,60 ms pro Bild aus#
Arms Repository Optimized-Runtimes umfasst für Arm optimierte Inferenz-Laufzeitumgebungen für bestimmte Modelle und Plattformen. Derzeit ist dort eine Laufzeitumgebung für die YOLO26n-Objekterkennung auf einem Raspberry Pi 5 aufgeführt. Jede Laufzeitumgebung befindet sich in einem eigenen Verzeichnis mit Build, Konvertierung, Beispielen, Benchmarks, Tests und Dokumentation zur Veröffentlichung.
Arms Lernpfad vergleicht die eigene Laufzeitumgebung in einem Test mit NCNN: Die Arm-Laufzeitumgebung benötigt 36,60 ms pro Bild, NCNN 67,20 ms. Beide Tests verwenden YOLO26n mit 640 x 640 Pixeln und Batchgröße 1 auf Arms Datensatz mit 128 Bildern coco-128-by-sa. Die Genauigkeit war ähnlich: 0,4863 mAP50-95 für die Arm-Laufzeitumgebung und 0,4902 für NCNN. Die Messwerte entsprechen etwa 27 gegenüber 15 Inferenz-FPS – in diesem Test bietet Arms Laufzeitumgebung also rund 84 % mehr Durchsatz. Arm weist darauf hin, dass beim NCNN-Modell FP32-Gewichte mit aktivierter FP16-Arithmetik verwendet wurden.
Für ein Team, das auf einer kosten- und stromsparenden Platine entwickelt, bedeutet eine nahezu halbierte Inferenzzeit, dass für die Aufnahme jedes Bildes, das Tracking und den Rest der Anwendung mehr Zeit zur Verfügung steht. Das sind ausschließlich Inferenzzeiten. Aufnahme, Vorverarbeitung, Zeichnen und Anzeige verlängern die Verarbeitung jedes Bildes. Miss daher die gesamte Kamerapipeline auf dem Gerät. Die Laufzeitumgebung setzt außerdem die Zusammenarbeit fort, über die wir im Zusammenhang mit der Arm Create 2026 berichtet haben: Dort wurde Ultralytics YOLO zum Start als voroptimiertes Modell in das Arm AI Portal aufgenommen.
Unser NCNN-Benchmark misst für YOLO26n auf einem Raspberry Pi 5 67,03 ms pro Bild#
Das Ultralytics-Team hat YOLO26 auf einem Raspberry Pi 5 in acht Exportformaten für den Raspberry-Pi-Leitfaden getestet. Die Bedingungen: Modelle mit FP32-Genauigkeit exportiert, die standardmäßige Eingabegröße von 640 Pixeln, Ultralytics 8.4.108, Genauigkeitsmessung auf COCO128 und ausschließlich Inferenzzeit, ohne Vor- und Nachverarbeitung. Für unseren Benchmark wurde ein FP32-Export verwendet. In Arms separatem NCNN-Test war FP16-Arithmetik aktiviert. Die beiden NCNN-Messwerte von 67,03 ms und 67,20 ms sind nicht direkt vergleichbar.
NCNN war mit deutlichem Abstand das schnellste Ultralytics-Exportformat:
| YOLO26n-Format | Inferenzzeit (ms/Bild) | mAP50-95(B), COCO128 |
|---|---|---|
| PyTorch | 299.09 | 0.4760 |
| ONNX | 125.99 | 0.4734 |
| LiteRT | 123.30 | 0.4730 |
| OpenVINO | 104.55 | 0.4734 |
| MNN | 91.87 | 0.4749 |
| NCNN | 67.03 | 0.4784 |
NCNN ist etwa 4,5-mal schneller als die PyTorch-Gewichte (67,03 ms gegenüber 299,09 ms). Auf COCO128 erzielte NCNN 0,4784 mAP50-95 gegenüber 0,4760 für PyTorch. Das größere YOLO26s benötigt mit NCNN 172,88 ms. Wenn du also die höchste Bildrate auf einer Pi-CPU erzielen möchtest, solltest du mit dem Nano-Modell beginnen.
YOLO26 übertrifft auf dieser Platine auch seinen Vorgänger. In einem separaten ONNX-Benchmark mit 640 Pixeln erreicht YOLO26n 7,79 FPS gegenüber 6,79 FPS für YOLO11n, also etwa 15 % mehr, und erzielt bei der COCO-Validierung 40,1 % mAP50-95 gegenüber 39,5 % (Ultralytics 8.4.14). YOLO26 kann außerdem ohne Non-Maximum-Suppression ausgeführt werden, wenn es mit nms=False in Formate exportiert wird, die dies unterstützen, etwa ONNX und OpenVINO. NCNN verwendet ersatzweise den Standard-Head mit NMS, wie der Leitfaden zur End-to-End-Erkennung erklärt.
Vergleiche Raspberry-Pi-Messwerte nur unter gleichen Bedingungen#
Arms Test ist hilfreich, weil Modell, Eingabegröße, Batch und Datensatz bei allen Laufzeitumgebungen gleich bleiben. Bei den meisten Raspberry-Pi-Benchmarks, die du online findest, ist das nicht der Fall. Drei Einstellungen beeinflussen ein Ergebnis stärker als alle anderen: die Genauigkeit (FP32, FP16 oder INT8), die Eingabegröße und der Umfang der gemessenen Zeit – nur der Vorwärtsdurchlauf des Modells oder die gesamte Verarbeitung vom Bild bis zu den endgültigen Boxen.
Auch bei der Genauigkeit ist Sorgfalt geboten. Unser mAP-Wert basiert auf COCO128, einer Stichprobe mit 128 Bildern. Prüfe die Genauigkeit daher vor der Bereitstellung anhand deiner eigenen Validierungsbilder – besonders bei einem quantisierten Modell.
YOLO26n in fünf Schritten auf der CPU eines Raspberry Pi 5 ausführen#
Hier ist der schnellste unterstützte Weg mit dem Ultralytics-Python-Paket. Voraussetzung ist ein Raspberry Pi 5 mit 64-Bit-Raspberry Pi OS. Im Raspberry-Pi-Leitfaden wird erklärt, wie du das Betriebssystem aufspielst und Docker einrichtest.
- Ultralytics in einer virtuellen Umgebung installieren. Das aktuelle Raspberry Pi OS verhindert die Installation von
pipin das systemweite Python. Erstelle deshalb eine Umgebung, die weiterhin auf die Systemkamerabibliothek zugreifen kann:
sudo apt update
sudo apt install -y python3-venv python3-picamera2 rpicam-apps
python3 -m venv --system-site-packages ~/yolo
source ~/yolo/bin/activate
pip install ultralytics- YOLO26n nach NCNN exportieren und testen. Der Exportmodus erstellt einen Ordner
yolo26n_ncnn_model, den du wie jedes andere Modell lädst:
from ultralytics import YOLO
# # Einmal auf dem Pi exportieren; erstellt den Ordner 'yolo26n_ncnn_model'
model = YOLO("yolo26n.pt")
model.export(format="ncnn")
# # Das NCNN-Modell laden und auf der CPU ausführen
ncnn_model = YOLO("yolo26n_ncnn_model")
results = ncnn_model("https://ultralytics.com/images/bus.jpg")
print(results[0].speed) # # Vorverarbeitungs-, Inferenz- und Nachverarbeitungszeiten in ms
YOLO26n nach NCNN exportiert und mit dem Testbild bus.jpg aus Schritt 2 ausgeführt: ein Bus und vier Personen erkannt. Auf einer Desktop-CPU aufgenommen; Boxen und Konfidenzwerte können auf einem Pi leicht abweichen.
- Eine Kamera anschließen. Prüfe das Kamerabild mit
rpicam-hello. Der Pi 5 hat zwei 22-polige Kamera-/Display-Anschlüsse. Für Kameramodule mit 15-poligem Stecker brauchst du daher ein Adapterkabel. - Live-Erkennung ausführen.
picamera2übergibt die Bilder direkt an das Modell. Das Fenstercv2.imshowerfordert eine Desktop-Sitzung. Entferne auf einem Pi ohne Bildschirm die Anzeigezeilen und verwende die Ergebnisse stattdessen im Code:
import cv2
from picamera2 import Picamera2
from ultralytics import YOLO
picam2 = Picamera2()
picam2.preview_configuration.main.size = (1280, 720)
picam2.preview_configuration.main.format = "RGB888"
picam2.preview_configuration.align()
picam2.configure("preview")
picam2.start()
model = YOLO("yolo26n_ncnn_model")
while True:
frame = picam2.capture_array()
results = model(frame)
cv2.imshow("Camera", results[0].plot())
if cv2.waitKey(1) == ord("q"):
break
cv2.destroyAllWindows()- Auf deiner Platine benchmarken.
yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640versucht jedes Exportformat auf deinem eigenen Pi, sodass du siehst, welche Leistung dein Kühlsystem, dein Betriebssystemabbild und dein Netzteil ermöglichen. Einige Formate lassen sich nicht direkt auf dem Pi exportieren: LiteRT zum Beispiel nur unter Linux x86_64 oder macOS. Exportiere es dort, kopiere die Datei auf den Pi und überprüfe es separat. Für zuverlässigere Genauigkeitswerte verwende einen größeren Validierungsdatensatz wiedata=coco.yaml.
Arms Laufzeitumgebung und NCNN auf demselben Pi ausführen#
Arms Laufzeitumgebung ist ein separates Projekt und kein Ultralytics-Exportformat. Die Einrichtungsschritte sind auf das 64-Bit-Raspberry Pi OS Trixie mit Python 3.13 ausgelegt. So kannst du sie ausprobieren und mit NCNN vergleichen:
- Klone arm/Optimized-Runtimes, wechsle in das Verzeichnis
yolo26-raspberry-pi-5, befolge die Voraussetzungen und erstelle die Laufzeitumgebung mitmake runtime. - Führe
make example-videoaus, um Erkennungen in einem Beispielvideo zu sehen. - Führe
make ultralytics-benchmarkaus, um die Arm-Laufzeitumgebung auf deiner Platine zu benchmarken. - Exportiere YOLO26n wie oben in Schritt 2 nach NCNN und überprüfe es anschließend anhand desselben erstellten Datensatzes
coco-128-by-sa. Verwende dazu die Umgebung, den Checkpoint und die Befehle auf Arms Vergleichsseite, damit beide Laufzeitumgebungen dieselben Bilder mit derselben Eingabegröße verarbeiten. - Konvertiere für dein eigenes Modell einen kompatiblen, feinabgestimmten YOLO26n-Checkpoint mit
make model CHECKPOINT=/path/to/checkpoint.pt, wie auf der Modellkarte der Laufzeitumgebung beschrieben. Vergleiche sowohl die Genauigkeit anhand deines eigenen Validierungssatzes als auch die Geschwindigkeit.
In Arms Vergleich war die eigene Laufzeitumgebung der schnellere CPU-Weg für die YOLO26n-Erkennung. Der Ultralytics-NCNN-Export deckt den Rest ab: weitere YOLO26-Größen und Aufgaben, darunter Segmentierung und Pose, mit denselben zwei Codezeilen und innerhalb der im NCNN-Leitfaden aufgeführten Einschränkungen.
Kühlung, Übertaktung und ein schlankeres Betriebssystem sorgen für mehr Bilder pro Sekunde#
Sobald das Modell läuft, setzt die Platine die Leistungsgrenze. Die bewährten Vorgehensweisen im Raspberry-Pi-Leitfaden zeigen, was hilft:
- Die Platine kühlen. Bei längerer Inferenz erhitzt sich die CPU, und thermische Drosselung senkt die Taktfrequenz, die deinem Benchmark zugrunde lag. Ein Kühlkörper und ein Lüfter sorgen für gleichbleibende Bildverarbeitungszeiten.
- Übertakten, wenn du ausreichend kühlen kannst. Einige Pi-5-Platinen lassen sich mit
arm_freq=3000undforce_turbo=1in/boot/firmware/config.txtvon ihrer Basistaktfrequenz von 2,4 GHz auf 3,0 GHz übertakten. Starte danach den Pi neu. Die Stabilität variiert je nach Platine. Wird das System instabil, reduziere die Taktfrequenz in Schritten von 100 MHz. - Auf die Desktop-Oberfläche verzichten. Raspberry Pi OS Lite lässt mehr Arbeitsspeicher für Bildverarbeitungsaufgaben frei.
- Für den Dauerbetrieb eine SSD verwenden. Durch kontinuierliche Schreibvorgänge kann eine SD-Karte verschleißen. Der PCIe-Anschluss des Pi 5 unterstützt einen NVMe-Adapter.
- Die Eingabegröße verringern, wenn die Objekte groß sind. Eine kleinere
imgszbedeutet weniger Pixel pro Bild. Miss die Auswirkungen auf Geschwindigkeit und Genauigkeit anhand deiner eigenen Aufnahmen, denn kleine oder weit entfernte Objekte leiden zuerst darunter. Unser Leitfaden zu FPS in der Computer Vision erklärt, wie du ein Bildratenbudget festlegst.
Einen Beschleuniger hinzufügen, wenn eine Pi-CPU nicht ausreicht#
Ein Pi 5 ohne Beschleuniger eignet sich für eine Kamera mit moderater Bildrate. Bei mehreren Streams, größeren Modellen oder zusätzlichem Leistungsbedarf für andere Software verlagert ein Beschleuniger die Modellverarbeitung von der CPU. Unsere gemessenen YOLO26n-Inferenzzeiten auf einem Raspberry Pi 5 (nur Inferenz, COCO128) stammen aus separaten Tests mit quantisierten Modellen und verschiedenen Ultralytics-Versionen:
- Hailo-8 im AI HAT+: 21,7 ms bei 0,455 mAP50-95, Ultralytics 8.4.174.
- DEEPX-DX-M1-M.2-Modul: 34,6 ms bei 0,4660 mAP50-95, Ultralytics 8.4.48.
- Coral Edge TPU: eine USB-Option mit eigenem Exportweg. Die Messwerte in diesem Leitfaden wurden mit YOLOv8-Modellen ermittelt.
Jeder dieser Beschleuniger erfordert zusätzliche Hardware, Stromversorgung und einen Schritt zur Modellkompilierung. Beschleunigte Modelle werden quantisiert ausgeführt; prüfe daher die Genauigkeit nach dem Export. Einen breiteren Überblick findest du in Unserem Leitfaden zur Auswahl des passenden Edge-Geräts und im NVIDIA-Jetson-Leitfaden, falls du mehr Rechenleistung benötigst, als ein Pi bietet.
Einen eigenen Detektor trainieren und auf dieselbe Weise bereitstellen#
Die 80 Klassen von COCO sind ein Ausgangspunkt. Die meisten Pi-Projekte benötigen eigene Objekte: ein Werkstück auf einem Förderband, ein Produkt im Regal, einen Schädling auf einem Blatt. Ultralytics Platform deckt den gesamten Ablauf ab: Lade einen Datensatz hoch und annotiere ihn, trainiere das Modell in der Cloud mit dem YOLO26n-Checkpoint, exportiere es anschließend nach NCNN und kopiere den Ordner auf den Pi.
Beginne mit dem Nano-Modell. Überprüfe anschließend die Genauigkeit und miss die Geschwindigkeit deines eigenen Modells anhand repräsentativer Aufnahmen mit der Kamera, die du einsetzen wirst. Unsere Tipps zum Modelltraining und die Lektion der Academy zur Auswahl eines Bereitstellungsziels behandeln die weiteren Schritte.
Für wen eignet sich YOLO26 auf der CPU eines Raspberry Pi 5?#
Führe YOLO26n auf der CPU des Pi 5 aus, wenn du eine Kamera hast, mit der Bildrate arbeiten kannst, die du für das gesamte Gerät gemessen hast, und die einfachste Materialliste möchtest: ein Raspberry Pi, eine Kamera, ein Lüfter und ein Netzteil. Kassensysteme im Einzelhandel, Überwachungs- und Wildkameras, das Zählen auf Förderbändern und Robotik-Prototypen eignen sich dafür.
Verwende Arms Laufzeitumgebung, wenn die YOLO26n-Erkennung deine gesamte Arbeitslast ausmacht und jede Millisekunde zählt. Füge einen Beschleuniger hinzu, wenn du mehrere Kameras oder größere Modelle benötigst oder CPU-Zeit für den Rest deiner Anwendung freihalten möchtest.
Ultralytics YOLO ist unter AGPL-3.0 oder einer Ultralytics Enterprise License verfügbar. Welche Lizenz deine Bereitstellung erfordert, erfährst du in den Ultralytics-Lizenzoptionen.
Häufig gestellte Fragen
Ja, für Aufgaben mit einer Kamera und moderater Bildrate. Im Ultralytics-Benchmark benötigt YOLO26n, exportiert nach NCNN, auf der CPU eines Raspberry Pi 5 67,03 ms Inferenzzeit pro Bild (FP32-Export, Eingabegröße 640 Pixel), also etwa 15 Inferenz-FPS. In einem separaten Vergleich maß Arm mit der eigenen Open-Source-Laufzeitumgebung für YOLO26n 36,60 ms. Das war ein anderer Test und keine Beschleunigung gegenüber unserem Messwert von 67,03 ms. Die Aufnahme und das Zeichnen mit der Kamera verlängern die Verarbeitung. Miss daher die gesamte Pipeline.
In Arms Vergleichstest war die Laufzeitumgebung Optimized-Runtimes für YOLO26n mit 36,60 ms pro Bild am schnellsten, gegenüber 67,20 ms für NCNN. In unserem separaten Benchmark der Ultralytics-Exportformate war NCNN mit 67,03 ms am schnellsten, vor MNN mit 91,87 ms und OpenVINO mit 104,55 ms. Für die Benchmarks wurden unterschiedliche Datensätze verwendet: COCO128 und Arms coco-128-by-sa. Daher belegen die Messwerte keine Beschleunigung zwischen den Tests.
Ja. In einem separaten ONNX-Benchmark mit 640 Pixeln auf einem Raspberry Pi 5 erreicht YOLO26n 7,79 FPS gegenüber 6,79 FPS für YOLO11n, also etwa 15 % mehr. Bei der COCO-Validierung erzielt YOLO26n 40,1 % mAP50-95 gegenüber 39,5 %.
Nicht für eine einzelne Kamera mit moderater Bildrate. Ein Beschleuniger lohnt sich bei mehreren Streams oder größeren Modellen: In unseren Tests benötigte ein quantisiertes YOLO26n auf einem Hailo-8 AI HAT+ 21,7 ms Inferenzzeit pro Bild, verglichen mit 67,03 ms für den FP32-NCNN-Export auf der CPU. Die Werte stammen aus separaten Tests mit unterschiedlichen Versionen und Genauigkeiten.
Ja. Trainiere dein Modell in Python oder auf der Ultralytics Platform, exportiere es mit
format="ncnn", kopiere den Ordner_ncnn_modelauf den Pi und lade ihn mitYOLO("your_model_ncnn_model"). Ändere den Modellpfad im Kameracode und führe einen Benchmark anhand deiner eigenen Dataset-YAML-Datei und Klassen durch. Arms Laufzeitumgebung konvertiert außerdem kompatible, feinabgestimmte YOLO26n-Checkpoints.
Verfasst von
Kommentare
Stelle eine Frage, teile deine Ergebnisse oder hilf anderen.










