RF-DETR

Ein Detection Transformer, der statt eines dichten Rasters eine feste Menge von Objekten vorhersagt und daher bei der Inferenz keine NMS benötigt. LibreYOLO unterstützt ihn für vier Aufgaben.

Aufgaben
detection, instance segmentation, pose, oriented boxes
Größen
n, s, m, l for detection, pose and oriented boxes; n through xx for segmentation
Installation
pip install "libreyolo[rfdetr]"
Supportstufe
Flaggschiff, seit v1.0.0. Funktionen werden zuerst hier entwickelt und vollständig auf GPUs validiert.
Upstream
RF-DETR von Roboflow, Apache-2.0. Publikation, Quelle
Lizenzen
Code MIT, Gewichte Apache-2.0. Kommerzielle Nutzung
LibreRFDETRs, Objekterkennung in einem Video bei 512 px.

Installation

RF-DETR benötigt ein eigenes Zusatzpaket, das transformers für das Backbone installiert.

bash
pip install "libreyolo[rfdetr]"

Vorhersage

Die Gewichte werden bei der ersten Verwendung von Hugging Face heruntergeladen und lokal zwischengespeichert.

Python
from libreyolo import LibreYOLO, SAMPLE_IMAGE model = LibreYOLO("LibreRFDETRs.pt")result = model(SAMPLE_IMAGE, save=True) for box in result.boxes:    print(box.cls, box.conf, box.xyxy)
CLI
libreyolo predict model=LibreRFDETRs.pt source=https://raw.githubusercontent.com/LibreYOLO/libreyolo/release/libreyolo/assets/parkour.jpg save=True
Video
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # Jede von der Bibliothek unterstützte Quelle: Datei, Ordner, URL, Webcam-Index,# RTSP-Stream oder eine .streams-Listefor result in model.predict("clip.mp4", stream=True, save=True):    print(len(result.boxes))

Das zurückgegebene Results-Objekt entspricht dem aller anderen Familien. Der Wechsel zu einem anderen Detektor erfordert daher nur eine Änderung in einer Zeile. conf und max_det filtern die Auswahl der Queries. Es gibt keinen NMS-Schritt zum Abstimmen. Unter Vorhersage findest du Quellen, Streaming und die Verarbeitung von Ergebnissen.

Varianten

Es gibt vier Größen und vier Aufgaben mit einer gemeinsamen Architektur. Segmentierung, Pose und orientierte Boxen verwenden den Erkennungsdecoder mit einem anderen Head und akzeptieren daher dieselben Argumente. Die Größen haben ähnliche Parameteranzahlen und unterscheiden sich vor allem in der Eingabeauflösung.

CheckpointEingabe (px)mAP 50-95Parameter (M)
LibreRFDETRn38451.430.47
LibreRFDETRs51255.132.11
LibreRFDETRm57657.433.69
LibreRFDETRl70458.633.93

COCO val2017, 500 images. Gemessen mit dem LibreYOLO-Benchmarksystem und auf Vision Analysis veröffentlicht. Dort werden Latenzen verschiedener Hardware und Runtimes verglichen und die vollständigen Laufprotokolle bereitgestellt.

Training

Das Training beginnt bei allen vier Aufgaben mit einem veröffentlichten Checkpoint. RF-DETR führt pretrained unter den von seinem nativen Trainer ignorierten Argumenten auf. pretrained=False erzeugt daher kein zufällig initialisiertes Modell.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.train(data="my-dataset.yaml", epochs=50, imgsz=512, batch=8, lr0=1e-4)
CLI
libreyolo train model=LibreRFDETRs.pt data=my-dataset.yaml \  epochs=50 imgsz=512 batch=8 lr0=1e-4
LoRA
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.train(data="my-dataset.yaml", epochs=50, lora=True)
Multi-GPU
libreyolo train model=LibreRFDETRs.pt data=my-dataset.yaml \  epochs=50 device=0,1 batch=-1

Zwei Argumente sind hier wichtiger als bei einem CNN-Detektor. Halte lr0 bei höchstens 1e-4, weil Transformer-Detektoren bei Lernraten divergieren, die ein YOLO-Modell verträgt. Behalte für imgsz die native Auflösung des Checkpoints bei, sofern kein Grund für eine Änderung besteht. Die Eingabe muss ohne Rest durch das Produkt aus Backbone-Patch-Größe und Fensteranzahl teilbar sein. LibreYOLO prüft das vor Beginn des Laufs und nennt die nächstgelegenen gültigen Größen.

Unter Training findest du Datensätze, Datenaugmentierung, Multi-GPU und Logger.

Validierung

