RF-DETR

Un detection transformer qui prédit un ensemble fixe d'objets au lieu d'une grille dense, ce qui élimine le besoin de NMS lors de l'inférence. LibreYOLO le prend en charge pour quatre tâches.

Tâches
detection, instance segmentation, pose, oriented boxes
Tailles
n, s, m, l for detection, pose and oriented boxes; n through xx for segmentation
Installer
pip install "libreyolo[rfdetr]"
Niveau de support
Fer de lance, depuis v1.0.0. Les fonctionnalités sont d'abord conçues et entièrement validées sur GPU ici.
Origine
RF-DETR par Roboflow, Apache-2.0. Article, source
Licences
Code MIT, poids Apache-2.0. Usage commercial
LibreRFDETRs, détection sur vidéo à 512 px.

Installer

RF-DETR nécessite son propre extra, qui installe transformers pour le backbone.

bash
pip install "libreyolo[rfdetr]"

Prédire

Les poids sont téléchargés depuis Hugging Face à la première utilisation et mis en cache localement.

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
Vidéo
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # Toute source acceptée par la bibliothèque : fichier, dossier, URL,# index de webcam, flux RTSP ou liste .streamsfor result in model.predict("clip.mp4", stream=True, save=True):    print(len(result.boxes))

L'objet Results renvoyé est le même pour toutes les familles, remplacer le détecteur ne demande donc de modifier qu'une ligne. conf et max_det filtrent la sélection des requêtes ; aucune étape NMS n'est à régler. Consultez la prédiction pour les sources, le streaming et le traitement des résultats.

Variantes

Quatre tailles et quatre tâches partagent une même architecture : la segmentation, la pose et les boîtes orientées réutilisent le décodeur de détection avec une tête différente, et acceptent donc les mêmes arguments. Les tailles comportent un nombre de paramètres similaire et diffèrent principalement par la résolution d'entrée.

CheckpointEntrée (px)mAP 50-95Paramètres (M)
LibreRFDETRn38451.430.47
LibreRFDETRs51255.132.11
LibreRFDETRm57657.433.69
LibreRFDETRl70458.633.93

COCO val2017, 500 images. Mesuré par le banc de benchmark de LibreYOLO et publié sur Vision Analysis, où sont comparées la latence selon le matériel et les runtimes et où sont conservés les enregistrements complets des exécutions.

Entraîner

Pour les quatre tâches, l'entraînement part d'un checkpoint publié. RF-DETR répertorie pretrained parmi les arguments ignorés par son entraîneur natif. Fournir pretrained=False ne produit donc pas ici un modèle initialisé aléatoirement.

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

Deux arguments comptent davantage ici que sur un détecteur CNN. Conservez lr0 à 1e-4 ou moins, car les detection transformers divergent avec des learning rates qu'un modèle YOLO tolère. Laissez imgsz à la résolution native du checkpoint sauf si vous avez une raison de la modifier. L'entrée doit être divisible sans reste par le produit de la taille de patch du backbone et du nombre de fenêtres. LibreYOLO le vérifie avant le début de l'exécution et indique les tailles valides les plus proches.

Consultez l'entraînement pour les datasets, l'augmentation, le multi-GPU et les loggers.

Valider

val() renvoie un dictionnaire de clés metrics/ couvrant la précision, le rappel, la mAP 50 et la mAP 50-95, mesurés sur tout dataset dans le format utilisé pour l'entraînement.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # val() renvoie un simple dict, pas un objetmetrics = 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
Comparer à COCO
# Le YAML COCO inclus contient un script de téléchargement intégré ; une# autorisation explicite est requise sauf si le dataset est déjà local.libreyolo val model=LibreRFDETRn.pt data=coco.yaml imgsz=384 \  allow_download_scripts=True

Exporter

TâcheONNXTorchScriptExecuTorchTensorRTOpenVINOPaddleMNNRKNNncnnTFLiteCoreMLCore AI
DetectionDetection to ONNX : pris en chargeDetection to TorchScript : pris en chargeDetection to ExecuTorch : pris en chargeDetection to TensorRT : pris en charge. Runtime parity coverage lives in tests/e2e/test_tensorrt.py.Detection to OpenVINO : pris en charge. Runtime parity coverage lives in tests/e2e/test_openvino.py.Detection to Paddle : non pris en chargeDetection to MNN : pris en chargeDetection to RKNN : non pris en chargeDetection to ncnn : non pris en chargeDetection to TFLite : non pris en chargeDetection to CoreML : pris en charge. Conversion is available, but runtime parity requires a macOS runner.Detection to Core AI : pris en charge
Instance segmentationInstance segmentation to ONNX : pris en chargeInstance segmentation to TorchScript : pris en chargeInstance segmentation to ExecuTorch : pris en chargeInstance segmentation to TensorRT : pris en charge. A published Apache-2.0 trained segmentation checkpoint exports and reloads, but public top-k class membership changes.Instance segmentation to OpenVINO : pris en charge. After Hungarian query alignment, the converted-runtime element match rate is 69.0%, below the validation bar.Instance segmentation to Paddle : non pris en chargeInstance segmentation to MNN : non pris en chargeInstance segmentation to RKNN : non pris en chargeInstance segmentation to ncnn : non pris en chargeInstance segmentation to TFLite : non pris en chargeInstance segmentation to CoreML : non pris en chargeInstance segmentation to Core AI : non pris en charge
PosePose to ONNX : pris en chargePose to TorchScript : pris en chargePose to ExecuTorch : pris en chargePose to TensorRT : pris en charge. 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 : pris en charge. After Hungarian query alignment, the converted-runtime element match rate is 72.75%, below the validation bar.Pose to Paddle : non pris en chargePose to MNN : non pris en chargePose to RKNN : non pris en chargePose to ncnn : non pris en chargePose to TFLite : non pris en chargePose to CoreML : non pris en chargePose to Core AI : non pris en charge
Oriented boxesOriented boxes to ONNX : pris en chargeOriented boxes to TorchScript : pris en chargeOriented boxes to ExecuTorch : pris en chargeOriented boxes to TensorRT : pris en charge. A deterministic synthetic OBB fixture exports and reloads, but public top-k class membership changes.Oriented boxes to OpenVINO : pris en charge. After Hungarian query alignment, the converted-runtime element match rate is 91.25%, below the validation bar.Oriented boxes to Paddle : non pris en chargeOriented boxes to MNN : non pris en chargeOriented boxes to RKNN : non pris en chargeOriented boxes to ncnn : non pris en chargeOriented boxes to TFLite : non pris en chargeOriented boxes to CoreML : non pris en chargeOriented boxes to Core AI : non pris en charge

