Ultralytics YOLO27:
Get Started

Schnellstartanleitung: Raspberry Pi mit Ultralytics YOLO26#

Raspberry Pi ist ein kleiner, erschwinglicher Computer, auf dem Ultralytics YOLO26 für die Objekterkennung in Echtzeit direkt am Einsatzort läuft – ganz ohne GPU. Diese Anleitung führt dich durch die Bereitstellung von YOLO26 auf Raspberry Pi 4 und 5: das Betriebssystem aufspielen, Ultralytics installieren, für die schnellste Inferenz auf ARM nach NCNN exportieren und Vorhersagen mit einem Live-Kamerabild ausführen. Außerdem enthält sie Leistungsbenchmarks für acht Exportformate, damit du für deine Hardware den passenden Kompromiss zwischen Geschwindigkeit und Genauigkeit wählen kannst.

Springe zu Ultralytics einrichten, nach NCNN exportieren und Inferenz ausführen, Benchmarks oder Inferenz mit der Kamera.



Ansehen: Updates und Verbesserungen für Raspberry Pi 5.
Hinweis

Diese Anleitung wurde mit Raspberry Pi 4 und Raspberry Pi 5 getestet, auf denen das aktuelle Raspberry Pi OS Bookworm (Debian 12) läuft. Sie sollte auch auf älteren Raspberry-Pi-Geräten wie Raspberry Pi 3 funktionieren, sofern dieselbe Version von Raspberry Pi OS Bookworm installiert ist.

Was ist Raspberry Pi?#

Raspberry Pi ist ein kleiner, erschwinglicher Einplatinencomputer. Er ist für zahlreiche Projekte und Anwendungen beliebt geworden – von der Heimautomatisierung im Hobbybereich bis hin zu industriellen Einsätzen. Raspberry-Pi-Boards können verschiedene Betriebssysteme ausführen und verfügen über GPIO-Pins (allgemeine Ein- und Ausgabe), an die sich Sensoren, Aktoren und andere Hardwarekomponenten problemlos anschließen lassen. Es gibt verschiedene Modelle mit unterschiedlichen technischen Daten, doch alle folgen demselben Grundprinzip: Sie sind kostengünstig, kompakt und vielseitig.

Vergleich der Raspberry-Pi-Serien#

Raspberry Pi 3Raspberry Pi 4Raspberry Pi 5
CPUBroadcom BCM2837, Cortex-A53 64-Bit-SoCBroadcom BCM2711, Cortex-A72 64-Bit-SoCBroadcom BCM2712, Cortex-A76 64-Bit-SoC
Maximale CPU-Frequenz1.4GHz1.8GHz2.4GHz
GPUVideoCore IVVideoCore VIVideoCore VII
Maximale GPU-Taktfrequenz400MHz500MHz800MHz
Speicher1GB LPDDR2 SDRAM1GB, 2GB, 4GB, 8GB LPDDR4-3200 SDRAM2GB, 4GB, 8GB, 16GB LPDDR4X-4267 SDRAM
PCIeNicht zutreffendNicht zutreffend1xPCIe 2.0-Schnittstelle
Maximale Leistungsaufnahme2.5A@5V3A@5V5A@5V (PD aktiviert)

Was ist Raspberry Pi OS?#

Raspberry Pi OS (früher bekannt als Raspbian) ist ein Unix-ähnliches Betriebssystem, das auf der Debian-GNU/Linux-Distribution für die Familie kompakter Einplatinencomputer Raspberry Pi basiert, die von der Raspberry Pi Foundation vertrieben werden. Raspberry Pi OS ist stark für Raspberry Pi mit ARM-CPUs optimiert und verwendet eine leichtgewichtige Desktop-Umgebung, die auf Raspberry Pi 4 und 5 standardmäßig mit Wayland läuft. Raspberry Pi OS wird aktiv weiterentwickelt; dabei liegt der Schwerpunkt darauf, die Stabilität und Leistung möglichst vieler Debian-Pakete auf Raspberry Pi zu verbessern.

Raspberry Pi OS auf Raspberry Pi flashen#

Als Erstes solltest du nach dem Kauf eines Raspberry Pi eine microSD-Karte mit Raspberry Pi OS flashen, sie in das Gerät einsetzen und das Betriebssystem starten. Folge der ausführlichen Einstiegsdokumentation von Raspberry Pi, um dein Gerät für die erste Verwendung vorzubereiten.

