YOLO lizenzieren
Anleitungen

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 SezerOnuralp Sezer11 Min. Lesezeit
Exportliste der Ultralytics Platform mit hervorgehobener NCNN-Zeile über MNN, dem empfohlenen Format für YOLO26 auf der CPU eines Raspberry Pi 5

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-FormatInferenzzeit (ms/Bild)mAP50-95(B), COCO128
PyTorch299.090.4760
ONNX125.990.4734
LiteRT123.300.4730
OpenVINO104.550.4734
MNN91.870.4749
NCNN67.030.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.

  1. Ultralytics in einer virtuellen Umgebung installieren. Das aktuelle Raspberry Pi OS verhindert die Installation von pip in 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
  1. 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-NCNN-Modell erkennt einen Bus und vier Personen auf einer Stadtstraße

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.

  1. 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.
  2. Live-Erkennung ausführen. picamera2 übergibt die Bilder direkt an das Modell. Das Fenster cv2.imshow erfordert 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()
  1. Auf deiner Platine benchmarken. yolo benchmark model=yolo26n.pt data=coco128.yaml imgsz=640 versucht 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 wie data=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:

  1. Klone arm/Optimized-Runtimes, wechsle in das Verzeichnis yolo26-raspberry-pi-5, befolge die Voraussetzungen und erstelle die Laufzeitumgebung mit make runtime.
  2. Führe make example-video aus, um Erkennungen in einem Beispielvideo zu sehen.
  3. Führe make ultralytics-benchmark aus, um die Arm-Laufzeitumgebung auf deiner Platine zu benchmarken.
  4. 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.
  5. 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=3000 und force_turbo=1 in /boot/firmware/config.txt von 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 imgsz bedeutet 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_model auf den Pi und lade ihn mit YOLO("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

Onuralp Sezer
Onuralp Sezer

Senior Machine-Learning-Engineer · Ultralytics

Onuralp Sezer ist Senior Machine Learning Engineer bei Ultralytics. Dort arbeitet er an der Weiterentwicklung von Computer-Vision-Technologien wie YOLO und trägt zur Open-Source-Entwicklung bei. Als langjähriger Organisator der Google Developer Group (GDG) und Mitwirkender an Open-Source-Projekten engagiert er sich als Redner zu den Themen maschinelles Lernen und Computer Vision in der Entwickler-Community. Zuvor hat er auch zum Fedora Project beigetragen.

Kommentare

Stelle eine Frage, teile deine Ergebnisse oder hilf anderen.

Lösungen entdecken

Computer Vision im Sport

Computer Vision im Sport

Entdecke, wie Ultralytics YOLO die Sportbildanalyse voranbringt – mit Spieler- und Ballverfolgung, Leistungsanalysen, Erkenntnissen für das Coaching und der Rehabilitation von Athleten.
Mehr erfahren
Computer Vision für Luftbilder

Computer Vision für Luftbilder

Verwandle Drohnen- und Luftbilder mit Ultralytics YOLO in Echtzeit-Erkenntnisse für Landwirtschaft, Aquakultur, Naturschutz und Geodatenanalyse.
Mehr erfahren
Computer Vision in der Luft- und Raumfahrt

Computer Vision in der Luft- und Raumfahrt

Setze Computer Vision in der Luft- und Raumfahrt mit Ultralytics YOLO ein – für Flugzeuginspektionen, die Erkennung von Fremdkörpern auf Start- und Landebahnen, den Bodenbetrieb am Flughafen und die Erkennung von Verbundwerkstofffehlern.
Mehr erfahren
Computer Vision im Sicherheitsbereich

Computer Vision im Sicherheitsbereich

Schütze jeden Standort mit Ultralytics YOLO-Modellen. Vision-KI ermöglicht die Überwachung von Grundstücksgrenzen, die Erkennung von Bedrohungen, die Kennzeichenerkennung und die Sicherheit am Arbeitsplatz.
Mehr erfahren
Computer Vision in der Robotik

Computer Vision in der Robotik

Mach Maschinen mit Ultralytics YOLO-Modellen leistungsfähiger. Vision-KI in der Robotik ermöglicht autonome Navigation, Wahrnehmung, Objektverfolgung und Steuerung in Echtzeit.
Mehr erfahren
Bildverarbeitung in der Logistik

Bildverarbeitung in der Logistik

Optimiere die Logistik mit Ultralytics YOLO-Modellen. Vision AI ermöglicht die Paketprüfung, Sortierung und Fahrzeugverfolgung sowie die Sicherheitsüberwachung von Lagerhäusern in Echtzeit.
Mehr erfahren
Bildverarbeitung im Einzelhandel

Bildverarbeitung im Einzelhandel

Gestalte den Einzelhandel mit Ultralytics YOLO-Modellen neu. Vision AI ermöglicht Bestandsverfolgung, Regalüberwachung und Warteschlangenmanagement und liefert bessere Einblicke in das Kundenverhalten.
Mehr erfahren
Bildverarbeitung im Gesundheitswesen

Bildverarbeitung im Gesundheitswesen

Entwickle Lösungen für das Gesundheitswesen mit Ultralytics YOLO-Modellen. Vision AI ermöglicht im Gesundheitswesen schnellere medizinische Bildgebung, bessere Diagnostik und die Überwachung von Patienten.
Mehr erfahren
Computer Vision in der Fertigung

Computer Vision in der Fertigung

Optimiere die Fertigung mit Ultralytics-YOLO-Modellen. Vision AI ermöglicht Qualitätskontrolle, Fehlererkennung, die Überprüfung der Einhaltung von Vorgaben zu persönlicher Schutzausrüstung und die Automatisierung von Montagelinien.
Mehr erfahren
Computer Vision in der Automobilbranche

Computer Vision in der Automobilbranche

Setze Computer Vision in der Automobilbranche mit Ultralytics-YOLO-Modellen ein. Vision AI verbessert die Verkehrssicherheit, Fahrerassistenz und Fahrzeugautomatisierung – für intelligentere Straßen.
Mehr erfahren
Computer Vision in der Landwirtschaft

Computer Vision in der Landwirtschaft

Setze mit Ultralytics YOLO-Modellen KI für Bildverarbeitung in der intelligenten Landwirtschaft ein. Ermögliche die Überwachung von Nutzpflanzen, die Verfolgung von Nutztieren und Präzisionslandwirtschaft für höhere und nachhaltigere Erträge.
Mehr erfahren

Lass uns gemeinsam die Zukunft der KI gestalten!

Starte deine Reise in die Zukunft des maschinellen Lernens