Suchen Sie nach einem Modell zur Implementierung der Posenschätzung? Ich kenne etwas, das Erkennung, Instanzsegmentierung, Posenschätzung und Klassifizierung durchführen kann, und das alles in Echtzeit. Ja, ich spreche vom YOLO26 von Ultralytika.

Es kann Sicherheitssysteme unterstützen oder fein abgestimmt werden, um auch kleinere Objekte zu erkennen. Sie fragen sich, wie Sie anfangen sollen? Keine Sorge, wir behandeln die Grundlagen von YOLO und lernen, mit dem Modell Inferenzen durchzuführen.

Hintergrundinformationen zu YOLO

YOLO (Du siehst nur einmal aus) ist eine Familie von Deep-Studying-Modellen, die für Laptop-Imaginative and prescient-Aufgaben verwendet werden; Die grundlegende Logik ist die Verwendung von Lokalisierung und Klassifizierung. Vereinfacht ausgedrückt erkennt die Lokalisierung Objekte und ermittelt deren Koordinaten. Anschließend sagt der Klassifikator die Klassenwahrscheinlichkeiten voraus und weist diesem Objekt die wahrscheinlichste Klasse zu. Die neueste Modellfamilie von YOLO ist YOLO26. Wie bereits erwähnt, können sie Folgendes leisten:

• Objekterkennung: Findet ein oder mehrere Objekte in einem Bild und sagt deren Klassenkonfidenzwert und Begrenzungsrahmen voraus. Dadurch erfahren Sie, um welches Objekt es sich handelt und wo es sich befindet.
• Einstufung: Weist das Bild einer von 1000 ImageNet-Kategorien zu. Als endgültige Vorhersage wird die Klasse mit der höchsten Wahrscheinlichkeit ausgewählt.
• Posenschätzung: Erkennt die 17 Schlüsselpunkte des menschlichen Körpers, die durch definiert werden COCO-Datensatz. Dazu gehören Punkte wie Nase, Schultern, Ellenbogen, Knie und Knöchel, um die Haltung jeder Individual einzuschätzen.
• Oriented Bounding Field (OBB)-Erkennung: Prognostiziert gedrehte Begrenzungsrahmen mithilfe von fünf Parametern. xyw h und θ. Dies ist besonders nützlich für Luft- und Satellitenbilder, bei denen Objekte selten perfekt ausgerichtet erscheinen.
• Instanzsegmentierung: Erzeugt für jedes erkannte Objekt eine Maske auf Pixelebene. Dies hilft dabei, einzelne Objekte zu trennen, selbst wenn sie derselben Klasse angehören.

Diese Modelle weisen eine höhere Genauigkeit und bessere Effizienz auf als die vorherigen Modellgenerationen.

Architektur

• Eingabebild: Die Größe des Eingabebilds wird geändert und normalisiert, bevor das Modell es verarbeitet.
• Rückgrat (C3k2 + CSP): Extrahiert Merkmale aus dem Bild wie Kanten, Texturen, Formen und Objektmuster.
• Hals (PAN-FPN): Führt die Fusion von P3, P4 und P5 durch. Dies trägt dazu bei, die Erkennung kleiner, mittlerer und großer Objekte zu verbessern.
• Erkennungskopf: Prognostiziert die Objektklassen, Begrenzungsrahmen und Konfidenzwerte mithilfe der zusammengeführten Function-Maps.
• Finish-to-Finish-Inferenz: Beseitigt einige Dinge, die in den vorherigen Generationen vorhanden waren, insbesondere DFL und NMS. Vereinfachung der Pipeline bei gleichzeitiger Verbesserung der Inferenzlatenz.
• Ausgabe: Objekterkennung, Segmentierung, Posenschätzung, Orientierungserkennung oder Klassifizierung.

Für den Kontext

• C3k2: Ein Function-Extraktionsblock, der kürzlich in YOLO-Modellen eingeführt wurde. Es verbessert das Function-Lernen mit weniger Parametern.
• PAN (Path Aggregation Community): Passt Merkmale auf niedriger und hoher Ebene in beide Richtungen und hilft so bei der präzisen Objekterkennung von Objekten unterschiedlicher Größe.
• FPN (Function Pyramid Community): Kombiniert Function-Maps aus mehreren Tiefen und hilft bei der Erkennung von Objekten in mehreren Maßstäben.
• P3 -> Function-Map mit hoher Auflösung, P4 -> Function-Map mit mittlerer Auflösung und P5 -> Function-Map mit niedriger Auflösung. Sie helfen dem Modell, kleine, mittlere und große Objekte zu erkennen.

Praktisch

Probieren wir YOLO26 mithilfe von Google Colab aus. Wir werden in erster Linie dieses Bild während der Schlussfolgerung verwenden:

Notiz: YOLO-Modelle erfordern keine Excessive-Finish-{Hardware}, sie können auch lokal in Jupyter Pocket book ausgeführt werden.

Installationen

!pip set up -q "ultralytics>=8.4.0" 

Hier wird „-q“ verwendet, um die Bibliothek und Abhängigkeiten zu installieren, ohne etwas anzuzeigen.

Hilfsfunktion definieren

from PIL import Picture 

# helper perform 
def present(consequence): 
    show(Picture.fromarray(consequence.plot()(..., ::-1)))

Dies wird zur Anzeige der Ergebnisse verwendet.

Objekterkennung

from ultralytics import YOLO 

IMAGE = "https://ultralytics.com/photographs/bus.jpg" 
mannequin = YOLO("yolo26n.pt") 
consequence = mannequin(IMAGE)(0) 

present(consequence)

Das Modell hat den Bus und die Personen erfolgreich erkannt.

Instanzsegmentierung

seg_model = YOLO("yolo26n-seg.pt") 
consequence = seg_model(IMAGE)(0) 
present(consequence)

Hier hat das Modell die Segmentierung durchgeführt, es hat die erkannten Objekte maskiert. Auch die Kantenerkennung sieht intestine aus.

Posen-/Schlüsselpunktschätzung

pose_model = YOLO("yolo26n-pose.pt") 

consequence = pose_model(IMAGE)(0) 

present(consequence)

Das Modell hat die Schlüsselpunkte des menschlichen Körpers für die Posenerkennung erfolgreich vorhergesagt.

Orientierte Begrenzungsrahmen

obb_model = YOLO("yolo26n-obb.pt") 
consequence = obb_model("https://ultralytics.com/photographs/boats.jpg")(0) 
present(consequence)