Ultralytics einrichten#

Du kannst das Ultralytics-Paket auf zwei Arten auf Raspberry Pi einrichten, um dein nächstes Computer-Vision-Projekt umzusetzen:

Mit Docker loslegen#

Am schnellsten kannst du Ultralytics YOLO26 auf Raspberry Pi nutzen, indem du ein vorgefertigtes Docker-Image für Raspberry Pi ausführst.

Führe den folgenden Befehl aus, um den Docker-Container herunterzuladen und auf dem Raspberry Pi zu starten. Das Image basiert auf dem offiziellen Python-Image 3.13-slim-trixie, das Debian 13 mit Python 3.13 verwendet.

t=ultralytics/ultralytics:latest-arm64
sudo docker pull $t && sudo docker run -it --ipc=host $t

Das Docker-Image enthält Ultralytics bereits, sodass du direkt mit dem Export deines Modells nach NCNN beginnen kannst.

Ohne Docker loslegen#

Ultralytics-Paket installieren#

Hier installieren wir das Ultralytics-Paket auf Raspberry Pi. Exportabhängigkeiten für Formate wie NCNN werden automatisch installiert, wenn du zum ersten Mal ein PyTorch-Modell exportierst. Daher benötigst du hier nur das Basispaket.

  1. Paketlisten aktualisieren, pip installieren und auf die neueste Version aktualisieren

    sudo apt update
    sudo apt install python3-pip -y
    pip install -U pip
  2. Das pip-Paket ultralytics installieren

    pip install ultralytics
  3. Gerät neu starten

    sudo reboot

NCNN auf Raspberry Pi verwenden#

Von allen Exportformaten, die Ultralytics unterstützt, bietet NCNN die beste Inferenzleistung auf Raspberry-Pi-Geräten, da es stark für mobile und eingebettete Plattformen wie die ARM-Architektur optimiert ist. Wandle dein YOLO26n-PyTorch-Modell in NCNN um und führe anschließend mit dem exportierten Modell Inferenz aus:

Beispiel
from ultralytics import YOLO

# Ein YOLO26n-PyTorch-Modell laden
model = YOLO("yolo26n.pt")

# Das Modell ins NCNN-Format exportieren
model.export(format="ncnn")  # creates 'yolo26n_ncnn_model'

# Das exportierte NCNN-Modell laden
ncnn_model = YOLO("yolo26n_ncnn_model")

# Inferenz ausführen
results = ncnn_model("https://ultralytics.com/images/bus.jpg")
Tipp

Weitere Informationen zu den unterstützten Exportoptionen findest du im Leitfaden zu den Optionen für die Modellbereitstellung.

Leistungsverbesserungen von YOLO26 gegenüber YOLO11#

YOLO26 wurde speziell für den Einsatz auf Geräten mit begrenzten Hardware-Ressourcen wie dem Raspberry Pi 5 entwickelt. Im Vergleich zu YOLO11n erzielt YOLO26n auf dem Raspberry Pi 5 mit ONNX-exportierten Modellen bei einer Eingabegröße von 640 eine um ~15 % höhere FPS-Rate (6.79 → 7.79) und zugleich einen höheren mAP-Wert (40.1 gegenüber 39.5). Die folgende Tabelle und das Diagramm zeigen diesen Vergleich.

YOLO26 benchmarks on RPi 5
Getestet mit Ultralytics 8.4.14
Leistung
ModellmAP50-95(B)Inferenzzeit (ms/Bild)
YOLO26n40.1128.42
YOLO26s47.8352.84
YOLO26m52.5993.78
YOLO26l54.41259.46
YOLO26x56.92636.26

Getestet mit Ultralytics 8.4.14.

YOLO26-Benchmarks auf Raspberry Pi 5#

Das Ultralytics-Team hat Benchmarks für YOLO26 in acht verschiedenen Modellformaten durchgeführt und dabei Geschwindigkeit und Genauigkeit gemessen: PyTorch, TorchScript, ONNX, OpenVINO, LiteRT, MNN, NCNN, ExecuTorch. Die Benchmarks wurden auf einem Raspberry Pi 5 mit FP32-Genauigkeit und einer standardmäßigen Eingabebildgröße von 640 durchgeführt.

