RF-DETR

Detection transformer yang memprediksi sekumpulan objek tetap, bukan grid padat, sehingga tidak memerlukan NMS saat inferensi. LibreYOLO mendukungnya untuk empat task.

Task: detection, instance segmentation, pose, oriented boxes
Ukuran: n, s, m, l for detection and oriented boxes; n through xx for segmentation; x for pose
Instalasi: pip install "libreyolo[rfdetr]"
Tier dukungan: Unggulan, sejak v1.0.0. Fitur dirancang dan divalidasi sepenuhnya pada GPU di sini terlebih dahulu.
Proyek upstream: RF-DETR oleh Roboflow, Apache-2.0. Makalah, sumber
Lisensi: Kode MIT, bobot Apache-2.0. Penggunaan komersial

Deteksi video dengan LibreRFDETRs pada 512 px.

Instalasi

RF-DETR memerlukan komponen tambahannya sendiri, yang memasang transformers untuk backbone.

bash

pip install "libreyolo[rfdetr]"

Tanpa extra itu, memuat checkpoint atau nama model RF-DETR, dari Python maupun CLI, berhenti dengan error yang menyebutkan baris instalasi ini.

Prediksi

Bobot diunduh dari Hugging Face saat pertama kali digunakan dan disimpan dalam cache lokal.

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") # Sumber apa pun yang diterima library: berkas, folder, URL, indeks webcam,# stream RTSP, atau daftar .streamsfor result in model.predict("clip.mp4", stream=True, save=True):    print(len(result.boxes))

Objek Results yang dikembalikan sama dengan yang dikembalikan setiap family, jadi mengganti detektor hanya memerlukan perubahan satu baris. conf dan max_det memfilter pemilihan query; tidak ada tahap NMS yang perlu disetel. Lihat prediksi untuk sumber, streaming, dan penanganan hasil.

Jalur deteksi, segmentasi, dan kotak berorientasi memakai pengubahan ukuran bilinear OpenCV floating-point tanpa antialiasing; pose tetap memakai pengubahan ukuran dengan antialiasing. imgsz=(height, width) persegi panjang harus sesuai dengan grid patch/window task. Daftar checkpoint mencakup detektor UI. Histogram peristiwa memakai profil input yang tercatat.

Varian

Empat ukuran deteksi, n sampai l, dan empat task yang memakai satu arsitektur: segmentasi, pose, dan kotak berorientasi menggunakan kembali decoder deteksi dengan head berbeda, sehingga semuanya menerima argumen yang sama. Segmentasi menambahkan x dan xx, dan pose hanya tersedia dalam x. Setiap ukuran memiliki jumlah parameter yang mirip dan terutama berbeda dalam resolusi input.

Checkpoint	Input (piksel)	mAP 50-95	Parameter (juta)
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. Diukur oleh perangkat benchmark LibreYOLO dan dipublikasikan di Vision Analysis, tempat latensi pada berbagai hardware dan runtime dibandingkan serta rekaman lengkap setiap pengujian tersedia.

Pelatihan

Pelatihan dimulai dari checkpoint yang dipublikasikan untuk keempat task. pretrained=False justru menginisialisasi ulang seluruh jaringan, termasuk backbone, lalu melatih dari nol.

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

Dua argumen lebih penting di sini daripada pada detektor CNN. Pertahankan lr0 pada atau di bawah 1e-4, karena detektor transformer mengalami divergensi pada learning rate yang masih dapat ditoleransi model YOLO. Biarkan imgsz pada resolusi native checkpoint kecuali ada alasan untuk mengubahnya. Input harus habis dibagi ukuran patch backbone dikalikan jumlah window; LibreYOLO memeriksanya sebelum proses dimulai dan menyebutkan ukuran valid terdekat.

Fine-tuning segment dimulai dari checkpoint segment, karena RF-DETR tidak punya transfer dari detect ke segment. libreyolo train model=LibreRFDETRn-seg.pt task=segment memuat checkpoint itu, dan checkpoint deteksi dengan task=segment berhenti dengan error.

Lihat pelatihan untuk dataset, augmentasi, multi-GPU, dan logger.

Proses baru memakai output_dir=None secara default, yang menghasilkan direktori runs/train/rfdetr_exp bernomor dengan exist_ok=False. Proses yang dilanjutkan tetap menulis ke direktori run milik checkpoint-nya. Dataset pose multikelas memakai kpt_names dengan indeks atau nama kelas sebagai kunci; daftar kosong menandai kelas yang hanya memiliki kotak. Prediksi mengisi keypoint hingga kpt_shape; fitness mAP keypoint tidak menilai kelas yang hanya memiliki kotak.

Validasi

val() mengembalikan dictionary dengan key metrics/ yang mencakup mAP 50, mAP 50-95, mAP 75, dan average recall COCO, yang diukur terhadap dataset apa pun dalam format yang digunakan untuk pelatihan.

Python

from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # val() mengembalikan dict biasa, bukan objekmetrics = 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

Dibandingkan dengan COCO