Dieses Modell kann gezielt Objekte in Luft-, High-Down- oder Satellitenbildern erkennen. Wie Sie sehen können, wurden die Schiffe im Bild sehr intestine erkannt.

Bildklassifizierung

cls_model = YOLO("yolo26n-cls.pt") 
consequence = cls_model(IMAGE)(0) 

for i in consequence.probs.top5: 
   print(f"{consequence.names(i):<25} {consequence.probs.information(i):.2%}")

Ausgabe:

Das Modell gibt die Wahrscheinlichkeiten von 1000 Klassen aus, hier hat der Klassifikator die Klasse als Kleinbus genau vorhergesagt.

Abschluss

Zusammenfassend haben Sie die Grundlagen von YOLO und YOLO26 kennengelernt, deren Architektur erkundet und in Google Colab Inferenzen zur Objekterkennung, Instanzsegmentierung, Posenschätzung, orientierten Begrenzungsrahmen und Bildklassifizierung durchgeführt. Mit seiner verbesserten Genauigkeit, Effizienz und Echtzeitleistung ist YOLO26 eine gute Wahl für eine Vielzahl von Laptop-Imaginative and prescient-Anwendungen.

Häufig gestellte Fragen

Willkommene Leser, die CV -Klasse ist wieder in der Sitzung! Wir haben zuvor 30+ untersucht Laptop Imaginative and prescient -Modelle Bisher bringt jeder in meinem vorherigen Weblog ihre eigenen einzigartigen Stärken auf den Tisch, von den schnellen Erkennungsfähigkeiten von Yolo bis zur transformativen Kraft von Imaginative and prescient Transformers (Vits). Heute stellen wir einen neuen Schüler in unser Klassenzimmer vor: rf-detr. Lesen Sie weiter, um alles über Roboflows RF-Detr zu wissen und wie es die Geschwindigkeit und Genauigkeit der Objekterkennung überbrückt.

Was ist Roboflows RF-Detr?

RF-Detr ist ein Echtzeit-Transformator-basiertes basiert Objekterkennung Modell, das über 60 Karte im Coco -Datensatz erreicht und eine beeindruckende Leistung zeigt. Natürlich sind wir neugierig: Wird RF-Detr in der Lage sein, Yolos Geschwindigkeit zu erreichen? Kann es sich an verschiedene Aufgaben anpassen, denen wir in der realen Welt begegnen?

Das sind wir hier, um zu erkunden. In diesem Artikel werden die Kernfunktionen von RF-DETRT, seine Echtzeitfähigkeiten, die Anpassungsfähigkeit der Domänen und die Verfügbarkeit von Open-Supply-Funktionen aufschlüsseln und sehen, wie es sich neben anderen Modellen entwickelt. Lassen Sie uns eintauchen und sehen, ob dieser Newcomer das Zeug dazu hat, sich in realen Anwendungen zu übertreffen!

Warum ist RF-Detr ein Sport Changer?

• Hervorragende Leistung sowohl für Coco- als auch für RF100-VL-Benchmarks.
• Entwickelt, um sowohl neuartige Domänen als auch Hochgeschwindigkeitsumgebungen zu handhaben, wodurch sie perfekt für Anwendungen von Kanten und Latenz.
• Prime 2 in allen Kategorien im Vergleich zu Echtzeit-Coco-SOTA-Transformatormodellen (wie D-High-quality und LW-Detr) und SOTA YOLO CNN-Modellen (wie Yolov11 und Yolov8).

Modellleistung und neue Benchmarks

Objekterkennungsmodelle werden zunehmend herausgefordert, ihren Wert über nur Coco zu beweisen – ein Datensatz, der zwar historisch kritisch ist, aber seitdem nicht mehr aktualisiert wurde 2017. Infolgedessen zeigen viele Modelle nur marginale Verbesserungen an Coco und wenden sich an andere Datensätze (z. B. LVIS, Objects365), um die Generalisierbarkeit zu demonstrieren.

RF100-VL: Roboflows neuer Benchmark, der rund 100 verschiedene Datensätze (Luftbilder, industrielle Inspektionen usw.) von 500.000 über das Roboflow -Universum sammelt. Dieser Benchmark betont Area -AnpassungsfähigkeitEin kritischer Faktor für reale Anwendungsfälle, in denen Daten drastisch von den gängigen Objekten von Coco unterscheiden können.

Warum wir RF100-VL brauchen

• Actual World Vielfalt: RF100-VL enthält Datensätze, die Szenarien wie Laborbildgebung, industrielle Inspektion und Luftfotografie abdecken, um zu testen, wie intestine Modelle externe traditionelle Benchmarks durchführen.
• Verschiedene Benchmarks: Durch die Standardisierung des Evaluierungsprozesses ermöglicht RF100-VL direkte Vergleiche zwischen verschiedenen Architekturen, einschließlich transformatorischer Modelle und CNN-basierter YOLO-Varianten.
• Anpassungsfähigkeit gegenüber inkrementellen Gewinnen: Bei der Sättigung von Kokos wird die Anpassungsfähigkeit der Domänen neben Latenz und Rohgenauigkeit zu einer erstklassigen Überlegung.

In der obigen Tabelle können wir sehen, wie sich RF-DETRT gegen andere Echtzeit-Objekterkennungsmodelle stapelt:

• Coco: Die Basisvariante von RF-Detr erreicht 53,3 Karte und platziert sie mit anderen Echtzeitmodellen.
• RF100-VL: RF-Detr übertrifft andere Modelle (86.7 MAP) und zeigt die außergewöhnliche Domänenanpassungsfähigkeit.
• Geschwindigkeit: Bei einer T4-GPU 6,0 ms/IMG übertrifft RF-Detr-Matches oder übertrifft konkurrierende Modelle, wenn sie in der Nachbearbeitung berücksichtigt werden.

Notiz: Ab sofort sind Code und Checkpoint für RF-DETRT-Massive und RF-Detr-Base verfügbar.

Die Gesamtlatenz ist auch wichtig

• NMS in Yolo: YOLO-Modelle verwenden die Nicht-Most-Unterdrückung (NMS), um Begrenzungsboxen zu verfeinern. Dieser Schritt kann die Schlussfolgerung geringfügig verlangsamen, insbesondere wenn es viele Objekte im Rahmen gibt.

• Kein zusätzlicher Schritt in DELS: RF-Detr folgt dem Ansatz der DETR-Familie und vermeidet die Notwendigkeit eines zusätzlichen NMS-Schritts zur Verfeinerung des Begrenzungsboxen.