val() gibt ein Dictionary mit metrics/-Schlüsseln für Precision, Recall, mAP 50 und mAP 50-95 zurück. Diese werden auf einem beliebigen Datensatz in dem Format gemessen, das du für das Training verwendet hast.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # val() gibt ein einfaches dict zurück, kein Objektmetrics = model.val(data="my-dataset.yaml", imgsz=512) print(metrics["metrics/mAP50-95"])print(metrics["metrics/mAP50"])print(metrics["metrics/precision"], metrics["metrics/recall"])
CLI
libreyolo val model=LibreRFDETRs.pt data=my-dataset.yaml imgsz=512
Gegen COCO
# Die mitgelieferte COCO-YAML enthält ein eingebettetes Downloadskript und# benötigt daher eine ausdrückliche Erlaubnis, wenn der Datensatz nicht lokal ist.libreyolo val model=LibreRFDETRn.pt data=coco.yaml imgsz=384 \  allow_download_scripts=True

Export

AufgabeONNXTorchScriptExecuTorchTensorRTOpenVINOPaddleMNNRKNNncnnTFLiteCoreMLCore AI
DetectionDetection to ONNX: unterstütztDetection to TorchScript: unterstütztDetection to ExecuTorch: unterstütztDetection to TensorRT: unterstützt. Runtime parity coverage lives in tests/e2e/test_tensorrt.py.Detection to OpenVINO: unterstützt. Runtime parity coverage lives in tests/e2e/test_openvino.py.Detection to Paddle: nicht unterstütztDetection to MNN: unterstütztDetection to RKNN: nicht unterstütztDetection to ncnn: nicht unterstütztDetection to TFLite: nicht unterstütztDetection to CoreML: unterstützt. Conversion is available, but runtime parity requires a macOS runner.Detection to Core AI: unterstützt
Instance segmentationInstance segmentation to ONNX: unterstütztInstance segmentation to TorchScript: unterstütztInstance segmentation to ExecuTorch: unterstütztInstance segmentation to TensorRT: unterstützt. A published Apache-2.0 trained segmentation checkpoint exports and reloads, but public top-k class membership changes.Instance segmentation to OpenVINO: unterstützt. After Hungarian query alignment, the converted-runtime element match rate is 69.0%, below the validation bar.Instance segmentation to Paddle: nicht unterstütztInstance segmentation to MNN: nicht unterstütztInstance segmentation to RKNN: nicht unterstütztInstance segmentation to ncnn: nicht unterstütztInstance segmentation to TFLite: nicht unterstütztInstance segmentation to CoreML: nicht unterstütztInstance segmentation to Core AI: nicht unterstützt
PosePose to ONNX: unterstütztPose to TorchScript: unterstütztPose to ExecuTorch: unterstütztPose to TensorRT: unterstützt. A published Apache-2.0 trained pose checkpoint exports and reloads, but matched public boxes fall to 0.704 IoU with 41.4-pixel coordinate drift.Pose to OpenVINO: unterstützt. After Hungarian query alignment, the converted-runtime element match rate is 72.75%, below the validation bar.Pose to Paddle: nicht unterstütztPose to MNN: nicht unterstütztPose to RKNN: nicht unterstütztPose to ncnn: nicht unterstütztPose to TFLite: nicht unterstütztPose to CoreML: nicht unterstütztPose to Core AI: nicht unterstützt
Oriented boxesOriented boxes to ONNX: unterstütztOriented boxes to TorchScript: unterstütztOriented boxes to ExecuTorch: unterstütztOriented boxes to TensorRT: unterstützt. A deterministic synthetic OBB fixture exports and reloads, but public top-k class membership changes.Oriented boxes to OpenVINO: unterstützt. After Hungarian query alignment, the converted-runtime element match rate is 91.25%, below the validation bar.Oriented boxes to Paddle: nicht unterstütztOriented boxes to MNN: nicht unterstütztOriented boxes to RKNN: nicht unterstütztOriented boxes to ncnn: nicht unterstütztOriented boxes to TFLite: nicht unterstütztOriented boxes to CoreML: nicht unterstütztOriented boxes to Core AI: nicht unterstützt