# YAML COCO bawaan menyertakan skrip unduhan tertanam, sehingga# memerlukan izin eksplisit kecuali dataset sudah tersedia secara lokal.libreyolo val model=LibreRFDETRn.pt data=coco.yaml imgsz=384 \  allow_download_scripts=True

Ekspor

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

Artefak hasil ekspor dimuat kembali melalui LibreYOLO() berdasarkan sufiks berkasnya, sehingga berkas .onnx atau .engine berperilaku seperti checkpoint dan mengembalikan Results yang sama. Menjalankan graph pada runtime mandiri tanpa memasang LibreYOLO juga didukung, tetapi prapemrosesan dan pascapemrosesannya harus ditulis sendiri.

Python

from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.export(format="onnx", imgsz=512)model.export(format="tensorrt", imgsz=512, half=True) # Argumen yang diterima untuk setiap format:##   format    "onnx" | "torchscript" | "executorch" | "tensorrt"#             | "openvino" | "paddle" | "mnn" | "rknn" | "ncnn"#             | "tflite" | "coreml" | "coreai".#             "engine" adalah alias untuk tensorrt, "litert" untuk tflite.#   imgsz     int, atau (height, width). Default-nya resolusi native#             checkpoint.#   batch     int, default 1.#   half      bool, ekspor dalam FP16. Default False.#   int8      bool, ekspor dalam INT8. Default False. Memerlukan `data`.#   data      path ke YAML dataset, digunakan untuk kalibrasi int8.#   fraction  float, bagian set kalibrasi yang digunakan. Default 1.0.#   dynamic   bool, sumbu dinamis. Default True.#   simplify  bool, jalankan penyederhanaan graph ONNX. Default True.#   opset     int, opset ONNX. Dipilih per family jika tidak diberikan.#   device    str, perangkat untuk tracing. Default-nya perangkat model.#   output_path  str, default-nya nama yang diturunkan dari checkpoint.#   verbose   bool, default False.#   allow_download_scripts  bool, default False. Mengizinkan Python#             tertanam dalam YAML dataset yang harus diunduh.## Beberapa format menerima argumen tambahan sendiri, seperti platform# target RKNN. Argumen tersebut didokumentasikan di halaman tiap format.

CLI

libreyolo export model=LibreRFDETRs.pt format=onnx imgsz=512libreyolo export model=LibreRFDETRs.pt format=tensorrt imgsz=512 half=True

Gunakan berkas hasil ekspor

from libreyolo import LibreYOLO, SAMPLE_IMAGE # Factory merutekan berdasarkan sufiks berkas, sehingga artefak hasil ekspor# dimuat seperti checkpoint lain dan mengembalikan objek Results yang sama.model = LibreYOLO("LibreRFDETRs.onnx")result = model(SAMPLE_IMAGE) print(result.boxes.xyxy)

Tanpa LibreYOLO

import numpy as npimport onnxruntime as ort # Menjalankan graph secara langsung berarti melakukan prapemrosesan dan# pascapemrosesan sendiri. Periksa signature sebelum menghubungkannya.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)

Input dan output ONNX

Tensor	`input` `float32` `[batch, 3, height, width]`
Warna	RGB
Penskalaan	piksel / 255
Normalisasi	rata-rata [0.485,0.456,0.406], simpangan baku [0.229,0.224,0.225]
Ubah ukuran	`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, ekspor default

Output	Bentuk	Arti
`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.

Pascapemrosesan

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, ekspor default

Output	Bentuk	Arti
`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.

Pascapemrosesan

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, ekspor default

Output	Bentuk	Arti
`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.

Pascapemrosesan

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, ekspor default

Output	Bentuk	Arti
`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.

Pascapemrosesan

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.

Untuk memeriksa implementasi Anda sendiri, jalankan file yang sama lewat LibreYOLO: LibreYOLO("model.onnx").predict("image.jpg") mengembalikan hasil acuan. Diverifikasi dengan LibreYOLO 1.7.0.

Checkpoint

Setiap berkas bobot yang dipublikasikan untuk family ini.

Berkas	Input (piksel)	Lisensi bobot
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

Setiap berkas di atas saat ini tersedia di organisasi LibreYOLO dan diunduh saat pertama kali digunakan.

Lisensi

Periksa lisensi di repositori Hugging Face untuk bobot tertentu yang diunduh. Setiap checkpoint di organisasi LibreYOLO memiliki lisensi, dan lisensinya tidak selalu sama dalam satu family. Repositori tersebut adalah sumber resmi. Ringkasan di bawah menjelaskan ketentuan yang berlaku saat halaman ini terakhir diverifikasi.

Ini adalah deskripsi lisensi yang terlibat, bukan nasihat hukum. Jika jawabannya penting secara komersial, baca sendiri lisensinya dan mintalah nasihat dari penasihat hukum Anda.

Karya asli: RF-DETR, Roboflow
Lisensi upstream: Apache-2.0
Sumber upstream: github.com/roboflow/rf-detr
Kode LibreYOLO: MIT
Bobot: Apache-2.0, dipublikasikan ulang di huggingface.co/LibreYOLO
Interpretasi: 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.

Sitasi

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

Disalin dari blok sitasi penulis di github.com/roboflow/rf-detr#citation.