Latenz gegen Genauigkeit auf Coco

• Horizontale Achse (Latenz): Gemessen in Millisekunden (MS) professional Bild auf einer Nvidia T4 -GPU unter Verwendung von Tensorrt10 FP16. Niedriger Latenz bedeutet hier eine schnellere Folgerung
• Vertikale Achse (MAP @0,50: 0,95): Die mittlere durchschnittliche Präzision am Microsoft Coco -Benchmark, ein Standardmaß für die Erkennungsgenauigkeit. Eine höhere Karte zeigt eine bessere Leistung an.

In diesem Diagramm zeigt RF-DETRT die Wettbewerbsgenauigkeit mit YOLO-Modellen und hält die Latenz im gleichen Bereich. RF-DETRT übertrifft die 60-Karte-Schwelle, sodass es die zuerst dokumentiert Echtzeitmodell, um dieses Leistungsniveau auf Coco zu erreichen.

Area-Anpassungsfähigkeit auf RF100-VL

Hier, Rf-detr fällt auf, indem er die höchste Karte auf RF100-VL erreicht, was auf eine starke Anpassungsfähigkeit hinsichtlich unterschiedlicher Domänen hinweist. Dies deutet darauf hin, dass RF-Detr nicht nur auf Coco wettbewerbsfähig ist, sondern auch bei der Behandlung von Datensätzen mit realen Welt, bei denen domänenspezifische Objekte und Bedingungen sich erheblich von gemeinsamen Objekten im Coco unterscheiden können.

Potenzielle Rangfolge von RF-DETRT

Basierend auf den Leistungsmetriken aus der Roboflow-Rangliste zeigt RF-DETRT konkurrenzfähige Ergebnisse sowohl bei Genauigkeit als auch in Effizienz.

• RF-DETRT-Massive (128m Parames) würde Rang 1stübertreffen alle vorhandenen Modelle mit einer geschätzten Karte 50:95 oben 60.5was es zum genauesten Modell auf der Rangliste macht.
• RF-DETRT-Base (29M Parames) würde Rang um den 4. Platzeng mit Modellen wie möglich konkurrieren DEIM-D-High-quality-X (61,7 m Parames, 0,548 Karte 50:95) Und D-High-quality-X (61,6 m Parames, 0,541 Karte 50:95). Trotz seiner niedrigeren Parameterzahl behält es einen starken Genauigkeitsvorteil.

In diesem Rang wird die Effizienz von RF-DETR weiter hervorgehoben und eine hohe Leistung mit optimierter Latenz liefert und gleichzeitig eine kleinere Modellgröße im Vergleich zu einigen Konkurrenten beibehalten.

RF-DETRT-Architekturübersicht

Historisch, CNN-basierte YOLO-Modelle haben das Paket in Echtzeit-Objekterkennung geführt. Allerdings profitieren CNNs allein nicht immer von großem Maßstab vor dem Coaching, was beim maschinellen Lernen zunehmend zentraler ist.

Transformatoren Excel mit großem Maßstab vor dem Coaching, battle aber oft zu sperrig (schwer) oder für Echtzeitanwendungen. Jüngste Arbeiten zeigen jedoch, dass DETR-basierte Modelle mit Yolos Geschwindigkeit übereinstimmen können, wenn wir betrachten, dass der Nachbearbeitungs-Overhead-Yolo Yolo erfordert.

Der Hybridvorteil von RF-DETRT

• Vorausgebildes Dinov2-Rückgrat: Dies hilft dem Modelltransferwissen aus großem Maßstab vor dem Coaching und erhöht die Leistung in neuartigen oder unterschiedlichen Domänen. RF-Detr kombiniert LW-Detr mit einem vorgebildeten Dinov2-Rückgrat und bietet außergewöhnliche Domänenanpassungsfähigkeit und erhebliche Vorteile von der Vorausbildung.
• Einzelgipfel-Function-Extraktion: Während deformierbares DEFTR die multi-gesellschaftliche Aufmerksamkeit nutzt, vereinfacht RF-Detr die Merkmalextraktion zu einer einzelnen Skala und schlägt ein Gleichgewicht zwischen Geschwindigkeit und Leistung.
• Mehrauflösungstraining: RF-Detr kann bei mehreren Auflösungen geschult werden, sodass Sie den besten Kompromiss zwischen Geschwindigkeit und Genauigkeit bei Inferenz auswählen können, ohne das Modell umzusetzen.

Lesen Sie dies für weitere Informationen. Lesen Sie dies. Lesen Sie dies Forschungspapier.

Wie benutze ich RF-Detr?

Aufgabe 1: Verwenden Sie es zur Objekterkennung in einem Bild

Installieren Sie RF-Detr über:

!pip set up rfdetr

Sie können dann einen vorgeborenen Kontrollpunkt (auf Coco ausgebildet) für sofortige Verwendung in Ihrer Anwendung laden:

import io

import requests

import supervision as sv

from PIL import Picture

from rfdetr import RFDETRBase

mannequin = RFDETRBase()

url = "https://media.roboflow.com/notebooks/examples/dog-2.jpeg"

picture = Picture.open(io.BytesIO(requests.get(url).content material))

detections = mannequin.predict(picture, threshold=0.5)

annotated_image = picture.copy()

annotated_image = sv.BoxAnnotator().annotate(annotated_image, detections)

annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections)

sv.plot_image(annotated_image)

Aufgabe 2: Verwenden Sie es zur Objekterkennung in einem Video

Ich werde Ihnen meinen Github -Repository -Hyperlink zur Verfügung stellen, damit Sie das Modell selbst frei implementieren können. Folgen Sie einfach den Anweisungen von Readme.md, um den Code auszuführen.

Github Hyperlink.

Code:

import cv2

import numpy as np

import json

from rfdetr import RFDETRBase

# Load the mannequin

mannequin = RFDETRBase()

# Learn the courses.json file and retailer class names in a dictionary

with open('courses.json', 'r', encoding='utf-8') as file:

    class_names = json.load(file)

# Open the video file

cap = cv2.VideoCapture('strolling.mp4')  # https://www.pexels.com/video/video-of-people-walking-855564/

# Create the output video

fourcc = cv2.VideoWriter_fourcc(*'XVID')

out = cv2.VideoWriter('output.mp4', fourcc, 20.0, (960, 540))

# For reside video streaming:

