RF-DETR: ein Open-Source-Modell für die visuelle Objekterkennung in Echtzeit

Allgemeine Einführung

RF-DETR ist ein Open-Source-Modell zur Objekterkennung, das vom Roboflow-Team entwickelt wurde. Es basiert auf Transformator Architektur ist das Hauptmerkmal die Echtzeit-Effizienz. Das Modell erreicht die erste Echtzeit-Erkennung von mehr als 60 APs auf dem Microsoft COCO-Datensatz und schneidet auch im RF100-VL-Benchmark-Test hervorragend ab, indem es sich an eine breite Palette von realen Szenarien anpasst. Es ist in zwei Versionen erhältlich: RF-DETR-base (29 Millionen Parameter) und RF-DETR-large (128 Millionen Parameter). Das Modell ist klein und eignet sich für den Einsatz in Edge-Geräten. Der Code und die vortrainierten Gewichte sind unter der Apache 2.0-Lizenz lizenziert und können von der Community frei genutzt werden. Die Nutzer können über GitHub auf die Ressourcen zugreifen, um das Training oder den Einsatz zu erleichtern.

Funktionsliste

• Objekterkennung in Echtzeit: schnelle Erkennung von Objekten in Bildern oder Videos mit geringer Latenzzeit.
• Training mit benutzerdefinierten Datensätzen: Unterstützung für das Tuning von Modellen mit Ihren eigenen Daten.
• Betrieb auf Endgeräten: Das Modell ist leichtgewichtig und für Geräte mit begrenzten Ressourcen geeignet.
• Einstellbare Auflösung: Benutzer können Prüfgeschwindigkeit und -genauigkeit ausgleichen.
• Vorgefertigte Modellunterstützung: bietet vorgefertigte Gewichte auf der Grundlage des COCO-Datensatzes.
• Videostromverarbeitung: kann Videos in Echtzeit analysieren und Ergebnisse ausgeben.
• ONNX-Export: unterstützt die Konvertierung in das ONNX-Format für eine einfache plattformübergreifende Bereitstellung.
• Multi-GPU-Training: Zur Beschleunigung des Trainingsprozesses können mehrere Grafikkarten eingesetzt werden.

Hilfe verwenden

Die Verwendung von RF-DETR gliedert sich in drei Teile: Installation, Inferenz und Schulung. Im Folgenden finden Sie detaillierte Schritte, die Ihnen einen schnellen Einstieg ermöglichen.

Einbauverfahren

1. Vorbereitung der Umwelt
   Erfordert Python 3.9 oder höher, und PyTorch 1.13.0 oder höher. Wenn Sie eine GPU verwenden, führen Sie nvidia-smi Überprüfen Sie das Laufwerk.
   • PyTorch installieren:

     pip install torch>=1.13.0 torchvision>=0.14.0
     

   • Code herunterladen:

     git clone https://github.com/roboflow/rf-detr.git
     cd rf-detr
     

   • Installieren Sie die Abhängigkeit:

     pip install rfdetr
     

     Dadurch wird automatisch Folgendes installiert numpyundsupervision und andere notwendige Bibliotheken.

2. Überprüfen der Installation
   Führen Sie den folgenden Code aus:

   from rfdetr import RFDETRBase
   print("安装成功")

Wenn keine Fehler gemeldet werden, ist die Installation abgeschlossen.

Inferenzoperation

RF-DETR wird mit einem vortrainierten Modell des COCO-Datensatzes geliefert, um Bilder oder Videos direkt zu erkennen.

1. Bilderkennung
   • Beispiel-Code:

     import io
     import requests
     from PIL import Image
     from rfdetr import RFDETRBase
     import supervision as sv
     model = RFDETRBase()
     url = "https://media.roboflow.com/notebooks/examples/dog-2.jpeg"
     image = Image.open(io.BytesIO(requests.get(url).content))
     detections = model.predict(image, threshold=0.5)
     labels = [f"{class_id} {confidence:.2f}" for class_id, confidence in zip(detections.class_id, detections.confidence)]
     annotated_image = image.copy()
     annotated_image = sv.BoxAnnotator().annotate(annotated_image, detections)
     annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels)
     sv.plot_image(annotated_image)
     

   • Dieser Code erkennt Objekte im Bild, kennzeichnet den Begrenzungsrahmen und die Vertrauensstufe und zeigt dann die Ergebnisse an.
2. Video-Erkennung
   • Installieren Sie erstens opencv-python::

     pip install opencv-python
     

   • Beispiel-Code:

     import cv2
     from rfdetr import RFDETRBase
     import supervision as sv
     model = RFDETRBase()
     cap = cv2.VideoCapture("video.mp4")  # 替换为你的视频路径
     while cap.isOpened():
     ret, frame = cap.read()
     if not ret:
     break
     image = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
     detections = model.predict(image, threshold=0.5)
     annotated_frame = sv.BoxAnnotator().annotate(frame, detections)
     cv2.imshow("RF-DETR Detection", annotated_frame)
     if cv2.waitKey(1) & 0xFF == ord('q'):
     break
     cap.release()
     cv2.destroyAllWindows()
     

   • Damit werden Objekte im Video Bild für Bild erkannt und in Echtzeit angezeigt.
