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 and oriented boxes; n through xx for segmentation; x for pose
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]"

Ohne dieses Paket bricht das Laden eines RF-DETR-Checkpoints oder Modellnamens, in Python wie in der CLI, mit einem Fehler ab, der diese Installationszeile nennt.

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.

Erkennung, Segmentierung und orientierte Boxen verwenden bilineare OpenCV-Skalierung mit Gleitkommazahlen ohne Antialiasing; Pose behält die Skalierung mit Antialiasing bei. Rechteckiges imgsz=(height, width) muss dem Patch-/Fensterraster der Aufgabe entsprechen. Das Checkpoint-Verzeichnis enthält den UI-Detektor. Ereignishistogramme verwenden das gespeicherte Eingabeprofil.

Varianten

Es gibt vier Erkennungsgrößen, n bis l, 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 Segmentierung ergänzt x und xx, Pose gibt es nur in x. Die Größen haben ähnliche Parameteranzahlen und unterscheiden sich vor allem in der Eingabeauflösung.

Checkpoint	Eingabe (px)	mAP 50-95	Parameter (M)
LibreRFDETRn	384	51.4	30.47
LibreRFDETRs	512	55.2	32.11
LibreRFDETRm	576	57.4	33.69
LibreRFDETRl	704	58.6	33.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. pretrained=False initialisiert dagegen das ganze Netz neu, das Backbone eingeschlossen, und trainiert von Grund auf neu.

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.

Das Segment-Fine-Tuning startet von einem Segment-Checkpoint, weil RF-DETR keinen Transfer von Erkennung zu Segmentierung kennt. libreyolo train model=LibreRFDETRn-seg.pt task=segment lädt diesen Checkpoint, und ein Erkennungs-Checkpoint mit task=segment bricht mit einem Fehler ab.

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

Neue Läufe verwenden standardmäßig output_dir=None und damit ein hochgezähltes runs/train/rfdetr_exp mit exist_ok=False. Ein fortgesetzter Lauf schreibt weiter in das Laufverzeichnis seines Checkpoints. Pose-Datensätze mit mehreren Klassen verwenden kpt_names mit Klassenindex oder -name als Schlüssel; eine leere Liste kennzeichnet eine Klasse nur mit Boxen. Vorhersagen füllen Keypoints bis kpt_shape auf; die Keypoint-mAP-Fitness bewertet Klassen nur mit Boxen nicht.

Validierung

val() gibt ein Dictionary mit metrics/-Schlüsseln für mAP 50, mAP 50-95, mAP 75 und den COCO-Average-Recall 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/mAP75"], metrics["metrics/AR100"])

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

Aufgabe	ONNX	TorchScript	ExecuTorch	TensorRT	OpenVINO	Paddle	MNN	RKNN	ncnn	TFLite	CoreML	Core AI
Detection	Detection to ONNX: unterstützt	Detection to TorchScript: unterstützt	Detection to ExecuTorch: unterstützt	Detection 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ützt	Detection to MNN: unterstützt	Detection to RKNN: nicht unterstützt	Detection to ncnn: nicht unterstützt	Detection to TFLite: nicht unterstützt	Detection to CoreML: unterstützt. Conversion is available, but runtime parity requires a macOS runner.	Detection to Core AI: unterstützt
Instance segmentation	Instance segmentation to ONNX: unterstützt	Instance segmentation to TorchScript: unterstützt	Instance segmentation to ExecuTorch: unterstützt	Instance 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ützt	Instance segmentation to MNN: nicht unterstützt	Instance segmentation to RKNN: nicht unterstützt	Instance segmentation to ncnn: nicht unterstützt	Instance segmentation to TFLite: nicht unterstützt	Instance segmentation to CoreML: nicht unterstützt	Instance segmentation to Core AI: nicht unterstützt
Pose	Pose to ONNX: unterstützt	Pose to TorchScript: unterstützt	Pose to ExecuTorch: unterstützt	Pose 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ützt	Pose to MNN: nicht unterstützt	Pose to RKNN: nicht unterstützt	Pose to ncnn: nicht unterstützt	Pose to TFLite: nicht unterstützt	Pose to CoreML: nicht unterstützt	Pose to Core AI: nicht unterstützt
Oriented boxes	Oriented boxes to ONNX: unterstützt	Oriented boxes to TorchScript: unterstützt	Oriented boxes to ExecuTorch: unterstützt	Oriented 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ützt	Oriented boxes to MNN: nicht unterstützt	Oriented boxes to RKNN: nicht unterstützt	Oriented boxes to ncnn: nicht unterstützt	Oriented boxes to TFLite: nicht unterstützt	Oriented boxes to CoreML: nicht unterstützt	Oriented 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, SAMPLE_IMAGE # 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("weights/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)