Vergleichsdiagramm#

Wir haben nur Benchmarks für die Modelle YOLO26n und YOLO26s aufgenommen, da die anderen Modellgrößen zu groß für Raspberry Pi-Geräte sind und keine angemessene Leistung bieten.

YOLO26 benchmarks on RPi 5
Getestet mit Ultralytics 8.4.108

Detaillierte Vergleichstabelle#

Die folgende Tabelle zeigt die Benchmark-Ergebnisse für zwei verschiedene Modelle (YOLO26n, YOLO26s) in acht verschiedenen Formaten (PyTorch, TorchScript, ONNX, OpenVINO, LiteRT, MNN, NCNN, ExecuTorch), ausgeführt auf einem Raspberry Pi 5. Für jede Kombination werden Status, Größe, die Kennzahl mAP50-95(B) und die Inferenzzeit aufgeführt.

Leistung
FormatStatusDateigröße (MB)mAP50-95(B)Inferenzzeit (ms/Bild)
PyTorch✅5.30.4760299.09
TorchScript✅9.80.4734353.20
ONNX✅9.50.4734125.99
OpenVINO✅9.60.4734104.55
LiteRT✅9.80.4730123.30
MNN✅9.40.474991.87
NCNN✅9.40.478467.03
ExecuTorch✅9.40.4772144.83

Getestet mit Ultralytics 8.4.108

Hinweis

Die Inferenzzeit umfasst keine Vor- und Nachverarbeitung.

Unsere Ergebnisse reproduzieren#

Führe diesen Code aus, um die obigen Ultralytics-Benchmarks für alle Exportformate zu reproduzieren:

Beispiel
from ultralytics import YOLO

# Ein YOLO26n-PyTorch-Modell laden
model = YOLO("yolo26n.pt")

# Benchmark für Geschwindigkeit und Genauigkeit von YOLO26n auf dem COCO128-Datensatz für alle Exportformate
results = model.benchmark(data="coco128.yaml", imgsz=640)

Beachte, dass die Benchmark-Ergebnisse je nach genauer Hardware- und Softwarekonfiguration eines Systems sowie der aktuellen Auslastung des Systems zum Zeitpunkt der Benchmarks variieren können. Die zuverlässigsten Ergebnisse erhältst du mit einem Datensatz mit vielen Bildern, z. B. data='coco.yaml' (5000 Validierungsbilder).

LiteRT-Export erfolgt auf einem anderen Gerät

Der Export nach format=litert (über litert-torch) wird nur unter Linux x86_64 und macOS unterstützt, nicht direkt auf dem Raspberry Pi. Exportiere das Modell .tflite auf einem Linux-x86_64-Rechner oder einem Mac, kopiere es auf den Raspberry Pi und verwende den Pi für die Inferenz.

Raspberry-Pi-Kamera verwenden#

Bei Computer-Vision-Projekten mit Raspberry Pi kann es wichtig sein, Videostreams in Echtzeit abzurufen, um Inferenz auszuführen. Über den integrierten MIPI-CSI-Anschluss des Raspberry Pi kannst du offizielle Raspberry-Pi-Kameramodule anschließen. In dieser Anleitung haben wir ein Raspberry Pi Camera Module 3 verwendet, um Videostreams abzurufen und mit YOLO26-Modellen Inferenz auszuführen.

Tipp
Hinweis

Der Raspberry Pi 5 hat kleinere CSI-Anschlüsse als der Raspberry Pi 4 (22-polig statt 15-polig). Daher benötigst du ein Adapterkabel von 15 auf 22 Pins, um eine Raspberry-Pi-Kamera anzuschließen.

Kamera testen#

Führe den folgenden Befehl aus, nachdem du die Kamera an den Raspberry Pi angeschlossen hast. Etwa 5 Sekunden lang solltest du ein Livebild der Kamera sehen.

rpicam-hello
Tipp

Weitere Informationen zur Verwendung von rpicam-hello in der offiziellen Raspberry-Pi-Dokumentation

Inferenz mit Kamera#

Es gibt zwei Möglichkeiten, mit der Raspberry-Pi-Kamera Inferenz mit YOLO26-Modellen auszuführen.

