RF-DETR

Un detection transformer che predice un insieme fisso di oggetti invece di una griglia densa, quindi non richiede NMS durante l'inferenza. LibreYOLO lo supporta per quattro task.

Task
detection, instance segmentation, pose, oriented boxes
Dimensioni
n, s, m, l for detection, pose and oriented boxes; n through xx for segmentation
Installa
pip install "libreyolo[rfdetr]"
Livello di supporto
Di punta, dalla v1.0.0. Le funzionalità vengono progettate e convalidate completamente su GPU prima per questo livello.
Origine
RF-DETR di Roboflow, Apache-2.0. Articolo, sorgente
Licenze
Codice MIT, pesi Apache-2.0. Uso commerciale
LibreRFDETRs, rilevamento su video a 512 px.

Installazione

RF-DETR richiede un extra dedicato, che porta con sé transformers per il backbone.

bash
pip install "libreyolo[rfdetr]"

Predizione

I pesi vengono scaricati da Hugging Face al primo utilizzo e restano nella cache locale.

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") # Qualsiasi sorgente accettata dalla libreria: file, cartella, URL,# indice della webcam, stream RTSP o una lista .streamsfor result in model.predict("clip.mp4", stream=True, save=True):    print(len(result.boxes))

L'oggetto Results restituito è quello che restituisce ogni famiglia, quindi passare a un rilevatore diverso è una modifica di una riga. conf e max_det filtrano la selezione delle query; non c'è nessun passaggio di NMS da regolare. Vedi predizione per sorgenti, streaming e gestione dei risultati.

Varianti

Quattro dimensioni, e quattro task che condividono una sola architettura: segmentazione, posa e box orientati riutilizzano il decoder di rilevamento con una testa diversa, quindi accettano gli stessi argomenti. Le dimensioni hanno un numero di parametri simile e differiscono soprattutto per la risoluzione di input.

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

COCO val2017, 500 images. Misurato con il sistema di benchmark di LibreYOLO e pubblicato su Vision Analysis, dove vengono confrontate le latenze tra hardware e runtime e sono disponibili i record completi delle esecuzioni.

Addestramento

L'addestramento parte da un checkpoint pubblicato, per tutti e quattro i task. RF-DETR elenca pretrained tra gli argomenti che il suo trainer nativo ignora, quindi passare pretrained=False qui non ti dà un modello inizializzato a caso.

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

Due argomenti contano più qui che su un rilevatore CNN. Tieni lr0 a 1e-4 o sotto, perché i detection transformer divergono a learning rate che un modello YOLO tollera. Lascia imgsz alla risoluzione nativa del checkpoint, a meno che tu non abbia un motivo per cambiarla. L'input deve essere divisibile esattamente per la dimensione delle patch del backbone moltiplicata per il numero di finestre; LibreYOLO lo verifica prima che l'esecuzione parta e indica le dimensioni valide più vicine.

Vedi addestramento per dataset, data augmentation, multi-GPU e logger.

Validazione

val() restituisce un dizionario di chiavi metrics/ che coprono precisione, recall, mAP 50 e mAP 50-95, misurati su qualsiasi dataset nel formato su cui hai addestrato.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # val() restituisce un semplice dict, non un oggettometrics = 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
Su COCO
# Lo yaml di COCO incluso porta uno script di download integrato,# quindi serve un permesso esplicito a meno che il dataset non sia# già in locale.libreyolo val model=LibreRFDETRn.pt data=coco.yaml imgsz=384 \  allow_download_scripts=True

Esportazione

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

Un artefatto esportato si ricarica con LibreYOLO() in base al suffisso del file, quindi un file .onnx o .engine si comporta come un checkpoint e restituisce lo stesso Results. È supportato anche eseguire il grafo in un runtime nudo, senza LibreYOLO installato, ma allora preprocessing e postprocessing tocca scriverli a te.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.export(format="onnx", imgsz=512)model.export(format="tensorrt", imgsz=512, half=True) # Argomenti accettati per ogni formato:##   format    "onnx" | "torchscript" | "executorch" | "tensorrt"#             | "openvino" | "paddle" | "mnn" | "rknn" | "ncnn"#             | "tflite" | "coreml" | "coreai".#             "engine" è un alias per tensorrt, "litert" per tflite.#   imgsz     int, oppure (altezza, larghezza). Di default la#             risoluzione nativa del checkpoint.#   batch     int, default 1.#   half      bool, esporta in FP16. Default False.#   int8      bool, esporta in INT8. Default False. Richiede `data`.#   data      percorso di uno YAML di dataset, usato per calibrare int8.#   fraction  float, quota di quel set di calibrazione da usare.#             Default 1.0.#   dynamic   bool, assi dinamici. Default True.#   simplify  bool, esegue la semplificazione del grafo ONNX.#             Default True.#   opset     int, opset ONNX. Scelto per famiglia se non indicato.#   device    str, dispositivo su cui tracciare. Di default quello#             del modello.#   output_path  str, di default un nome derivato dal checkpoint.#   verbose   bool, default False.#   allow_download_scripts  bool, default False. Consente il Python#             integrato in uno YAML di dataset che va scaricato.## Qualche formato accetta argomenti extra propri, come una piattaforma# target RKNN. Sono documentati nella pagina di ciascun formato.
CLI
libreyolo export model=LibreRFDETRs.pt format=onnx imgsz=512libreyolo export model=LibreRFDETRs.pt format=tensorrt imgsz=512 half=True
Usare il file esportato
from libreyolo import LibreYOLO # La factory smista in base al suffisso del file, quindi un artefatto# esportato si carica come qualsiasi checkpoint e restituisce lo stesso# oggetto Results.model = LibreYOLO("LibreRFDETRs.onnx")result = model(SAMPLE_IMAGE) print(result.boxes.xyxy)
Senza LibreYOLO
import numpy as npimport onnxruntime as ort # Eseguire il grafo direttamente significa scrivere da sé il# preprocessing e il postprocessing. Ispeziona la firma prima di# collegare qualsiasi cosa.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)

Checkpoint

Tutti i file di pesi pubblicati per questa famiglia.

FileIngresso (px)Licenza dei pesi
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

Oggi tutti i file elencati sopra sono presenti nell<link>organizzazione LibreYOLO</link> e vengono scaricati al primo utilizzo.

Licenze

Controlla la licenza nel repository Hugging Face degli specifici pesi che scarichi. Ogni checkpoint nell<link>organizzazione LibreYOLO</link> ne include una e non è sempre la stessa per tutta la famiglia. Quel repository è la fonte autorevole; il riepilogo seguente descrive le condizioni applicabili al momento dellultima verifica di questa pagina.

Questa è una descrizione delle licenze coinvolte, non una consulenza legale. Se la risposta è importante a fini commerciali, leggi personalmente le licenze e chiedi una consulenza indipendente.

Lavoro originale
RF-DETR, Roboflow
Licenza upstream
Apache-2.0
Codice LibreYOLO
MIT
Pesi
Apache-2.0, ripubblicati su huggingface.co/LibreYOLO
Interpretazione
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.

Citazione

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

Copiato dal blocco di citazione degli autori disponibile su github.com/roboflow/rf-detr#citation.

Verificato con LibreYOLO v1.5.0. Le tabelle di supporto, i checkpoint e i dati dei benchmark in questa pagina vengono generati dalla libreria rilasciata e dai pesi pubblicati, non scritti a mano.