# cap = cv2.VideoCapture(0)  # 0 refers back to the default digicam

whereas True:

    # Learn a body

    ret, body = cap.learn()

    if not ret:

        break  # Exit the loop when the video ends

    # Carry out object detection

    detections = mannequin.predict(body, threshold=0.5)

    # Mark the detected objects

    for i, field in enumerate(detections.xyxy):

        x1, y1, x2, y2 = map(int, field)

        class_id = int(detections.class_id(i))

        # Get the category identify utilizing class_id

        label = class_names.get(str(class_id), "Unknown")

        confidence = detections.confidence(i)

        # Draw the bounding field (coloured and thick)

        coloration = (255, 255, 255)  # White coloration

        thickness = 7  # Thickness

        cv2.rectangle(body, (x1, y1), (x2, y2), coloration, thickness)

        # Show the label and confidence rating (in white coloration and readable font)

        textual content = f"{label} ({confidence:.2f})"

        font = cv2.FONT_HERSHEY_SIMPLEX

        font_scale = 2

        font_thickness = 7

        text_size = cv2.getTextSize(textual content, font, font_scale, font_thickness)(0)

        text_x = x1

        text_y = y1 - 10

        cv2.putText(body, textual content, (text_x, text_y), font, font_scale, (0, 0, 255), font_thickness, cv2.LINE_AA)

    # Show the outcomes

    resized_frame = cv2.resize(body, (960, 540))

    cv2.imshow('Labeled Video', resized_frame)

    # Save the output

    out.write(resized_frame)

    # Exit when 'q' secret's pressed

    if cv2.waitKey(1) & 0xFF == ord('q'):

        break

# Launch sources

cap.launch()

out.launch()  # Launch the output video

cv2.destroyAllWindows()

Ausgabe:

Feinabstimmung für benutzerdefinierte Datensätze

In der Feinabstimmung leuchtet RF-Detr wirklich, insbesondere wenn Sie mit Nischen- oder kleineren Datensätzen arbeiten:

• Verwenden Sie das CoCo -Format: Organisieren Sie Ihren Datensatz in den Zug/, gültig/und testen Sie/Verzeichnisse, jeweils mit seinen eigenen _annotations.coco.json.
• Nutzen Sie Colab: Das Roboflow -Group bietet ein detailliertes Colab Pocket book (bereitgestellt vom Roboflow -Group), um Sie durch das Coaching in Ihrem eigenen Datensatz zu führen.

from rfdetr import RFDETRBase

mannequin = RFDETRBase()

mannequin.prepare(

    dataset_dir="<DATASET_PATH>",

    epochs=10,

    batch_size=4,

    grad_accum_steps=4,

    lr=1e-4

)

Während des Trainings wird RF-Detr produzieren:

• Regelmäßige Gewichte: Standardmodell -Kontrollpunkte.
• EMA -Gewichte: Eine exponentielle gleitende Durchschnittsversion des Modells, die häufig eine stabilere Leistung erbringt.

Wie trainiere ich RF-Detr in einem benutzerdefinierten Datensatz?

Zum Beispiel hat das Roboflow-Group einen Mahjong-Fliesenerkennungsdatensatz verwendet, der Teil des RF100-VL-Benchmarks, der über 2.000 Bilder enthält. In diesem Handbuch wird angezeigt, wie Sie den Datensatz herunterladen, die erforderlichen Instruments installieren und das Modell auf Ihren benutzerdefinierten Daten optimieren.

Die resultierende Anzeige sollte die Grundwahrheit auf der einen Seite und die Erkennungen des Modells auf der anderen Seite zeigen. In unserem Beispiel identifiziert RF-DETRT die meisten Mahjong-Fliesen korrekt, wobei nur geringfügige Fehlverhandlungen durch weiteres Coaching verbessert werden können.

Wichtiger Hinweis:

• Instanzsegmentierung: RF-Detr unterstützt derzeit keine Instanzsegmentierung, wie in Open Supply Lead von Roboflow festgestellt wird. Piotr Skalski.
• POSE -Schätzung: Die Unterstützung der Pose -Schätzung steht ebenfalls am Horizont und wird in Kürze kommen.

Endgültiges Urteil und potenzielle Kante über andere Lebenslaufmodelle

RF-Detr ist eines der besten Echtzeit-DETR-basierten Modelle und bietet ein starkes Gleichgewicht zwischen Genauigkeit, Geschwindigkeit und Anpassungsfähigkeit der Domänen. Wenn Sie einen in Echtzeit transformator basierenden Detektor benötigen, der die Nachbearbeitungsaufwand vermeidet und über Coco verallgemeinert wird, ist dies ein Prime-Anwärter. Yolov8 hält jedoch für einige Anwendungen immer noch eine Kante an der Rohgeschwindigkeit.

Wobei RF-Detr andere CV-Modelle übertreffen kann:

• Spezielle Domänen und benutzerdefinierte Datensätze: RF-Detr zeichnet sich in der Domänenanpassung aus (86.7 Karte auf RF100-VL), es very best für medizinische Bildgebung, Industriefehlererkennung und autonome Navigation Wo mit Coco-ausgebildete Modelle kämpfen.
• Anwendungen mit niedriger Latenz: Da es erfordert keine NMSes kann sein schneller als Yolo In Szenarien, in denen Nachbearbeitung Overhead hinzufügt, wie z. Drohnenbasierte Erkennung, Videoanalyse oder Robotik.

• Transformator-basierte Zukunftssicherung: Im Gegensatz zu CNN-basierten Detektoren (Yolo, schnellerer R-CNN) profitiert RF-DETR von Vorteilen von Selbstbekämpfung und groß anwas es besser für geeignet ist für Multi-Objekt-Argumentation, Verschluss und Verallgemeinerung in unsichtbare Umgebungen.
• Kanten -AI & eingebettete Geräte: Rf-detr’s Inferenzzeit von 6,0 ms/IMG auf einer T4 -GPU schlägt vor, es könnte ein starker Kandidat für sein Echtzeit-Edge-Bereitstellung wo herkömmliche DETR -Modelle zu langsam sind.

Eine Runde des Applaus für das Roboflow ML -Group – Peter Robicheaux, James Gallagher, Joseph Nelson, Isaac Robinson.

Peter RobicheauxAnwesend James GallagherAnwesend Joseph NelsonAnwesend Isaac Robinson. (20. März 2025). RF-Detr: Ein SOTA-Echtzeit-Objekterkennungsmodell. Roboflow-Weblog: https://weblog.roboflow.com/rf-detr/