Un artefact exporté se recharge par LibreYOLO() à partir de son suffixe de fichier. Un fichier .onnx ou .engine se comporte donc comme un checkpoint et renvoie le même objet Results. L'exécution du graphe dans un runtime brut, sans installation de LibreYOLO, est également prise en charge, mais vous devez alors écrire vous-même le prétraitement et le post-traitement.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.export(format="onnx", imgsz=512)model.export(format="tensorrt", imgsz=512, half=True) # Arguments acceptés pour tous les formats :##   format    "onnx" | "torchscript" | "executorch" | "tensorrt"#             | "openvino" | "paddle" | "mnn" | "rknn" | "ncnn"#             | "tflite" | "coreml" | "coreai".#             "engine" est un alias de tensorrt, "litert" de tflite.#   imgsz     int ou (hauteur, largeur). Utilise par défaut la résolution#             native du checkpoint.#   batch     int, 1 par défaut.#   half      bool, export en FP16. False par défaut.#   int8      bool, export en INT8. False par défaut. Nécessite `data`.#   data      chemin d'un YAML de dataset pour calibrer int8.#   fraction  float, part du dataset de calibration. 1.0 par défaut.#   dynamic   bool, axes dynamiques. True par défaut.#   simplify  bool, simplification du graphe ONNX. True par défaut.#   opset     int, opset ONNX. Choisi par famille s'il n'est pas fourni.#   device    str, appareil de traçage. Utilise celui du modèle par défaut.#   output_path  str, nom dérivé du checkpoint par défaut.#   verbose   bool, False par défaut.#   allow_download_scripts  bool, False par défaut. Autorise le code#             Python d'un YAML de dataset qui doit être téléchargé.## Quelques formats acceptent leurs propres arguments, comme une plateforme# cible RKNN. Ils sont documentés sur la page de chaque format.
CLI
libreyolo export model=LibreRFDETRs.pt format=onnx imgsz=512libreyolo export model=LibreRFDETRs.pt format=tensorrt imgsz=512 half=True
Utiliser le fichier exporté
from libreyolo import LibreYOLO # La factory utilise le suffixe du fichier : un artefact exporté se charge# comme tout checkpoint et renvoie le même objet Results.model = LibreYOLO("LibreRFDETRs.onnx")result = model(SAMPLE_IMAGE) print(result.boxes.xyxy)
Sans LibreYOLO
import numpy as npimport onnxruntime as ort # L'exécution directe du graphe impose votre propre pré/post-traitement.# Inspectez la signature avant de connecter quoi que ce soit.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

Tous les fichiers de poids publiés pour cette famille.

FichierEntrée (px)Licence des poids
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

Tous les fichiers ci-dessus sont actuellement disponibles dans l<link>organisation LibreYOLO</link> et sont téléchargés à la première utilisation.

Licence

Vérifiez la licence dans le dépôt Hugging Face des poids précis que vous téléchargez. Chaque checkpoint de l<link>organisation LibreYOLO</link> en possède une, et elles ne sont pas toujours identiques au sein dune même famille. Ce dépôt fait autorité ; le résumé ci-dessous décrit les conditions applicables lors de la dernière vérification de cette page.

Ceci décrit les licences concernées et ne constitue pas un conseil juridique. Si la réponse a une importance commerciale, lisez vous-même les licences et consultez votre propre avocat.

Travail d'origine
RF-DETR, Roboflow
Licence du projet d'origine
Apache-2.0
Source du projet d'origine
github.com/roboflow/rf-detr
Code de LibreYOLO
MIT
Poids
Apache-2.0, republiés sur huggingface.co/LibreYOLO
Interprétation
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.

Citation

@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}
}

Copié depuis le bloc de citation des auteurs sur github.com/roboflow/rf-detr#citation.

Vérifié avec LibreYOLO v1.5.0. Les tableaux de support, les checkpoints et les chiffres de benchmark de cette page sont générés à partir de la bibliothèque publiée et des poids publiés, et non rédigés à la main.