ONNX-Ein- und Ausgaben

Tensor	`input` `float32` `[batch, 3, height, width]`
Farbe	RGB
Skalierung	Pixel / 255
Normalisierung	Mittelwert [0.485,0.456,0.406], Standardabweichung [0.229,0.224,0.225]
Größenanpassung	`custom`, `bilinear`

The input tensor is named input, not images.

Square input only. Export rejects a non-square imgsz. The default size comes from the checkpoint and is stored in the imgsz metadata key: 384 for LibreRFDETRn, 312 for LibreRFDETRn-seg, 576 for LibreRFDETRx-pose.

A custom imgsz must be a multiple of patch size x windows: 32 for detection and OBB, 12 for segmentation n, 24 for the other segmentation sizes and for pose.

Stretch the whole image to width x height. There is no letterbox and no padding, so the aspect ratio is not kept.

Detection, segmentation and OBB: convert the 8-bit RGB image to float32 and divide by 255 first, then resize the float image with cv2.resize INTER_LINEAR (half-pixel centers, no antialiasing). Resizing the 8-bit image before dividing is close but moves scores by up to about 0.01.

Pose resizes differently: divide by 255 the same way, then resize the float image with antialiased bilinear, as torch.nn.functional.interpolate does with mode bilinear, align_corners False and antialias True. This is the filter of Pillow's BILINEAR, which widens by the shrink factor, but in float with no rounding to 8 bits. Per axis, let s = in_size / out_size and f = max(s, 1). Output pixel i has center c = (i + 0.5) * s. It reads source pixels j from int(c - f + 0.5) to int(c + f + 0.5) - 1, clipped to the image, each with weight max(0, 1 - |j + 0.5 - c| / f). Divide the weights by their sum.

The pose model is sensitive to this. On the test image, cv2.resize INTER_LINEAR or INTER_AREA adds 3 to 9 detections, and Pillow on the 8-bit image adds one and moves keypoints by more than 4 px.

Then subtract the mean and divide by the std per channel.

nms=True is not available for this family: export raises NotImplementedError.

Detection, Standardexport

Ausgabe	Form	Bedeutung
`dets`	`[batch, queries, 4]`	Boxes as cx, cy, w, h, normalized 0 to 1 of the input. 300 queries.
`labels`	`[batch, queries, columns]`	Raw class logits per query, sigmoid not applied. The COCO checkpoints have 91 columns, where column k is COCO category id k. For other checkpoints column j is class j.

Nachbearbeitung

Apply sigmoid to labels.
Flatten the scores of one image to queries x columns and take the top k over all of them, with k equal to queries (300). For flat index i, the query is i // columns and the column is i % columns. One query can yield several classes.
Keep the entries whose score is strictly above the confidence threshold (0.25 by default). There is no NMS.
When labels has 91 columns and nc is 80 (the COCO checkpoints), the column is a COCO category id. Class i is the i-th id, counting from 0, in this list: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 27, 28, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 67, 70, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 84, 85, 86, 87, 88, 89, 90. Drop entries whose id is not in the list. With any other column count the column is the class.
Convert the query's box to x1 = cx - w / 2, y1 = cy - h / 2, x2 = cx + w / 2, y2 = cy + h / 2.
Map boxes back to the original image: multiply x by the original width and y by the original height. The input was stretched, so no pad offset applies. LibreYOLO does not clip these boxes.

Instance segmentation, Standardexport

Ausgabe	Form	Bedeutung
`dets`	`[batch, queries, 4]`	Boxes as cx, cy, w, h, normalized 0 to 1 of the input. 100 queries for sizes n and s, 200 for m and l, 300 for x and xx.
`labels`	`[batch, queries, columns]`	Raw class logits per query, sigmoid not applied. 91 columns for the COCO checkpoints, where column k is COCO category id k.
`masks`	`[batch, queries, mask_h, mask_w]`	Raw mask logits per query over the whole input, at a quarter of the input size: 78 x 78 at 312 x 312.

Nachbearbeitung

Select, threshold, map classes and decode boxes exactly as for detection, with k equal to queries.
Take the mask of each kept query and resize the logits straight to the original image size with bilinear, half-pixel centers and no antialiasing (cv2.resize INTER_LINEAR on the float logits gives the same).
A pixel is foreground when its resized logit is above 0.

Pose, Standardexport