Inferenz mit der Raspberry-Pi-Kamera ausführen

Wir können picamera2, das mit Raspberry Pi OS vorinstalliert ist, verwenden, um auf die Kamera zuzugreifen und mit YOLO26-Modellen Inferenz auszuführen.

Beispiel
import cv2
from picamera2 import Picamera2

from ultralytics import YOLO

# Picamera2 initialisieren
picam2 = Picamera2()
picam2.preview_configuration.main.size = (1280, 720)
picam2.preview_configuration.main.format = "RGB888"
picam2.preview_configuration.align()
picam2.configure("preview")
picam2.start()

# YOLO26-Modell laden
model = YOLO("yolo26n.pt")

while True:
    # Einzelbilder aufnehmen
    frame = picam2.capture_array()

    # YOLO26-Inferenz für das Einzelbild ausführen
    results = model(frame)

    # Ergebnisse auf dem Bild visualisieren
    annotated_frame = results[0].plot()

    # Das resultierende Einzelbild anzeigen
    cv2.imshow("Camera", annotated_frame)

    # Schleife beenden, wenn „q“ gedrückt wird
    if cv2.waitKey(1) == ord("q"):
        break

# Ressourcen freigeben und Fenster schließen
cv2.destroyAllWindows()
Tipp

Sieh dir unsere Dokumentation zu Inferenzquellen an, wenn du den Typ der Bild-/Videoeingabe ändern möchtest.

Bewährte Vorgehensweisen bei der Verwendung von Raspberry Pi#

Es gibt einige bewährte Vorgehensweisen, mit denen du die Leistung von Raspberry Pi-Geräten maximieren kannst, auf denen YOLO26 läuft.

  1. Eine SSD verwenden

    Wenn du Raspberry Pi rund um die Uhr verwendest, empfiehlt sich eine SSD als Systemlaufwerk, da eine SD-Karte fortlaufende Schreibvorgänge nicht aushält und beschädigt werden kann. Dank des integrierten PCIe-Anschlusses des Raspberry Pi 5 kannst du jetzt SSDs über einen Adapter wie die NVMe Base für Raspberry Pi 5 anschließen.

  2. Ohne grafische Oberfläche flashen

    Beim Flashen von Raspberry Pi OS kannst du auf die Installation der Desktop-Umgebung verzichten (Raspberry Pi OS Lite). Dadurch sparst du etwas RAM auf dem Gerät und hast mehr Speicher für die Computer-Vision-Verarbeitung zur Verfügung.

  3. Raspberry Pi übertakten

    Wenn du bei der Ausführung von Ultralytics YOLO26-Modellen auf Raspberry Pi 5 eine leichte Leistungssteigerung erzielen möchtest, kannst du die CPU von ihrer Basisfrequenz von 2.4GHz auf 3.0GHz und die GPU von 800MHz auf 1GHz übertakten. Wird das System instabil oder stürzt ab, verringere die Übertaktungswerte schrittweise um jeweils 100MHz. Sorge für ausreichende Kühlung, da beim Übertakten mehr Wärme entsteht und es zu thermischer Drosselung kommen kann.

    a. Software aktualisieren

    sudo apt update && sudo apt dist-upgrade

    b. Öffnen, um die Konfigurationsdatei zu bearbeiten

    sudo nano /boot/firmware/config.txt

    c. Die folgenden Zeilen am Ende hinzufügen

    arm_freq=3000
    gpu_freq=1000
    force_turbo=1

    d. Mit CTRL + X und anschließend Y speichern und beenden, dann ENTER drücken

    e. Raspberry Pi neu starten

Nächste Schritte#

Du hast YOLO26 erfolgreich auf deinem Raspberry Pi eingerichtet. Als Nächstes kannst du den Predict-Modus erkunden, um weitere Inferenzoptionen kennenzulernen, den Export-Modus für zusätzliche Bereitstellungsformate nutzen oder den NVIDIA-Jetson-Leitfaden aufrufen, wenn du mehr Rechenleistung am Netzwerkrand benötigst. Die vollständige Dokumentation findest du in der Ultralytics-YOLO26-Dokumentation.

Danksagungen und Zitate#