Abschluss

RFOFLOW-RF-DETRT stellt eine neue Era von Echtzeit-Objekterkennung dar, das ausbalanciert wird hohe GenauigkeitAnwesend Area -AnpassungsfähigkeitUnd geringe Latenz in einem einzigen Modell. Unabhängig davon, ob Sie ein modernes Robotiksystem erstellen oder auf ressourcenbegrenzten Kantengeräten eingesetzt werden, bietet RF-Detr eine vielseitige und zukunftssichere Lösung.

Was denkst du? Lassen Sie mich im Kommentarbereich wissen.

Objekterkennung ist von zentraler Bedeutung künstliche Intelligenzund dient als Rückgrat für zahlreiche hochmoderne Anwendungen. Von autonomen Fahrzeugen und Überwachungssystemen bis hin zu medizinischer Bildgebung und erweiterter Realität – die Fähigkeit, Objekte in Bildern und Movies zu identifizieren und zu lokalisieren, verändert Industrien weltweit. Die Objekterkennungs-API von TensorFlow, ein leistungsstarkes und vielseitiges Software, vereinfacht die Erstellung robuster Objekterkennungsmodelle. Durch die Nutzung dieser API können Entwickler benutzerdefinierte Modelle trainieren, die auf spezifische Anforderungen zugeschnitten sind, wodurch die Entwicklungszeit und -komplexität erheblich reduziert wird.

In diesem Leitfaden untersuchen wir Schritt für Schritt den Prozess des Trainierens eines Objekterkennungsmodells mit TensorFlow und konzentrieren uns dabei auf die Integration von Datensätzen aus Roboflow-Universumein umfangreiches Repository mit kommentierten Datensätzen, das die KI-Entwicklung beschleunigen soll.

Lernziele

• Erfahren Sie, wie Sie es einrichten und konfigurieren TensorFlow’s Objekterkennungs-API-Umgebung für effizientes Modelltraining.
• Erfahren Sie, wie Sie mithilfe des TFRecord-Codecs Datensätze für das Coaching vorbereiten und vorverarbeiten.
• Erwerben Sie Fachwissen bei der Auswahl und Anpassung eines vorab trainierten Objekterkennungsmodells für spezifische Anforderungen.
• Erfahren Sie, wie Sie Pipeline-Konfigurationsdateien anpassen und Modellparameter optimieren, um die Leistung zu optimieren.
• Beherrschen Sie den Trainingsprozess, einschließlich der Handhabung von Kontrollpunkten und der Bewertung der Modellleistung während des Trainings.
• Erfahren Sie, wie Sie das trainierte Modell zur Inferenz und Bereitstellung in realen Anwendungen exportieren.

Dieser Artikel wurde im Rahmen der veröffentlicht Knowledge Science-Blogathon.

Schrittweise Implementierung der Objekterkennung mit TensorFlow

In diesem Abschnitt führen wir Sie Schritt für Schritt durch die Implementierung der Objekterkennung mit TensorFlow und begleiten Sie von der Einrichtung bis zur Bereitstellung.

Schritt 1: Einrichten der Umgebung

Die TensorFlow Object Detection API erfordert verschiedene Abhängigkeiten. Beginnen Sie mit dem Klonen des TensorFlow-Modellrepositorys:

# Clone the tensorflow fashions repository from GitHub
!pip uninstall Cython -y # Non permanent repair for "No module named 'object_detection'" error
!git clone --depth 1 https://github.com/tensorflow/fashions

• Cython deinstallieren: Dieser Schritt stellt sicher, dass es während des Setups zu keinen Konflikten mit der Cython-Bibliothek kommt.
• Klonen Sie das TensorFlow-Modell-Repository: Dieses Repository enthält die offiziellen Modelle von TensorFlow, einschließlich der Objekterkennungs-API.

Kopieren Sie die Setup-Dateien und ändern Sie die Datei setup.py