Ein exportiertes Artefakt wird anhand seiner Dateiendung wieder über LibreYOLO() geladen. Eine .onnx- oder .engine-Datei verhält sich daher wie ein Checkpoint und gibt dasselbe Results-Objekt zurück. Du kannst den Graphen auch in einer einfachen Runtime ohne LibreYOLO ausführen. Dann musst du die Vor- und Nachverarbeitung selbst implementieren.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.export(format="onnx", imgsz=512)model.export(format="tensorrt", imgsz=512, half=True) # Für jedes Format akzeptierte Argumente:##   format    "onnx" | "torchscript" | "executorch" | "tensorrt"#             | "openvino" | "paddle" | "mnn" | "rknn" | "ncnn"#             | "tflite" | "coreml" | "coreai".#             "engine" ist ein Alias für tensorrt, "litert" für tflite.#   imgsz     int oder (height, width). Standardmäßig native Checkpoint-Auflösung.#   batch     int, Standardwert 1.#   half      bool, Export in FP16. Standardwert False.#   int8      bool, Export in INT8. Standardwert False. Benötigt `data`.#   data      Pfad zu einer Datensatz-YAML zur int8-Kalibrierung.#   fraction  float, Anteil des Kalibrierungssatzes. Standardwert 1.0.#   dynamic   bool, dynamische Achsen. Standardwert True.#   simplify  bool, ONNX-Graphvereinfachung. Standardwert True.#   opset     int, ONNX-Opset. Ohne Angabe pro Familie gewählt.#   device    str, Gerät für das Tracing. Standardmäßig Modellgerät.#   output_path  str, standardmäßig aus dem Checkpoint abgeleitet.#   verbose   bool, Standardwert False.#   allow_download_scripts  bool, Standardwert False. Erlaubt eingebettetes#             Python in einer Datensatz-YAML, die heruntergeladen werden muss.## Einige Formate akzeptieren eigene Zusatzargumente wie eine RKNN-Zielplattform.# Diese sind auf der jeweiligen Formatseite dokumentiert.
CLI
libreyolo export model=LibreRFDETRs.pt format=onnx imgsz=512libreyolo export model=LibreRFDETRs.pt format=tensorrt imgsz=512 half=True
Exportierte Datei verwenden
from libreyolo import LibreYOLO # Die Factory entscheidet anhand der Dateiendung, daher wird ein Exportartefakt# wie jeder Checkpoint geladen und gibt dasselbe Results-Objekt zurück.model = LibreYOLO("LibreRFDETRs.onnx")result = model(SAMPLE_IMAGE) print(result.boxes.xyxy)
Ohne LibreYOLO
import numpy as npimport onnxruntime as ort # Bei direkter Graphausführung musst du Vor- und Nachverarbeitung selbst umsetzen.# Prüfe die Signatur, bevor du etwas anschließt.session = ort.InferenceSession("LibreRFDETRs.onnx")name = session.get_inputs()[0].nameoutputs = session.run(None, {name: np.zeros((1, 3, 512, 512), dtype=np.float32)}) for meta, array in zip(session.get_outputs(), outputs):    print(meta.name, array.shape)

Checkpoints

Alle veröffentlichten Gewichtsdateien dieser Familie.

DateiEingabe (px)Lizenz der Gewichte
Detection
LibreRFDETRl.pt704apache-2.0
LibreRFDETRm.pt576apache-2.0
LibreRFDETRn.pt384apache-2.0
LibreRFDETRs.pt512apache-2.0
Instance segmentation
LibreRFDETRn-seg.pt312apache-2.0
LibreRFDETRs-seg.pt384apache-2.0
LibreRFDETRm-seg.pt432apache-2.0
LibreRFDETRl-seg.pt504apache-2.0
LibreRFDETRx-seg.pt624apache-2.0
LibreRFDETRxx-seg.pt768apache-2.0
Pose
LibreRFDETRn-pose.ptapache-2.0
LibreRFDETRs-pose.ptapache-2.0
LibreRFDETRm-pose.ptapache-2.0
LibreRFDETRl-pose.ptapache-2.0
LibreRFDETRx-pose.pt576apache-2.0
Oriented boxes
LibreRFDETRn-obb.pt384cc-by-4.0
LibreRFDETRs-obb.pt512cc-by-4.0
LibreRFDETRm-obb.pt576cc-by-4.0
LibreRFDETRl-obb.pt704cc-by-4.0

Jede oben aufgeführte Datei ist heute in der LibreYOLO-Organisation verfügbar und wird bei der ersten Verwendung heruntergeladen.

Lizenzierung

Prüfe die Lizenz im Hugging-Face-Repository der konkreten Gewichte, die du herunterlädst. Jeder Checkpoint in der LibreYOLO-Organisation hat eine Lizenz, und sie ist innerhalb einer Familie nicht immer gleich. Dieses Repository ist die maßgebliche Quelle. Die Zusammenfassung unten beschreibt den Stand bei der letzten Verifizierung dieser Seite.

Dies ist eine Beschreibung der beteiligten Lizenzen und keine Rechtsberatung. Wenn die Antwort kommerziell relevant ist, lies die Lizenzen selbst und hole eigenen Rechtsrat ein.

Originalarbeit
RF-DETR, Roboflow
Upstream-Lizenz
Apache-2.0
LibreYOLO-Code
MIT
Gewichte
Apache-2.0, erneut unter huggingface.co/LibreYOLO veröffentlicht
Einordnung
Apache-2.0 is a permissive license, so these weights can be used in commercial and closed-source products. It asks you to keep its license text and attribution notices with any copy of the weights you redistribute, and it grants a patent license. It places no obligation on your own application code, and weights you train yourself on your own data are yours.

Zitieren

@inproceedings{robinson2026rfdetr,
  title     = {RF-DETR: Real-Time Detection Transformer},
  author    = {Robinson, Isaac and Robicheaux, Peter and Popov, Matvei and Ramanan, Deva and Peri, Neehar},
  booktitle = {International Conference on Learning Representations (ICLR)},
  year      = {2026},
  url       = {https://arxiv.org/abs/2511.09554}
}

Aus dem Zitierblock der Autoren unter github.com/roboflow/rf-detr#citation kopiert.

Mit LibreYOLO v1.5.0 verifiziert. Supporttabellen, Checkpoints und Benchmarkwerte auf dieser Seite werden aus der veröffentlichten Bibliothek und den publizierten Gewichten generiert und nicht von Hand geschrieben.