Diese Anleitung wurde ursprünglich von Daan Eeltink für die Kashmir World Foundation erstellt, eine Organisation, die sich dem Einsatz von YOLO zum Schutz gefährdeter Arten widmet. Wir würdigen ihre Pionierarbeit und ihren Bildungsauftrag im Bereich der Objekterkennungstechnologien.

Weitere Informationen zu den Aktivitäten der Kashmir World Foundation findest du auf ihrer Website.

Häufig gestellte Fragen#

  • Führe die folgenden Schritte aus, um Ultralytics YOLO26 ohne Docker auf einem Raspberry Pi einzurichten:

    1. Paketliste aktualisieren und pip installieren:
      sudo apt update
      sudo apt install python3-pip -y
      pip install -U pip
    2. Ultralytics-Paket installieren:
      pip install ultralytics
    3. Gerät neu starten, um die Änderungen zu übernehmen:
      sudo reboot

    Eine ausführliche Anleitung findest du im Abschnitt Ohne Docker loslegen.

  • Das NCNN-Format von Ultralytics YOLO26 ist stark für mobile und eingebettete Plattformen optimiert und daher ideal für KI-Aufgaben auf Raspberry-Pi-Geräten. NCNN nutzt die ARM-Architektur, um die Inferenzleistung zu maximieren und im Vergleich zu anderen Formaten eine schnellere und effizientere Verarbeitung zu ermöglichen. Weitere Informationen zu den unterstützten Exportformaten findest du unter Optionen für den Modellexport.

  • Du kannst ein YOLO26-PyTorch-Modell entweder mit Python oder mit CLI-Befehlen ins NCNN-Format umwandeln:

    Beispiel
    from ultralytics import YOLO
    
    # Ein YOLO26n-PyTorch-Modell laden
    model = YOLO("yolo26n.pt")
    
    # Das Modell ins NCNN-Format exportieren
    model.export(format="ncnn")  # creates 'yolo26n_ncnn_model'
    
    # Das exportierte NCNN-Modell laden
    ncnn_model = YOLO("yolo26n_ncnn_model")
    
    # Inferenz ausführen
    results = ncnn_model("https://ultralytics.com/images/bus.jpg")

    Weitere Informationen findest du im Abschnitt NCNN auf Raspberry Pi verwenden.

  • Zu den wichtigsten Unterschieden gehören:

    • CPU: Der Raspberry Pi 4 verwendet ein Broadcom BCM2711, Cortex-A72 64-Bit-SoC, während der Raspberry Pi 5 ein Broadcom BCM2712, Cortex-A76 64-Bit-SoC verwendet.
    • Maximale CPU-Frequenz: Der Raspberry Pi 4 erreicht eine maximale Frequenz von 1.8GHz, während der Raspberry Pi 5 2.4GHz erreicht.
    • Speicher: Der Raspberry Pi 4 bietet bis zu 8 GB LPDDR4-3200-SDRAM, während der Raspberry Pi 5 mit LPDDR4X-4267-SDRAM ausgestattet ist, das in Varianten mit 2 GB, 4 GB, 8 GB und 16 GB verfügbar ist.

    Diese Verbesserungen tragen dazu bei, dass YOLO26-Modelle auf dem Raspberry Pi 5 bei Leistungsbenchmarks besser abschneiden als auf dem Raspberry Pi 4. Weitere Informationen findest du in der Tabelle Vergleich der Raspberry-Pi-Modelle.

  • Es gibt zwei Möglichkeiten, eine Raspberry-Pi-Kamera für die YOLO26-Inferenz einzurichten:

    1. Mit picamera2:

      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.pt")
      
      while True:
          frame = picam2.capture_array()
          results = model(frame)
          annotated_frame = results[0].plot()
          cv2.imshow("Camera", annotated_frame)
      
          if cv2.waitKey(1) == ord("q"):
              break
      
      cv2.destroyAllWindows()
    2. Mit einem TCP-Stream:

      rpicam-vid -n -t 0 --inline --listen -o tcp://127.0.0.1:8888
      from ultralytics import YOLO
      
      model = YOLO("yolo26n.pt")
      results = model("tcp://127.0.0.1:8888")

    Eine ausführliche Anleitung zur Einrichtung findest du im Abschnitt Inferenz mit Kamera.

Kommentare