# Copy setup recordsdata into fashions/analysis folder
%%bash
cd fashions/analysis/
protoc object_detection/protos/*.proto --python_out=.
#cp object_detection/packages/tf2/setup.py .

# Modify setup.py file to put in the tf-models-official repository focused at TF v2.8.0
import re
with open('/content material/fashions/analysis/object_detection/packages/tf2/setup.py') as f:
    s = f.learn()

with open('/content material/fashions/analysis/setup.py', 'w') as f:
    # Set fine_tune_checkpoint path
    s = re.sub('tf-models-official>=2.5.1',
               'tf-models-official==2.8.0', s)
    f.write(s)

Warum ist das notwendig?

• Zusammenstellung der Protokollpuffer: Die Objekterkennungs-API verwendet .proto-Dateien, um Modellkonfigurationen und Datenstrukturen zu definieren. Diese müssen in Python-Code kompiliert werden, damit sie funktionieren.
• Kompatibilität der Abhängigkeitsversion: TensorFlow und seine Abhängigkeiten entwickeln sich weiter. Die Verwendung von tf-models-official>=2.5.1 kann versehentlich eine inkompatible Model für TensorFlow v2.8.0 installieren.
• Durch die explizite Einstellung von tf-models-official==2.8.0 werden mögliche Versionskonflikte vermieden und die Stabilität gewährleistet.

Abhängigkeitsbibliotheken installieren

TensorFlow-Modelle basieren häufig auf bestimmten Bibliotheksversionen. Durch die Korrektur der TensorFlow-Model wird eine reibungslose Integration gewährleistet.

# Set up the Object Detection API 

# Have to do a brief repair with PyYAML as a result of Colab is not capable of set up PyYAML v5.4.1
!pip set up pyyaml==5.3
!pip set up /content material/fashions/analysis/

# Have to downgrade to TF v2.8.0 as a result of Colab compatibility bug with TF v2.10 (as of 10/03/22)
!pip set up tensorflow==2.8.0

# Set up CUDA model 11.0 (to keep up compatibility with TF v2.8.0)
!pip set up tensorflow_io==0.23.1
!wget https://developer.obtain.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin
!mv cuda-ubuntu1804.pin /and many others/apt/preferences.d/cuda-repository-pin-600
!wget http://developer.obtain.nvidia.com/compute/cuda/11.0.2/local_installers/cuda-repo-ubuntu1804-11-0-local_11.0.2-450.51.05-1_amd64.deb
!dpkg -i cuda-repo-ubuntu1804-11-0-local_11.0.2-450.51.05-1_amd64.deb
!apt-key add /var/cuda-repo-ubuntu1804-11-0-local/7fa2af80.pub
!apt-get replace && sudo apt-get set up cuda-toolkit-11-0
!export LD_LIBRARY_PATH=/usr/native/cuda-11.0/lib64:$LD_LIBRARY_PATH

Während Sie diesen Block ausführen, müssen Sie die Sitzungen erneut starten und diesen Codeblock erneut ausführen, um alle Abhängigkeiten erfolgreich zu installieren. Dadurch werden alle Abhängigkeiten erfolgreich installiert.

Installieren einer geeigneten Model der Protobuf-Bibliothek zur Lösung von Abhängigkeitsproblemen

!pip set up protobuf==3.20.1

Schritt 2: Umgebung und Installationen überprüfen

Um zu bestätigen, dass die Set up funktioniert, führen Sie den folgenden Check durch:

# Run Mannequin Bulider Check file, simply to confirm every little thing's working correctly
!python /content material/fashions/analysis/object_detection/builders/model_builder_tf2_test.py

Wenn keine Fehler angezeigt werden, ist Ihre Einrichtung abgeschlossen. Nun haben wir die Einrichtung erfolgreich abgeschlossen.

Schritt 3: Bereiten Sie die Trainingsdaten vor

Für dieses Tutorial verwenden wir die „Personenerkennung“ Datensatz von Roboflow-Universum. Befolgen Sie diese Schritte, um es vorzubereiten:

Besuchen Sie die Datensatzseite:

Verzweigen Sie den Datensatz in Ihren Arbeitsbereich, um ihn für die Anpassung zugänglich zu machen.

Generieren Sie eine Model des Datensatzes, um seine Vorverarbeitungskonfigurationen wie Erweiterung und Größenänderung abzuschließen.

Laden Sie es jetzt im TFRecord-Format herunter, einem Binärformat, das für TensorFlow-Workflows optimiert ist. TFRecord speichert Daten effizient und ermöglicht TensorFlow das Lesen großer Datensätze während des Trainings mit minimalem Overhead.

Platzieren Sie nach dem Herunterladen die Datensatzdateien in Ihrem Google Drive, mounten Sie Ihren Code auf Ihrem Laufwerk und laden Sie diese Dateien in den Code, um ihn zu verwenden.

from google.colab import drive
drive.mount('/content material/gdrive')


train_record_fname="/content material/gdrive/MyDrive/photographs/prepare/prepare.tfrecord"
val_record_fname="/content material/gdrive/MyDrive/photographs/take a look at/take a look at.tfrecord"
label_map_pbtxt_fname="/content material/gdrive/MyDrive/photographs/label_map.pbtxt"

Schritt 4: Richten Sie die Trainingskonfiguration ein

Jetzt ist es an der Zeit, die Konfiguration für das Objekterkennungsmodell einzurichten. Für dieses Beispiel verwenden wir das Modell „efficientdet-d0“. Sie können aus anderen Modellen wie ssd-mobilenet-v2 oder ssd-mobilenet-v2-fpnlite-320 wählen, aber in diesem Leitfaden konzentrieren wir uns aufefficientdet-d0.

# Change the chosen_model variable to deploy totally different fashions obtainable within the TF2 object detection zoo
chosen_model="efficientdet-d0"

MODELS_CONFIG = {
    'ssd-mobilenet-v2': {
        'model_name': 'ssd_mobilenet_v2_320x320_coco17_tpu-8',
        'base_pipeline_file': 'ssd_mobilenet_v2_320x320_coco17_tpu-8.config',
        'pretrained_checkpoint': 'ssd_mobilenet_v2_320x320_coco17_tpu-8.tar.gz',
    },
    'efficientdet-d0': {
        'model_name': 'efficientdet_d0_coco17_tpu-32',
        'base_pipeline_file': 'ssd_efficientdet_d0_512x512_coco17_tpu-8.config',
        'pretrained_checkpoint': 'efficientdet_d0_coco17_tpu-32.tar.gz',
    },
    'ssd-mobilenet-v2-fpnlite-320': {
        'model_name': 'ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8',
        'base_pipeline_file': 'ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.config',
        'pretrained_checkpoint': 'ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz',
    },
}

model_name = MODELS_CONFIG(chosen_model)('model_name')
pretrained_checkpoint = MODELS_CONFIG(chosen_model)('pretrained_checkpoint')
base_pipeline_file = MODELS_CONFIG(chosen_model)('base_pipeline_file')

Anschließend laden wir die vorab trainierten Gewichte und die entsprechende Konfigurationsdatei für das gewählte Modell herunter:

# Create "mymodel" folder for holding pre-trained weights and configuration recordsdata
%mkdir /content material/fashions/mymodel/
%cd /content material/fashions/mymodel/

# Obtain pre-trained mannequin weights
import tarfile
download_tar="http://obtain.tensorflow.org/fashions/object_detection/tf2/20200711/" + pretrained_checkpoint
!wget {download_tar}
tar = tarfile.open(pretrained_checkpoint)
tar.extractall()
tar.shut()

# Obtain coaching configuration file for mannequin
download_config = 'https://uncooked.githubusercontent.com/tensorflow/fashions/grasp/analysis/object_detection/configs/tf2/' + base_pipeline_file
!wget {download_config}

Danach richten wir die Anzahl der Trainingsschritte und die Batchgröße basierend auf dem ausgewählten Modell ein:

# Set coaching parameters for the mannequin
num_steps = 4000

if chosen_model == 'efficientdet-d0':
  batch_size = 8
else:
  batch_size = 8

Sie können „num_steps“ und „batch_size“ entsprechend Ihren Anforderungen erhöhen und verringern.

Schritt 5: Ändern Sie die Pipeline-Konfigurationsdatei

Wir müssen die Datei „pipeline.config“ mit den Pfaden zu unseren Datensatz- und Modellparametern anpassen. Die Datei „pipeline.config“ enthält verschiedene Konfigurationen wie die Stapelgröße, die Anzahl der Klassen und Prüfpunkte zur Feinabstimmung. Wir nehmen diese Änderungen vor, indem wir die Vorlage lesen und die relevanten Felder ersetzen:

# Set file areas and get variety of courses for config file
pipeline_fname="/content material/fashions/mymodel/" + base_pipeline_file
fine_tune_checkpoint="/content material/fashions/mymodel/" + model_name + '/checkpoint/ckpt-0'

def get_num_classes(pbtxt_fname):
    from object_detection.utils import label_map_util
    label_map = label_map_util.load_labelmap(pbtxt_fname)
    classes = label_map_util.convert_label_map_to_categories(
        label_map, max_num_classes=90, use_display_name=True)
    category_index = label_map_util.create_category_index(classes)
    return len(category_index.keys())
num_classes = get_num_classes(label_map_pbtxt_fname)
print('Whole courses:', num_classes)

# Create customized configuration file by writing the dataset, mannequin checkpoint, and coaching parameters into the bottom pipeline file
import re

%cd /content material/fashions/mymodel
print('writing customized configuration file')

with open(pipeline_fname) as f:
    s = f.learn()
with open('pipeline_file.config', 'w') as f:

    # Set fine_tune_checkpoint path
    s = re.sub('fine_tune_checkpoint: ".*?"',
               'fine_tune_checkpoint: "{}"'.format(fine_tune_checkpoint), s)

    # Set tfrecord recordsdata for prepare and take a look at datasets
    s = re.sub(
        '(input_path: ".*?)(PATH_TO_BE_CONFIGURED/prepare)(.*?")', 'input_path: "{}"'.format(train_record_fname), s)
    s = re.sub(
        '(input_path: ".*?)(PATH_TO_BE_CONFIGURED/val)(.*?")', 'input_path: "{}"'.format(val_record_fname), s)

    # Set label_map_path
    s = re.sub(
        'label_map_path: ".*?"', 'label_map_path: "{}"'.format(label_map_pbtxt_fname), s)

    # Set batch_size
    s = re.sub('batch_size: (0-9)+',
               'batch_size: {}'.format(batch_size), s)

    # Set coaching steps, num_steps
    s = re.sub('num_steps: (0-9)+',
               'num_steps: {}'.format(num_steps), s)

    # Set variety of courses num_classes
    s = re.sub('num_classes: (0-9)+',
               'num_classes: {}'.format(num_classes), s)

    # Change fine-tune checkpoint kind from "classification" to "detection"
    s = re.sub(
        'fine_tune_checkpoint_type: "classification"', 'fine_tune_checkpoint_type: "{}"'.format('detection'), s)

    # If utilizing ssd-mobilenet-v2, scale back studying charge (as a result of it is too excessive within the default config file)
    if chosen_model == 'ssd-mobilenet-v2':
      s = re.sub('learning_rate_base: .8',
                 'learning_rate_base: .08', s)

      s = re.sub('warmup_learning_rate: 0.13333',
                 'warmup_learning_rate: .026666', s)

    # If utilizing efficientdet-d0, use fixed_shape_resizer as an alternative of keep_aspect_ratio_resizer (as a result of it is not supported by TFLite)
    if chosen_model == 'efficientdet-d0':
      s = re.sub('keep_aspect_ratio_resizer', 'fixed_shape_resizer', s)
      s = re.sub('pad_to_max_dimension: true', '', s)
      s = re.sub('min_dimension', 'peak', s)
      s = re.sub('max_dimension', 'width', s)

    f.write(s)


# (Optionally available) Show the customized configuration file's contents
!cat /content material/fashions/mymodel/pipeline_file.config

# Set the trail to the customized config file and the listing to retailer coaching checkpoints in
pipeline_file="/content material/fashions/mymodel/pipeline_file.config"
model_dir="/content material/coaching/"

Schritt 6: Trainieren Sie das Modell

Jetzt können wir das Modell mithilfe der benutzerdefinierten Pipeline-Konfigurationsdatei trainieren. Das Trainingsskript speichert Prüfpunkte, mit denen Sie die Leistung Ihres Modells bewerten können:

# Run coaching!
!python /content material/fashions/analysis/object_detection/model_main_tf2.py 
    --pipeline_config_path={pipeline_file} 
    --model_dir={model_dir} 
    --alsologtostderr 
    --num_train_steps={num_steps} 
    --sample_1_of_n_eval_examples=1

Schritt 7: Speichern Sie das trainierte Modell

Nach Abschluss des Trainings exportieren wir das trainierte Modell, damit es für Inferenzen verwendet werden kann. Wir verwenden das Skript exporter_main_v2.py, um das Modell zu exportieren:

!python /content material/fashions/analysis/object_detection/exporter_main_v2.py 
    --input_type image_tensor 
    --pipeline_config_path {pipeline_file} 
    --trained_checkpoint_dir {model_dir} 
    --output_directory /content material/exported_model

Zum Schluss komprimieren wir das exportierte Modell zum einfachen Herunterladen in eine ZIP-Datei. Anschließend können Sie die ZIP-Datei mit Ihrem trainierten Modell herunterladen:

import shutil
# Path to the exported mannequin folder
exported_model_path="/content material/exported_model"

# Path the place the zip file might be saved
zip_file_path="/content material/exported_model.zip"

# Create a zipper file of the exported mannequin folder
shutil.make_archive(zip_file_path.exchange('.zip', ''), 'zip', exported_model_path)

# Obtain the zip file utilizing Google Colab's file obtain utility
from google.colab import recordsdata
recordsdata.obtain(zip_file_path)

Sie können diese heruntergeladenen Modelldateien je nach Bedarf zum Testen an unsichtbaren Bildern oder in Ihren Anwendungen verwenden.

Darauf können Sie sich beziehen: Kollaborationsnotizbuch für detaillierten Code

Abschluss

Zusammenfassend stattet Sie dieser Leitfaden mit den Kenntnissen und Werkzeugen aus, die Sie zum Trainieren eines Objekterkennungsmodells mithilfe der Objekterkennungs-API von TensorFlow benötigen, wobei Datensätze aus Roboflow Universe für eine schnelle Anpassung genutzt werden. Indem Sie die beschriebenen Schritte befolgen, können Sie Ihre Daten effektiv vorbereiten, die Trainingspipeline konfigurieren, das richtige Modell auswählen und es an Ihre spezifischen Anforderungen anpassen. Darüber hinaus eröffnet die Möglichkeit, Ihr trainiertes Modell zu exportieren und bereitzustellen, enorme Möglichkeiten für reale Anwendungen, sei es in autonomen Fahrzeugen, medizinischen Bildgebungssystemen oder Überwachungssystemen. Mit diesem Workflow können Sie leistungsstarke, skalierbare Objekterkennungssysteme mit geringerer Komplexität und schnellerer Bereitstellung erstellen.

Wichtige Erkenntnisse

• Die TensorFlow Object Detection API bietet ein flexibles Framework zum Erstellen benutzerdefinierter Objekterkennungsmodelle mit vorab trainierten Optionen, wodurch Entwicklungszeit und Komplexität reduziert werden.
• Das TFRecord-Format ist für eine effiziente Datenverarbeitung, insbesondere bei großen Datensätzen in TensorFlow, unerlässlich und ermöglicht schnelles Coaching und minimalen Overhead.
• Pipeline-Konfigurationsdateien sind für die Feinabstimmung und Anpassung des Modells an Ihren spezifischen Datensatz und die gewünschten Leistungsmerkmale von entscheidender Bedeutung.
• Vorab trainierte Modelle wie „efficientdet-d0“ und „ssd-mobilenet-v2“ bieten solide Ausgangspunkte für das Coaching benutzerdefinierter Modelle, wobei jedes Modell je nach Anwendungsfall und Ressourcenbeschränkungen spezifische Stärken aufweist.
• Der Trainingsprozess umfasst die Verwaltung von Parametern wie Batch-Größe, Anzahl der Schritte und Modell-Checkpoints, um sicherzustellen, dass das Modell optimum lernt.
• Der Export des Modells ist unerlässlich, um das trainierte Objekterkennungsmodell in einem realen Modell zu verwenden, das gepackt wird und für die Bereitstellung bereit ist.

Häufig gestellte Fragen

Die in diesem Artikel gezeigten Medien sind nicht Eigentum von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Fühlen Sie sich inspiriert, Ihren ersten TDS-Beitrag zu schreiben? Wir sind immer offen für Beiträge neuer Autoren.

Bevor wir uns dieser Woche mit der Auswahl herausragender Artikel befassen, möchten wir uns kurz bei allen unseren Lesern, Autoren und Mitgliedern unserer breiteren Group bedanken, die uns geholfen haben, einen wichtigen Meilenstein zu erreichen, denn unsere Anhänger zählen auf Mittel gerade erreicht…

Wir sind überglücklich und dankbar für alle, die uns dabei unterstützt haben, TDS zu der erfolgreichen, lernorientierten Publikation zu machen, die es heute ist. Auf weiteres Wachstum und Entdeckungen in der Zukunft!

Zurück zu unserem normalen Geschäft: Wir haben diese Woche drei aktuelle Artikel als unsere Highlights ausgewählt, die sich auf hochmoderne Instruments und Ansätze aus den immer spannenden Bereichen Laptop Imaginative and prescient und Objekterkennung konzentrieren. Da multimodale Modelle immer mehr an Bedeutung gewinnen und Anwendungsfälle wie autonomes Fahren, Gesundheitswesen und Landwirtschaft zum Mainstream werden, struggle es für Daten- und ML-Praktiker noch nie so wichtig, über die neuesten Entwicklungen auf dem Laufenden zu bleiben. (Wenn Sie sich im Second mehr für andere Themen interessieren, sind Sie bei uns richtig! Scrollen Sie nach unten, um eine Handvoll sorgfältig ausgewählter Empfehlungen zu Neurowissenschaften, Musik und KI, umweltbewussten ML-Workflows und mehr zu sehen.)

• Objektzählen in Movies meistern
  Die genaue Objekterkennung in Movies bringt im Vergleich zum gleichen Vorgang bei statischen Bildern eine Reihe neuer Herausforderungen mit sich. Lihi Gur Arie, PhD präsentiert ein klares und prägnantes Tutorial, das zeigt, wie Sie es trotzdem schaffen können, und verwendet zur Untermauerung ihrer These das witzige Beispiel des Zählens sich bewegender Ameisen auf einem Baum.
• Eishockey mit KI aufpeppen: Spieler-Monitoring mit Laptop Imaginative and prescient
  Für alle, die eine gründliche und spannende Projektdurchführung suchen, empfehlen wir dringend Raul Vizcarra Chirinos‚ Bericht über seinen jüngsten Versuch, einen Hockeyspieler-Tracker (mehr oder weniger) von Grund auf zu bauen. Mithilfe von PyTorch, Laptop-Imaginative and prescient-Techniken und einem Convolutional Neural Community (CNN) entwickelte Raul einen Prototyp, der Spieler verfolgen und grundlegende Leistungsstatistiken sammeln kann.
• Ein Crashkurs zur Planung für Wahrnehmungsingenieure im autonomen Fahren
  Auch wenn es noch Jahre dauern wird, bis selbstfahrende Autos unsere Straßen dominieren, haben Forscher und Branchenakteure in den letzten Jahren erhebliche Fortschritte gemacht. Praktiker, die ihr Wissen über Planung und Entscheidungsfindung im Zusammenhang mit autonomem Fahren erweitern möchten, sollten sich diesen Artikel nicht entgehen lassen. Patrick Langechuan LiuDer umfassende „Crashkurs“ von zu diesem Thema.

Pc Imaginative and prescient kann ein wichtiger Bestandteil von ML-Apps unterschiedlicher Größenordnung sein, von 20.000-Greenback-Tesla-Bots oder selbstfahrenden Autos bis hin zu intelligenten Türklingeln und Staubsaugern. Es ist auch eine anspruchsvolle Aufgabe, da die Hardwarespezifikationen auf „echten“ Edge-Geräten im Vergleich zu einer Cloud-Infrastruktur oft viel eingeschränkter sind.

YOLO (You Solely Look As soon as) ist eine beliebte Objekterkennungsbibliothek. Die erste Model wurde 2015 erstellt. YOLO ist besonders für eingebettete Geräte interessant, da es quick überall ausgeführt werden kann. Es sind nicht nur Python-, sondern auch C++- (ONNX und OpenVINO) und Rust-Versionen verfügbar. Vor einem Jahr habe ich YOLO v8 getestet auf einem Raspberry Pi 4. Inzwischen hat sich vieles geändert – ein neuer Raspberry Pi 5 ist verfügbar und eine neuere YOLO v10 wurde veröffentlicht. Ich erwarte additionally, dass ein neues Modell auf neuer {Hardware} schneller und präziser funktioniert.

Der in diesem Artikel vorgestellte Code ist plattformübergreifend, sodass Leser, die keinen Raspberry Pi haben, ihn auch auf einem Home windows-, Linux- oder OS X-Pc ausführen können.

Lassen Sie uns ohne weitere Umschweife sehen, wie es funktioniert!

Himbeer-Pi

Für jemanden, der vielleicht noch nie vom Raspberry Pi gehört hat, machen wir eine kurze …