Ausgabe	Form	Bedeutung
`dets`	`[batch, queries, 4]`	Boxes as cx, cy, w, h, normalized 0 to 1 of the input. 100 queries.
`labels`	`[batch, queries, columns]`	Raw class logits per query, sigmoid not applied, with the keypoint class term already added inside the graph. Column 0 is an empty slot and column j + 1 is class j, so the person checkpoint has 2 columns.
`keypoints`	`[batch, queries, columns * num_keypoints, 8]`	One block of num_keypoints rows per label column, 2 x 17 = 34 rows here. Each row is x, y normalized 0 to 1 of the input, findable logit, visible logit, log_l11, l21, log_l22 and a class logit term. The num_keypoints_per_class metadata key ([0, 17]) says how many rows of each block are real keypoints.

Nachbearbeitung

Apply sigmoid to labels. Flatten to queries x columns and take the top k over all of them, with k equal to queries (100). For flat index i, the query is i // columns and the column is i % columns.
For each entry take its column's keypoint block: rows column * num_keypoints onward, of which the first num_keypoints_per_class[column] are used.
Rescore each entry whose column has keypoints. Per used keypoint, with a = log_l11, b = l21, d = log_l22 and p = sigmoid(findable logit): sigma = exp(-2a) + exp(-2d) + b^2 * exp(-2a - 2d). Then trace = log(sum of p * sigma / sum of p) over the used keypoints, and score = score * exp(-0.2 * trace). Scores can go above 1.
Drop entries whose column is 0. The class is column - 1.
Keep the entries whose new score is strictly above the confidence threshold (0.25 by default). There is no NMS.
Decode and map the box as for detection. LibreYOLO does not clip these boxes.
Keypoint x is x * original width and keypoint y is y * original height. Keypoint confidence is sigmoid(findable logit). LibreYOLO does not use the visible logit.

Oriented boxes, Standardexport

Ausgabe	Form	Bedeutung
`dets`	`[batch, queries, 4]`	Rotated boxes as cx, cy, w, h, normalized 0 to 1 of the input. 300 queries.
`labels`	`[batch, queries, columns]`	Raw class logits per query, sigmoid not applied. Column j is class j. The 6-class checkpoint has 7 columns: the last one is not a class and LibreYOLO does not drop it.
`angles`	`[batch, queries, 1]`	Rotation in radians from -pi / 2 to pi / 2, tanh already applied, measured on the square input. The width side points along (cos(angle), sin(angle)) with y pointing down.

Nachbearbeitung

Select and threshold as for detection, with k equal to queries (300). The column is the class.
The stretch scales x and y by different amounts, so map each box back through its corners. In normalized input units, with c = cos(angle) and s = sin(angle), the corners are (cx, cy) - u - v, + u - v, + u + v and - u + v, with u = (c * w / 2, s * w / 2) and v = (-s * h / 2, c * h / 2).
Multiply corner x by the original width and corner y by the original height.
Fit cv2.minAreaRect to the 4 corners and convert its angle to radians. Raise w and h to at least 1e-4. If h > w, swap them and add pi / 2 to the angle. Then wrap the angle to [-pi / 2, pi / 2) with angle = (angle + pi / 2) mod pi - pi / 2.
The result is cx, cy, w, h, angle in original-image pixels, with w the long side.

Um deine eigene Implementierung zu prüfen, lade dieselbe Datei mit LibreYOLO: LibreYOLO("model.onnx").predict("image.jpg") liefert die Referenzergebnisse. Geprüft mit LibreYOLO 1.7.0.

Checkpoints

Alle veröffentlichten Gewichtsdateien dieser Familie.

Datei	Eingabe (px)	Lizenz der Gewichte
Detection
LibreRFDETRl.pt	704	apache-2.0
LibreRFDETRm.pt	576	apache-2.0
LibreRFDETRn.pt	384	apache-2.0
LibreRFDETRs.pt	512	apache-2.0
LibreRFDETRm-ui.pt		mit
Instance segmentation
LibreRFDETRn-seg.pt	312	apache-2.0
LibreRFDETRs-seg.pt	384	apache-2.0
LibreRFDETRm-seg.pt	432	apache-2.0
LibreRFDETRl-seg.pt	504	apache-2.0
LibreRFDETRx-seg.pt	624	apache-2.0
LibreRFDETRxx-seg.pt	768	apache-2.0
Pose
LibreRFDETRx-pose.pt	576	apache-2.0
Oriented boxes
LibreRFDETRn-obb.pt	384	cc-by-4.0
LibreRFDETRs-obb.pt	512	cc-by-4.0
LibreRFDETRm-obb.pt	576	cc-by-4.0
LibreRFDETRl-obb.pt	704	cc-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
Upstream-Quelle: github.com/roboflow/rf-detr
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.