## File: README.md # RF-DETR: Real-Time SOTA Object Detection, Instance Segmentation, and Keypoint Detection --- RF-DETR is a real-time transformer architecture for object detection, instance segmentation, and keypoint detection (preview) developed by Roboflow. Built on a DINOv2 vision transformer backbone, RF-DETR delivers state-of-the-art accuracy and latency trade-offs on [Microsoft COCO](https://cocodataset.org/#home) and [RF100-VL](https://github.com/roboflow/rf100-vl). RF-DETR uses a DINOv2 vision transformer backbone and supports object detection, instance segmentation, and keypoint detection (preview) in a single, consistent API. The open-source `rfdetr` package and Apache-designated models are released under Apache 2.0, while Plus components (`rfdetr_plus`, including RF-DETR-XL/2XL detection models) are licensed under PML 1.0. The published RF-DETR sizes were created with neural architecture search (NAS) — and the same NAS method is now available on the [Roboflow platform](https://app.roboflow.com/), so you can discover the best architecture for your own dataset. Learn more in the [NAS docs](https://docs.roboflow.com/train/neural-architecture-search). https://github.com/user-attachments/assets/add23fd1-266f-4538-8809-d7dd5767e8e6 ## Install To install RF-DETR, install the `rfdetr` package in a [**Python>=3.10**](https://www.python.org/) environment with `pip`. ```bash pip install rfdetr ``` Install from source By installing RF-DETR from source, you can explore the most recent features and enhancements that have not yet been officially released. **Please note that these updates are still in development and may not be as stable as the latest published release.** ```bash pip install https://github.com/roboflow/rf-detr/archive/refs/heads/develop.zip ``` ## Benchmarks RF-DETR achieves state-of-the-art results in both object detection and instance segmentation, with benchmarks reported on Microsoft COCO and RF100-VL (RF100-VL for detection only). The charts and tables below compare RF-DETR against other top real-time models across accuracy and latency for detection and segmentation. All COCO accuracy numbers are measured in-house for every model shown, computed with pycocotools in SAB over the full 5,000-image `val2017` split, so every row is directly comparable and may differ from vendor-reported figures. The sole exception is rows marked †, which are quoted from the original authors' paper and were not measured in SAB. All latency numbers were measured on an NVIDIA T4 using TensorRT, FP16, and batch size 1. Parameter counts are deployment (fused) `nn.Module` parameter counts (`model.parameters()`, not the raw tensor count of the saved checkpoint), except rows marked †, which are the authors' reported counts. For full benchmarking methodology and reproducibility details, see [roboflow/sab](https://github.com/roboflow/single_artifact_benchmarking). ### Detection See object detection benchmark numbers | Architecture | COCO AP50 | COCO AP50:95 | RF100VL AP50 | RF100VL AP50:95 | Latency (ms) | Params (M) | Resolution | License | | :-----------: | :------------------: | :---------------------: | :---------------------: | :------------------------: | :----------: | :--------: | :--------: | :--------: | | RF-DETR-N | 67.6 | 48.4 | 85.0 | 57.7 | 2.3 | 30.5 | 384x384 | Apache 2.0 | | RF-DETR-S | 72.1 | 53.0 | 86.7 | 60.2 | 3.5 | 32.1 | 512x512 | Apache 2.0 | | RF-DETR-M | 73.6 | 54.7 | 87.4 | 61.2 | 4.4 | 33.7 | 576x576 | Apache 2.0 | | RF-DETR-L | 75.1 | 56.5 | 88.2 | 62.2 | 6.8 | 33.9 | 704x704 | Apache 2.0 | | RF-DETR-XL △ | 77.4 | 58.6 | 88.5 | 62.9 | 11.5 | 126.4 | 700x700 | PML 1.0 | | RF-DETR-2XL △ | 78.5 | 60.1 | 89.0 | 63.2 | 17.2 | 126.9 | 880x880 | PML 1.0 | | YOLO11-N | 52.0 | 37.4 | 81.4 | 55.3 | 2.5 | 2.6 | 640x640 | AGPL-3.0 | | YOLO11-S | 59.7 | 44.4 | 82.3 | 56.2 | 3.2 | 9.4 | 640x640 | AGPL-3.0 | | YOLO11-M | 64.1 | 48.6 | 82.5 | 56.5 | 5.1 | 20.1 | 640x640 | AGPL-3.0 | | YOLO11-L | 64.9 | 49.9 | 82.2 | 56.5 | 6.5 | 25.3 | 640x640 | AGPL-3.0 | | YOLO11-X | 66.1 | 50.9 | 81.7 | 56.2 | 10.5 | 56.9 | 640x640 | AGPL-3.0 | | YOLO26-N | 55.8 | 40.3 | 76.7 | 52.0 | 1.7 | 2.6 | 640x640 | AGPL-3.0 | | YOLO26-S | 64.3 | 47.7 | 82.7 | 57.0 | 2.6 | 9.4 | 640x640 | AGPL-3.0 | | YOLO26-M | 69.7 | 52.5 | 84.4 | 58.7 | 4.4 | 20.1 | 640x640 | AGPL-3.0 | | YOLO26-L | 71.1 | 54.1 | 85.0 | 59.3 | 5.7 | 25.3 | 640x640 | AGPL-3.0 | | YOLO26-X | 74.0 | 56.9 | 85.6 | 60.0 | 9.6 | 56.9 | 640x640 | AGPL-3.0 | | LW-DETR-T | 60.7 | 42.9 | 84.7 | 57.1 | 1.9 | 12.1 | 640x640 | Apache 2.0 | | LW-DETR-S | 66.8 | 48.0 | 85.0 | 57.4 | 2.6 | 14.6 | 640x640 | Apache 2.0 | | LW-DETR-M | 72.0 | 52.6 | 86.8 | 59.8 | 4.4 | 28.2 | 640x640 | Apache 2.0 | | LW-DETR-L | 74.6 | 56.1 | 87.4 | 61.5 | 6.9 | 46.8 | 640x640 | Apache 2.0 | | LW-DETR-X | 76.9 | 58.3 | 87.9 | 62.1 | 13.0 | 118.0 | 640x640 | Apache 2.0 | | D-FINE-N | 60.2 | 42.7 | 84.4 | 58.2 | 2.1 | 3.8 | 640x640 | Apache 2.0 | | D-FINE-S | 67.6 | 50.6 | 85.3 | 60.3 | 3.5 | 10.2 | 640x640 | Apache 2.0 | | D-FINE-M | 72.6 | 55.0 | 85.5 | 60.6 | 5.4 | 19.2 | 640x640 | Apache 2.0 | | D-FINE-L | 74.9 | 57.2 | 86.4 | 61.6 | 7.5 | 31.0 | 640x640 | Apache 2.0 | | D-FINE-X | 76.8 | 59.3 | 86.9 | 62.2 | 11.5 | 62.0 | 640x640 | Apache 2.0 | | SAM 3 † | — | — | — | 61.6 | — | ~850 | 1008x1008 | N/A | > † Reported by the SAM 3 authors ([arXiv:2511.16719](https://arxiv.org/abs/2511.16719), Table 36), **not** measured by us in SAB. The value is SAM 3 fine-tuned on the full RF100-VL training set, which is the same setting as the RF100VL columns above — SAM 3's paper reports LW-DETR-m at 59.8 on this benchmark, matching our own measurement, so the numbers line up. Dashes mark results SAM 3 does not report under this protocol. Parameter count is the paper's stated ~850 M (~450 M vision + ~300 M text encoders + ~100 M detector/tracker). ### Segmentation See instance segmentation benchmark numbers | Architecture | COCO AP50 | COCO AP50:95 | Latency (ms) | Params (M) | Resolution | License | | :-------------: | :------------------: | :---------------------: | :----------: | :--------: | :--------: | :--------: | | RF-DETR-Seg-N | 63.0 | 40.3 | 3.4 | 33.6 | 312x312 | Apache 2.0 | | RF-DETR-Seg-S | 66.2 | 43.1 | 4.4 | 33.7 | 384x384 | Apache 2.0 | | RF-DETR-Seg-M | 68.4 | 45.3 | 5.9 | 35.7 | 432x432 | Apache 2.0 | | RF-DETR-Seg-L | 70.5 | 47.1 | 8.8 | 36.2 | 504x504 | Apache 2.0 | | RF-DETR-Seg-XL | 72.2 | 48.8 | 13.5 | 38.1 | 624x624 | Apache 2.0 | | RF-DETR-Seg-2XL | 73.1 | 49.9 | 21.8 | 38.6 | 768x768 | Apache 2.0 | | YOLOv8-N-Seg | 45.6 | 28.3 | 3.5 | 3.4 | 640x640 | AGPL-3.0 | | YOLOv8-S-Seg | 53.8 | 34.0 | 4.2 | 11.8 | 640x640 | AGPL-3.0 | | YOLOv8-M-Seg | 58.2 | 37.3 | 7.0 | 27.3 | 640x640 | AGPL-3.0 | | YOLOv8-L-Seg | 60.5 | 39.0 | 9.7 | 46.0 | 640x640 | AGPL-3.0 | | YOLOv8-XL-Seg | 61.3 | 39.5 | 14.0 | 71.8 | 640x640 | AGPL-3.0 | | YOLOv11-N-Seg | 47.8 | 30.0 | 3.6 | 2.9 | 640x640 | AGPL-3.0 | | YOLOv11-S-Seg | 55.4 | 35.0 | 4.6 | 10.1 | 640x640 | AGPL-3.0 | | YOLOv11-M-Seg | 60.0 | 38.5 | 6.9 | 22.4 | 640x640 | AGPL-3.0 | | YOLOv11-L-Seg | 61.5 | 39.5 | 8.3 | 27.6 | 640x640 | AGPL-3.0 | | YOLOv11-XL-Seg | 62.4 | 40.1 | 13.7 | 62.1 | 640x640 | AGPL-3.0 | | YOLO26-N-Seg | 54.3 | 34.7 | 2.31 | 2.7 | 640x640 | AGPL-3.0 | | YOLO26-S-Seg | 62.4 | 40.2 | 3.47 | 10.4 | 640x640 | AGPL-3.0 | | YOLO26-M-Seg | 67.8 | 44.0 | 6.32 | 23.6 | 640x640 | AGPL-3.0 | | YOLO26-L-Seg | 69.8 | 45.5 | 7.58 | 28.0 | 640x640 | AGPL-3.0 | | YOLO26-X-Seg | 71.6 | 46.8 | 12.92 | 62.8 | 640x640 | AGPL-3.0 | ### Keypoints See keypoint detection benchmark numbers | Architecture | COCO AP50:95 | Latency (ms) | Params (M) | License | | :------------------------: | :---------------------: | :----------: | :--------: | :--------: | | RF-DETR Keypoint (Preview) | 71.8 | 9.7 | 40.7 | Apache 2.0 | | YOLO11-pose N | 48.9 | 3.2 | 2.9 | AGPL-3.0 | | YOLO11-pose S | 57.5 | 3.4 | 9.9 | AGPL-3.0 | | YOLO11-pose M | 64.2 | 5.2 | 20.9 | AGPL-3.0 | | YOLO11-pose L | 65.2 | 6.6 | 26.2 | AGPL-3.0 | | YOLO11-pose X | 68.6 | 10.6 | 58.8 | AGPL-3.0 | | YOLO26-pose N | 55.9 | 1.9 | 2.9 | AGPL-3.0 | | YOLO26-pose S | 62.0 | 2.7 | 10.4 | AGPL-3.0 | | YOLO26-pose M | 68.0 | 4.6 | 21.5 | AGPL-3.0 | | YOLO26-pose L | 69.2 | 5.9 | 25.9 | AGPL-3.0 | | YOLO26-pose X | 71.0 | 9.8 | 57.6 | AGPL-3.0 | > Keypoint benchmarks report AP50:95 (OKS-based); this is the standard COCO keypoint comparison metric. ### NAS on the Roboflow Platform Since the paper release, we have improved RF-DETR NAS training on the Roboflow platform even further. A single training run gives you every model size, with results that beat not only the open-source checkpoints but also our own paper NAS results. [Try it now!](https://roboflow.com/) ## Run Models ### Detection RF-DETR provides multiple model sizes, ranging from Nano to 2XLarge. To use a different model size, replace the class name in the code snippet below with another class from the table. ```python import supervision as sv from rfdetr import RFDETRMedium from rfdetr.assets.coco_classes import COCO_CLASSES model = RFDETRMedium() detections = model.predict("https://media.roboflow.com/dog.jpg", threshold=0.5) labels = [f"{COCO_CLASSES[class_id]}" for class_id in detections.class_id] annotated_image = sv.BoxAnnotator().annotate(detections.metadata["source_image"], detections) annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels) ``` > **Note:** `COCO_CLASSES` works for COCO-pretrained models. For fine-tuned models, use `detections.data["class_name"]` instead — it resolves class names from the checkpoint and works for both COCO and custom datasets. Run RF-DETR with Inference You can also run RF-DETR models using the Inference library. To switch model size, select the appropriate inference package alias from the table below. ```python import requests import supervision as sv from PIL import Image from inference import get_model model = get_model("rfdetr-medium") image = Image.open(requests.get("https://media.roboflow.com/dog.jpg", stream=True).raw) predictions = model.infer(image, confidence=0.5)[0] detections = sv.Detections.from_inference(predictions) annotated_image = sv.BoxAnnotator().annotate(image, detections) annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections) ``` | Size | RF-DETR package class | Inference package alias | COCO AP50 | COCO AP50:95 | Latency (ms) | Params (M) | Resolution | License | | :--: | :-------------------: | :---------------------- | :------------------: | :---------------------: | :----------: | :--------: | :--------: | :--------: | | N | `RFDETRNano` | `rfdetr-nano` | 67.6 | 48.4 | 2.3 | 30.5 | 384x384 | Apache 2.0 | | S | `RFDETRSmall` | `rfdetr-small` | 72.1 | 53.0 | 3.5 | 32.1 | 512x512 | Apache 2.0 | | M | `RFDETRMedium` | `rfdetr-medium` | 73.6 | 54.7 | 4.4 | 33.7 | 576x576 | Apache 2.0 | | L | `RFDETRLarge` | `rfdetr-large` | 75.1 | 56.5 | 6.8 | 33.9 | 704x704 | Apache 2.0 | | XL | `RFDETRXLarge` △ | `rfdetr-xlarge` | 77.4 | 58.6 | 11.5 | 126.4 | 700x700 | PML 1.0 | | 2XL | `RFDETR2XLarge` △ | `rfdetr-2xlarge` | 78.5 | 60.1 | 17.2 | 126.9 | 880x880 | PML 1.0 | > △ Requires the `rfdetr_plus` extension: `pip install rfdetr[plus]`. See [License](#license) for details. ### Segmentation RF-DETR supports instance segmentation with model sizes from Nano to 2XLarge. To use a different model size, replace the class name in the code snippet below with another class from the table. ```python import supervision as sv from rfdetr import RFDETRSegMedium from rfdetr.assets.coco_classes import COCO_CLASSES model = RFDETRSegMedium() detections = model.predict("https://media.roboflow.com/dog.jpg", threshold=0.5) labels = [f"{COCO_CLASSES[class_id]}" for class_id in detections.class_id] annotated_image = sv.MaskAnnotator().annotate(detections.metadata["source_image"], detections) annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels) ``` Run RF-DETR-Seg with Inference You can also run RF-DETR-Seg models using the Inference library. To switch model size, select the appropriate inference package alias from the table below. ```python import requests import supervision as sv from PIL import Image from inference import get_model model = get_model("rfdetr-seg-medium") image = Image.open(requests.get("https://media.roboflow.com/dog.jpg", stream=True).raw) predictions = model.infer(image, confidence=0.5)[0] detections = sv.Detections.from_inference(predictions) annotated_image = sv.MaskAnnotator().annotate(image, detections) annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections) ``` | Size | RF-DETR package class | Inference package alias | COCO AP50 | COCO AP50:95 | Latency (ms) | Params (M) | Resolution | License | | :--: | :-------------------: | :---------------------- | :------------------: | :---------------------: | :----------: | :--------: | :--------: | :--------: | | N | `RFDETRSegNano` | `rfdetr-seg-nano` | 63.0 | 40.3 | 3.4 | 33.6 | 312x312 | Apache 2.0 | | S | `RFDETRSegSmall` | `rfdetr-seg-small` | 66.2 | 43.1 | 4.4 | 33.7 | 384x384 | Apache 2.0 | | M | `RFDETRSegMedium` | `rfdetr-seg-medium` | 68.4 | 45.3 | 5.9 | 35.7 | 432x432 | Apache 2.0 | | L | `RFDETRSegLarge` | `rfdetr-seg-large` | 70.5 | 47.1 | 8.8 | 36.2 | 504x504 | Apache 2.0 | | XL | `RFDETRSegXLarge` | `rfdetr-seg-xlarge` | 72.2 | 48.8 | 13.5 | 38.1 | 624x624 | Apache 2.0 | | 2XL | `RFDETRSeg2XLarge` | `rfdetr-seg-2xlarge` | 73.1 | 49.9 | 21.8 | 38.6 | 768x768 | Apache 2.0 | ### Keypoints RF-DETR supports keypoint detection (preview) with `RFDETRKeypointPreview`, pretrained on COCO person keypoints. ```python from rfdetr import RFDETRKeypointPreview model = RFDETRKeypointPreview() key_points = model.predict("image.jpg", threshold=0.5) ``` | Size | RF-DETR package class | COCO AP50:95 | Latency (ms) | Params (M) | Resolution | License | | :----------------: | :---------------------: | :---------------------: | :----------: | :--------: | :--------: | :--------: | | Keypoint (Preview) | `RFDETRKeypointPreview` | 71.8 | 9.7 | 40.7 | 576x576 | Apache 2.0 | ### Train Models RF-DETR supports training for object detection, instance segmentation, and keypoint detection (preview). You can train models in [Google Colab](https://colab.research.google.com/github/roboflow-ai/notebooks/blob/main/notebooks/how-to-finetune-rf-detr-on-detection-dataset.ipynb) or directly on the Roboflow platform. Below you will find a step-by-step video fine-tuning tutorial. [](https://youtu.be/-OvpdLAElFA) ## Documentation Visit our [documentation website](https://rfdetr.roboflow.com) to learn more about how to use RF-DETR. ## License Licensing is split by component: - The open-source `rfdetr` package and Apache-designated model weights are licensed under Apache License 2.0. See [`LICENSE`](LICENSE). - Plus components, including the `rfdetr_plus` extension and RF-DETR-XL / RF-DETR-2XL detection models, are licensed under PML 1.0. ## Acknowledgements Our work is built upon [LW-DETR](https://arxiv.org/pdf/2406.03459), [DINOv2](https://arxiv.org/pdf/2304.07193), and [Deformable DETR](https://arxiv.org/pdf/2010.04159). Thanks to their authors for their excellent work! ## Citation If you find our work helpful for your research, please consider citing the following BibTeX entry. ```bibtex @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} } ``` ## Contribute We welcome and appreciate all contributions! If you notice any issues or bugs, have questions, or would like to suggest new features, please [open an issue](https://github.com/roboflow/rf-detr/issues/new) or pull request. By sharing your ideas and improvements, you help make RF-DETR better for everyone. --- ## File: docs/learn/benchmarks.md --- --- # Benchmarks !!! tip "Key Takeaways" - RF-DETR-2XL achieves 60.1 AP50:95 on COCO detection at 17.2 ms latency (T4, TensorRT FP16) - RF-DETR-L outperforms YOLOv11x (56.5 vs 50.9 AP50:95) at lower latency (6.8 vs 10.5 ms) - Segmentation models range from 40.3 AP (Nano, 3.4 ms) to 49.9 AP (2XL, 21.8 ms) on COCO - All latency measured on NVIDIA T4 with TensorRT 10.4, CUDA 12.4, FP16, batch size 1 - RF100-VL results demonstrate strong domain-shift generalization across 100 diverse datasets - RF-DETR Keypoint (Preview) achieves 71.8 AP50:95 on COCO person keypoints at 9.7 ms (T4, TensorRT FP16) This page reports RF-DETR benchmark results for object detection, instance segmentation, and keypoint detection on Microsoft COCO and RF100-VL (detection only). All benchmark numbers and plots match the latest released checkpoints and tables shown below. Latency values are measured on an NVIDIA T4 with TensorRT in FP16 at batch size 1. For full methodology details and architectural context, see the RF-DETR paper. ## Methodology Accuracy is reported using standard COCO metrics computed with pycocotools. For object detection, we report COCO AP50 and COCO AP50:95, and the same metrics are also reported for RF100-VL. COCO results are evaluated on the validation split, following common practice in detector benchmarking. Every model on this page — including third-party models — is re-evaluated in-house with pycocotools in [roboflow/sab](https://github.com/roboflow/single_artifact_benchmarking) under this same protocol, scored over the full 5,000-image `val2017` split, so all rows are directly comparable; numbers may therefore differ from vendor-reported figures. The sole exception is rows marked †, which are quoted from the original authors' paper and were not run through SAB; these are flagged in the table footnote and should be read as author-reported rather than independently reproduced. RF100-VL results are averaged across all 100 datasets to reflect performance under diverse real-world data distributions. Latency is measured as single-image inference latency rather than sustained throughput. All latency numbers are obtained on an NVIDIA T4 GPU using TensorRT 10.4 and CUDA 12.4 with FP16 inference and batch size 1. To reduce variance caused by GPU power throttling and thermal effects, a 200 ms buffer is inserted between consecutive forward passes. This procedure improves reproducibility of latency measurements but is not intended to measure maximum throughput. Accuracy and latency are always measured using the same model artifact and the same numerical precision. This avoids reporting FP32 accuracy together with FP16 latency, which can lead to misleading comparisons because naive FP16 conversion can significantly degrade accuracy for some models. !!! info "Metric definitions" **AP50**: Detection accuracy at IoU threshold >= 0.50. **AP50:95**: Mean accuracy averaged over IoU thresholds 0.50 to 0.95 (step 0.05) — the primary COCO metric. **Params (M)**: Deployment (fused) `nn.Module` parameter count (`model.parameters()`) in millions, excluding training-only branches and folded normalization layers, and counting model parameters rather than the raw tensor count of the saved checkpoint. Rows marked † use the authors' reported counts rather than SAB-measured values. Latency measured on NVIDIA T4, TensorRT 10.4, CUDA 12.4, FP16, batch size 1, with 200 ms thermal buffer between passes to reduce GPU thermal variance. ## Detection | Architecture | COCO AP50 | COCO AP50:95 | RF100VL AP50 | RF100VL AP50:95 | Latency (ms) | Params (M) | Resolution | | :----------: | :------------------: | :---------------------: | :---------------------: | :------------------------: | :----------: | :--------: | :--------: | | RF-DETR-N | 67.6 | 48.4 | 85.0 | 57.7 | 2.3 | 30.5 | 384x384 | | RF-DETR-S | 72.1 | 53.0 | 86.7 | 60.2 | 3.5 | 32.1 | 512x512 | | RF-DETR-M | 73.6 | 54.7 | 87.4 | 61.2 | 4.4 | 33.7 | 576x576 | | RF-DETR-L | 75.1 | 56.5 | 88.2 | 62.2 | 6.8 | 33.9 | 704x704 | | RF-DETR-XL | 77.4 | 58.6 | 88.5 | 62.9 | 11.5 | 126.4 | 700x700 | | RF-DETR-2XL | 78.5 | 60.1 | 89.0 | 63.2 | 17.2 | 126.9 | 880x880 | | YOLO11-N | 52.0 | 37.4 | 81.4 | 55.3 | 2.5 | 2.6 | 640x640 | | YOLO11-S | 59.7 | 44.4 | 82.3 | 56.2 | 3.2 | 9.4 | 640x640 | | YOLO11-M | 64.1 | 48.6 | 82.5 | 56.5 | 5.1 | 20.1 | 640x640 | | YOLO11-L | 64.9 | 49.9 | 82.2 | 56.5 | 6.5 | 25.3 | 640x640 | | YOLO11-X | 66.1 | 50.9 | 81.7 | 56.2 | 10.5 | 56.9 | 640x640 | | YOLO26-N | 55.8 | 40.3 | 76.7 | 52.0 | 1.7 | 2.6 | 640x640 | | YOLO26-S | 64.3 | 47.7 | 82.7 | 57.0 | 2.6 | 9.4 | 640x640 | | YOLO26-M | 69.7 | 52.5 | 84.4 | 58.7 | 4.4 | 20.1 | 640x640 | | YOLO26-L | 71.1 | 54.1 | 85.0 | 59.3 | 5.7 | 25.3 | 640x640 | | YOLO26-X | 74.0 | 56.9 | 85.6 | 60.0 | 9.6 | 56.9 | 640x640 | | LW-DETR-T | 60.7 | 42.9 | 84.7 | 57.1 | 1.9 | 12.1 | 640x640 | | LW-DETR-S | 66.8 | 48.0 | 85.0 | 57.4 | 2.6 | 14.6 | 640x640 | | LW-DETR-M | 72.0 | 52.6 | 86.8 | 59.8 | 4.4 | 28.2 | 640x640 | | LW-DETR-L | 74.6 | 56.1 | 87.4 | 61.5 | 6.9 | 46.8 | 640x640 | | LW-DETR-X | 76.9 | 58.3 | 87.9 | 62.1 | 13.0 | 118.0 | 640x640 | | D-FINE-N | 60.2 | 42.7 | 84.4 | 58.2 | 2.1 | 3.8 | 640x640 | | D-FINE-S | 67.6 | 50.6 | 85.3 | 60.3 | 3.5 | 10.2 | 640x640 | | D-FINE-M | 72.6 | 55.0 | 85.5 | 60.6 | 5.4 | 19.2 | 640x640 | | D-FINE-L | 74.9 | 57.2 | 86.4 | 61.6 | 7.5 | 31.0 | 640x640 | | D-FINE-X | 76.8 | 59.3 | 86.9 | 62.2 | 11.5 | 62.0 | 640x640 | | SAM 3 † | — | — | — | 61.6 | — | ~850 | 1008x1008 | > † Reported by the SAM 3 authors ([arXiv:2511.16719](https://arxiv.org/abs/2511.16719), Table 36), **not** measured by us in SAB. The value is SAM 3 fine-tuned on the full RF100-VL training set — the same fully-supervised setting as the RF100VL columns above, and distinct from the 15.2 zero-shot / 36.5 10-shot numbers in the paper's main table. SAM 3's paper independently reports LW-DETR-m at 59.8 on this benchmark, matching our own measurement, which confirms the protocols align. Dashes mark results SAM 3 does not report under this protocol. Parameter count is the paper's stated ~850 M (~450 M vision + ~300 M text encoders + ~100 M detector/tracker). ## Segmentation | Architecture | COCO AP50 | COCO AP50:95 | Latency (ms) | Params (M) | Resolution | | :-------------: | :------------------: | :---------------------: | :----------: | :--------: | :--------: | | RF-DETR-Seg-N | 63.0 | 40.3 | 3.4 | 33.6 | 312x312 | | RF-DETR-Seg-S | 66.2 | 43.1 | 4.4 | 33.7 | 384x384 | | RF-DETR-Seg-M | 68.4 | 45.3 | 5.9 | 35.7 | 432x432 | | RF-DETR-Seg-L | 70.5 | 47.1 | 8.8 | 36.2 | 504x504 | | RF-DETR-Seg-XL | 72.2 | 48.8 | 13.5 | 38.1 | 624x624 | | RF-DETR-Seg-2XL | 73.1 | 49.9 | 21.8 | 38.6 | 768x768 | | YOLOv8-N-Seg | 45.6 | 28.3 | 3.5 | 3.4 | 640x640 | | YOLOv8-S-Seg | 53.8 | 34.0 | 4.2 | 11.8 | 640x640 | | YOLOv8-M-Seg | 58.2 | 37.3 | 7.0 | 27.3 | 640x640 | | YOLOv8-L-Seg | 60.5 | 39.0 | 9.7 | 46.0 | 640x640 | | YOLOv8-XL-Seg | 61.3 | 39.5 | 14.0 | 71.8 | 640x640 | | YOLOv11-N-Seg | 47.8 | 30.0 | 3.6 | 2.9 | 640x640 | | YOLOv11-S-Seg | 55.4 | 35.0 | 4.6 | 10.1 | 640x640 | | YOLOv11-M-Seg | 60.0 | 38.5 | 6.9 | 22.4 | 640x640 | | YOLOv11-L-Seg | 61.5 | 39.5 | 8.3 | 27.6 | 640x640 | | YOLOv11-XL-Seg | 62.4 | 40.1 | 13.7 | 62.1 | 640x640 | | YOLO26-N-Seg | 54.3 | 34.7 | 2.31 | 2.7 | 640x640 | | YOLO26-S-Seg | 62.4 | 40.2 | 3.47 | 10.4 | 640x640 | | YOLO26-M-Seg | 67.8 | 44.0 | 6.32 | 23.6 | 640x640 | | YOLO26-L-Seg | 69.8 | 45.5 | 7.58 | 28.0 | 640x640 | | YOLO26-X-Seg | 71.6 | 46.8 | 12.92 | 62.8 | 640x640 | ## Keypoints | Architecture | COCO AP50:95 | Latency (ms) | Params (M) | | :------------------------: | :---------------------: | :----------: | :--------: | | RF-DETR Keypoint (Preview) | 71.8 | 9.7 | 40.7 | | YOLO11-pose N | 48.9 | 3.2 | 2.9 | | YOLO11-pose S | 57.5 | 3.4 | 9.9 | | YOLO11-pose M | 64.2 | 5.2 | 20.9 | | YOLO11-pose L | 65.2 | 6.6 | 26.2 | | YOLO11-pose X | 68.6 | 10.6 | 58.8 | | YOLO26-pose N | 55.9 | 1.9 | 2.9 | | YOLO26-pose S | 62.0 | 2.7 | 10.4 | | YOLO26-pose M | 68.0 | 4.6 | 21.5 | | YOLO26-pose L | 69.2 | 5.9 | 25.9 | | YOLO26-pose X | 71.0 | 9.8 | 57.6 | > Keypoint benchmarks report AP50:95 (OKS-based); this is the standard COCO keypoint comparison metric. --- ## File: docs/learn/deploy.md --- --- # Deploy a Trained RF-DETR Model !!! tip "Key Takeaways" - Deploy fine-tuned RF-DETR models to Roboflow with a single `deploy_to_roboflow()` call - Supports both detection and segmentation model deployment - Run deployed models via Roboflow Inference on cloud, edge hardware, or NVIDIA Jetson - Model weights are cached locally after the first inference run for fast subsequent predictions You can deploy a fine-tuned RF-DETR model to Roboflow. Deploying to Roboflow allows you to create multi-step computer vision applications that run both in the cloud and your own hardware. To deploy your model to Roboflow, run: === "Object Detection" ```python from rfdetr import RFDETRNano x = RFDETRNano(pretrain_weights="") x.deploy_to_roboflow( workspace="", project_id="", api_key="", ) ``` === "Image Segmentation" ```python from rfdetr import RFDETRSegMedium x = RFDETRSegMedium(pretrain_weights="") x.deploy_to_roboflow( workspace="", project_id="", api_key="", ) ``` Above, set your Roboflow Workspace ID, the ID of the project to which you want to upload your model, and your Roboflow API key. By default the model is deployed to the project's latest dataset version; pass `version=` to target a specific one. A project with no generated versions falls back to version `1`, for which the Roboflow SDK raises its usual error. - [Learn how to find your Workspace and Project ID.](https://docs.roboflow.com/developer/authentication/workspace-and-project-ids) - [Learn how to find your API key.](https://docs.roboflow.com/developer/authentication/find-your-roboflow-api-key) You can then run your model with Roboflow Inference: === "Object Detection" ```python import supervision as sv from inference import get_model from PIL import Image from io import BytesIO import requests url = "https://media.roboflow.com/dog.jpeg" image = Image.open(BytesIO(requests.get(url).content)) model = get_model("rfdetr-large") # replace with your Roboflow model ID predictions = model.infer(image, confidence=0.5)[0] detections = sv.Detections.from_inference(predictions) labels = [prediction.class_name for prediction in predictions.predictions] 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) ``` === "Image Segmentation" ```python import supervision as sv from inference import get_model from PIL import Image from io import BytesIO import requests url = "https://media.roboflow.com/dog.jpeg" image = Image.open(BytesIO(requests.get(url).content)) model = get_model("rfdetr-seg-small") # replace with your Roboflow model ID predictions = model.infer(image, confidence=0.5)[0] detections = sv.Detections.from_inference(predictions) labels = [prediction.class_name for prediction in predictions.predictions] annotated_image = image.copy() annotated_image = sv.MaskAnnotator().annotate(annotated_image, detections) annotated_image = sv.LabelAnnotator().annotate(annotated_image, detections, labels) sv.plot_image(annotated_image) ``` Above, replace `rfdetr-large` with the your Roboflow model ID. You can find this ID from the "Models" list in your Roboflow dashboard: When you first run this model, your model weights will be cached for local use with Inference. You will then see the results from your fine-tuned model. --- ## File: docs/learn/pretrained.md --- --- You can run any of the four supported RF-DETR base models -- Nano, Small, Medium, Large -- with [Inference](https://github.com/roboflow/inference), an open source computer vision inference server. The base models are trained on the [Microsoft COCO dataset](https://universe.roboflow.com/microsoft/coco). XLarge and 2XLarge detection models are also available via `pip install rfdetr[plus]` and are provided under the PML 1.0 license. === "Run on an Image" To run RF-DETR on an image, use the following code: ```python import os import supervision as sv from inference import get_model from PIL import Image from io import BytesIO import requests url = "https://media.roboflow.com/dog.jpeg" image = Image.open(BytesIO(requests.get(url).content)) model = get_model("rfdetr-large") predictions = model.infer(image, confidence=0.5)[0] detections = sv.Detections.from_inference(predictions) labels = [prediction.class_name for prediction in predictions.predictions] 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) ``` Above, replace the image URL with any image you want to use with the model. Here are the results from the code above:
{ width=300 }
RF-DETR Base predictions
=== "Run on a Video File" To run RF-DETR on a video file, use the following code: ```python import supervision as sv from rfdetr import RFDETRMedium from rfdetr.assets.coco_classes import COCO_CLASSES model = RFDETRMedium() def callback(frame, index): detections = model.predict(frame[:, :, ::-1], threshold=0.5) labels = [ f"{COCO_CLASSES[class_id]} {confidence:.2f}" for class_id, confidence in zip(detections.class_id, detections.confidence) ] annotated_frame = frame.copy() annotated_frame = sv.BoxAnnotator().annotate(annotated_frame, detections) annotated_frame = sv.LabelAnnotator().annotate(annotated_frame, detections, labels) return annotated_frame sv.process_video( source_path="", target_path="", callback=callback, ) ``` Above, set your `SOURCE_VIDEO_PATH` and `TARGET_VIDEO_PATH` to the directories of the video you want to process and where you want to save the results from inference, respectively. === "Run on a Webcam Stream" To run RF-DETR on a webcam input, use the following code: ```python import cv2 import supervision as sv from rfdetr import RFDETRMedium from rfdetr.assets.coco_classes import COCO_CLASSES model = RFDETRMedium() cap = cv2.VideoCapture(0) while True: success, frame = cap.read() if not success: break detections = model.predict(frame[:, :, ::-1], threshold=0.5) labels = [ f"{COCO_CLASSES[class_id]} {confidence:.2f}" for class_id, confidence in zip(detections.class_id, detections.confidence) ] annotated_frame = frame.copy() annotated_frame = sv.BoxAnnotator().annotate(annotated_frame, detections) annotated_frame = sv.LabelAnnotator().annotate(annotated_frame, detections, labels) cv2.imshow("Webcam", annotated_frame) if cv2.waitKey(1) & 0xFF == ord("q"): break cap.release() cv2.destroyAllWindows() ``` === "Run on an RTSP Stream" To run RF-DETR on an RTSP (Real Time Streaming Protocol) stream, use the following code: ```python import cv2 import supervision as sv from rfdetr import RFDETRMedium from rfdetr.assets.coco_classes import COCO_CLASSES model = RFDETRMedium() cap = cv2.VideoCapture("") while True: success, frame = cap.read() if not success: break detections = model.predict(frame[:, :, ::-1], threshold=0.5) labels = [ f"{COCO_CLASSES[class_id]} {confidence:.2f}" for class_id, confidence in zip(detections.class_id, detections.confidence) ] annotated_frame = frame.copy() annotated_frame = sv.BoxAnnotator().annotate(annotated_frame, detections) annotated_frame = sv.LabelAnnotator().annotate(annotated_frame, detections, labels) cv2.imshow("RTSP Stream", annotated_frame) if cv2.waitKey(1) & 0xFF == ord("q"): break cap.release() cv2.destroyAllWindows() ``` You can change the RF-DETR model that the code snippet above uses. To do so, update `rfdetr-small` to any of the following values: - `rfdetr-nano` - `rfdetr-small` - `rfdetr-medium` - `rfdetr-large` ## Batch Inference You can provide `.predict()` with either a single image or a list of images. When multiple images are supplied, they are processed together in a single forward pass, resulting in a corresponding list of detections. ```python import io import requests import supervision as sv from PIL import Image from rfdetr import RFDETRMedium from rfdetr.assets.coco_classes import COCO_CLASSES model = RFDETRMedium() urls = [ "https://media.roboflow.com/notebooks/examples/dog-2.jpeg", "https://media.roboflow.com/notebooks/examples/dog-3.jpeg", ] images = [Image.open(io.BytesIO(requests.get(url).content)) for url in urls] detections_list = model.predict(images, threshold=0.5) for image, detections in zip(images, detections_list): labels = [ f"{COCO_CLASSES[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) ``` --- ## File: docs/reference/large.md --- --- :::rfdetr.variants.RFDETRLarge options: inherited_members: true --- ## File: docs/reference/medium.md --- --- :::rfdetr.variants.RFDETRMedium options: inherited_members: true --- ## File: docs/reference/nano.md --- --- :::rfdetr.variants.RFDETRNano options: inherited_members: true --- ## File: docs/reference/rfdetr.md --- --- :::rfdetr.detr.RFDETR