3. Anpassung der Auflösung
   • Die Auflösung kann bei der Initialisierung eingestellt werden (muss ein Vielfaches von 56 sein):

     model = RFDETRBase(resolution=560)
     

   • Je höher die Auflösung, desto besser die Genauigkeit, aber auch langsamer.

Training benutzerdefinierter Modelle

RF-DETR unterstützt die Feinabstimmung mit seinem eigenen Datensatz, der jedoch im COCO-Format vorliegen muss und Folgendes enthält trainundvalid im Gesang antworten test Drei Unterverzeichnisse.

1. Vorbereiten des Datensatzes
   • Beispiel einer Katalogstruktur:

     dataset/
     ├── train/
     │   ├── _annotations.coco.json
     │   ├── image1.jpg
     │   └── image2.jpg
     ├── valid/
     │   ├── _annotations.coco.json
     │   ├── image1.jpg
     │   └── image2.jpg
     └── test/
     ├── _annotations.coco.json
     ├── image1.jpg
     └── image2.jpg
     

   • Datensätze im COCO-Format können mit der Roboflow-Plattform erstellt werden:

     from roboflow import Roboflow
     rf = Roboflow(api_key="你的API密钥")
     project = rf.workspace("rf-100-vl").project("mahjong-vtacs-mexax-m4vyu-sjtd")
     dataset = project.version(2).download("coco")
     

2. Beginn der Ausbildung
   • Beispiel-Code:

     from rfdetr import RFDETRBase
     model = RFDETRBase()
     model.train(dataset_dir="./mahjong-vtacs-mexax-m4vyu-sjtd-2", epochs=10, batch_size=4, grad_accum_steps=4, lr=1e-4)
     

   • Für das Training ist die empfohlene Gesamtgröße der Charge (batch_size * grad_accum_stepsDie A100-GPUs verwenden zum Beispiel die batch_size=16, grad_accum_steps=1T4-GPUs batch_size=4, grad_accum_steps=4.
3. Multi-GPU-Schulung
   • einrichten. main.py Dokumentation:

     from rfdetr import RFDETRBase
     model = RFDETRBase()
     model.train(dataset_dir="./dataset", epochs=10, batch_size=4, grad_accum_steps=4, lr=1e-4)
     

   • Läuft im Terminal:

     python -m torch.distributed.launch --nproc_per_node=8 --use_env main.py
     

   • Oberbefehlshaber (Militär) 8 Ersetzen Sie durch die Anzahl der von Ihnen verwendeten GPUs. Beachten Sie die Anpassung batch_size um die Gesamtchargengröße stabil zu halten.
4. Ergebnisse des Lastentrainings
   • Nach dem Training werden zwei Gewichtungsdateien erstellt: normale Gewichte und EMA-Gewichte (stabiler). Methode zum Laden:

     model = RFDETRBase(pretrain_weights="./output/model_ema.pt")
     detections = model.predict("image.jpg")
     

ONNX-Ausfuhr

• Export in das ONNX-Format zur einfachen Bereitstellung auf anderen Plattformen:

  from rfdetr import RFDETRBase
  model = RFDETRBase()
  model.export()
  

• Die exportierte Datei wird im Verzeichnis output Katalog für optimale Inferenz für Randgeräte.

Anwendungsszenario

1. automatisches Fahren
   RF-DETR erkennt Fahrzeuge und Fußgänger auf der Straße in Echtzeit. Seine geringe Latenz und hohe Genauigkeit sind für eingebettete Systeme geeignet.
2. industrielle Qualitätskontrolle
   RF-DETR identifiziert schnell die Defekte an den Montagelinien in der Fabrik. Das Modell ist leicht und kann direkt an der Anlage betrieben werden.
3. Videoüberwachung
   RF-DETR verarbeitet Überwachungsvideos, um abnormale Objekte oder Verhaltensweisen in Echtzeit zu erkennen. Er unterstützt Videostreaming und ist für 24/7-Sicherheit geeignet.

QA

1. Welche Datensatzformate werden unterstützt?
   Es wird nur das COCO-Format unterstützt. Der Datensatz muss enthalten trainundvalid im Gesang antworten test Unterverzeichnisse, jedes mit einem entsprechenden _annotations.coco.json Dokumentation.
2. Wie erhalte ich den Roboflow-API-Schlüssel?
   Melden Sie sich bei https://app.roboflow.com an, suchen Sie den API-Schlüssel in Ihren Kontoeinstellungen, kopieren Sie ihn und setzen Sie ihn in die Umgebungsvariable ROBOFLOW_API_KEY.
3. Wie lange dauert die Ausbildung?
   Hängt von der Hardware und der Größe des Datensatzes ab. Auf einem T4-Grafikprozessor können 10 Epochen ein paar Stunden dauern. Kleinere Datensätze können auf einer CPU ausgeführt werden, aber das ist langsam.