RF-DETR

Transformer detekcyjny, który przewiduje stały zestaw obiektów zamiast gęstej siatki, dlatego podczas wnioskowania nie wymaga NMS. LibreYOLO obsługuje go w czterech zadaniach.

Zadania
detection, instance segmentation, pose, oriented boxes
Rozmiary
n, s, m, l for detection, pose and oriented boxes; n through xx for segmentation
Instalacja
pip install "libreyolo[rfdetr]"
Poziom obsługi
Flagowy, od wersji v1.0.0. Tutaj funkcje są najpierw projektowane i w pełni walidowane na GPU.
Projekt źródłowy
RF-DETR, autorzy: Roboflow, licencja: Apache-2.0. Publikacja, kod źródłowy
Licencje
Kod: MIT, wagi: Apache-2.0. Użycie komercyjne
LibreRFDETRs, detekcja na wideo w rozdzielczości 512 px.

Instalacja

RF-DETR wymaga własnego dodatku, który instaluje transformers dla backbone.

bash
pip install "libreyolo[rfdetr]"

Predykcja

Przy pierwszym użyciu wagi są pobierane z Hugging Face i zapisywane w lokalnej pamięci podręcznej.

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
Wideo
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # Dowolne źródło akceptowane przez bibliotekę: plik, folder, URL, indeks kamery,# strumień RTSP albo lista .streamsfor result in model.predict("clip.mp4", stream=True, save=True):    print(len(result.boxes))

Zwracany obiekt Results jest taki sam dla każdej rodziny, więc zamiana na inny detektor wymaga zmiany jednego wiersza. Parametry conf i max_det filtrują wybór zapytań. Nie ma etapu NMS do dostrojenia. Informacje o źródłach, strumieniowaniu i obsłudze wyników znajdziesz w sekcji predykcja.

Warianty

Dostępne są cztery rozmiary oraz cztery zadania korzystające ze wspólnej architektury. Segmentacja, estymacja pozy i ramki zorientowane ponownie używają dekodera detekcji z inną głowicą, dlatego przyjmują te same argumenty. Rozmiary mają podobną liczbę parametrów i różnią się głównie rozdzielczością wejściową.

Checkpoint modeluWejście (px)mAP 50-95Parametry (mln)
LibreRFDETRn38451.430.47
LibreRFDETRs51255.132.11
LibreRFDETRm57657.433.69
LibreRFDETRl70458.633.93

COCO val2017, 500 images. Wyniki zmierzono za pomocą zestawu benchmarkowego LibreYOLO i opublikowano w Vision Analysis, gdzie porównywane są opóźnienia na różnych urządzeniach i w różnych środowiskach uruchomieniowych oraz znajdują się pełne zapisy przebiegów.

Trenowanie

Trenowanie dla wszystkich czterech zadań zaczyna się od opublikowanego punktu kontrolnego. RF-DETR umieszcza pretrained wśród argumentów ignorowanych przez natywny trener, więc przekazanie pretrained=False nie daje tutaj losowo zainicjalizowanego modelu.

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)
Wiele GPU
libreyolo train model=LibreRFDETRs.pt data=my-dataset.yaml \  epochs=50 device=0,1 batch=-1

Dwa argumenty mają tutaj większe znaczenie niż w detektorze CNN. Utrzymuj lr0 na poziomie 1e-4 lub niższym, ponieważ detektory transformer rozbiegają się przy szybkościach uczenia tolerowanych przez model YOLO. Pozostaw imgsz w natywnej rozdzielczości punktu kontrolnego, chyba że istnieje powód, by ją zmienić. Rozmiar wejścia musi być podzielny przez iloczyn rozmiaru fragmentu backbone i liczby okien. LibreYOLO sprawdza to przed rozpoczęciem przebiegu i wskazuje najbliższe prawidłowe rozmiary.

Informacje o zbiorach danych, augmentacji, wielu GPU i loggerach znajdziesz w sekcji trenowanie.

Walidacja

Metoda val() zwraca słownik kluczy metrics/ obejmujących precyzję, czułość, mAP 50 i mAP 50-95, mierzone na dowolnym zbiorze danych w formacie użytym do trenowania.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # val() zwraca zwykły słownik, a nie obiektmetrics = 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
Walidacja na COCO
# Dołączony plik yaml COCO zawiera osadzony skrypt pobierania, dlatego wymaga# jawnego zezwolenia, chyba że zbiór danych jest już dostępny lokalnie.libreyolo val model=LibreRFDETRn.pt data=coco.yaml imgsz=384 \  allow_download_scripts=True

Eksport

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

Wyeksportowany artefakt jest ponownie ładowany przez LibreYOLO() na podstawie rozszerzenia pliku, więc plik .onnx lub .engine zachowuje się jak punkt kontrolny i zwraca ten sam obiekt Results. Obsługiwane jest także uruchamianie grafu w samym środowisku uruchomieniowym bez zainstalowanego LibreYOLO, ale wówczas samodzielnie trzeba zaimplementować przetwarzanie wstępne i końcowe.

Python
from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.export(format="onnx", imgsz=512)model.export(format="tensorrt", imgsz=512, half=True) # Argumenty akceptowane dla każdego formatu:##   format    "onnx" | "torchscript" | "executorch" | "tensorrt"#             | "openvino" | "paddle" | "mnn" | "rknn" | "ncnn"#             | "tflite" | "coreml" | "coreai".#             "engine" jest aliasem tensorrt, a "litert" aliasem tflite.#   imgsz     int albo (wysokość, szerokość). Domyślnie natywna#             rozdzielczość punktu kontrolnego.#   batch     int, domyślnie 1.#   half      bool, eksport w FP16. Domyślnie False.#   int8      bool, eksport w INT8. Domyślnie False. Wymaga `data`.#   data      ścieżka do pliku YAML zbioru danych używanego do kalibracji int8.#   fraction  float, część zestawu kalibracyjnego do użycia. Domyślnie 1.0.#   dynamic   bool, osie dynamiczne. Domyślnie True.#   simplify  bool, uproszczenie grafu ONNX. Domyślnie True.#   opset     int, zestaw operatorów ONNX. Jeśli nie podano, wybierany dla rodziny.#   device    str, urządzenie do śledzenia. Domyślnie urządzenie modelu.#   output_path  str, domyślnie nazwa pochodząca od punktu kontrolnego.#   verbose   bool, domyślnie False.#   allow_download_scripts  bool, domyślnie False. Zezwala na osadzony#             Python w pliku YAML zbioru danych, który trzeba pobrać.## Kilka formatów przyjmuje własne dodatkowe argumenty, na przykład platformę# docelową RKNN. Są one opisane na stronie każdego formatu.
CLI
libreyolo export model=LibreRFDETRs.pt format=onnx imgsz=512libreyolo export model=LibreRFDETRs.pt format=tensorrt imgsz=512 half=True
Użycie wyeksportowanego pliku
from libreyolo import LibreYOLO # Fabryka wybiera ścieżkę na podstawie rozszerzenia pliku, dlatego# artefakt ładuje się jak punkt kontrolny i zwraca ten sam obiekt Results.model = LibreYOLO("LibreRFDETRs.onnx")result = model(SAMPLE_IMAGE) print(result.boxes.xyxy)
Bez LibreYOLO
import numpy as npimport onnxruntime as ort # Bezpośrednie uruchomienie grafu wymaga własnego przetwarzania wstępnego# i końcowego. Przed integracją sprawdź sygnaturę.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)

Punkty kontrolne

Wszystkie opublikowane pliki wag dla tej rodziny.

PlikWejście (px)Licencja wag
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

Każdy z powyższych plików jest obecnie dostępny w organizacji LibreYOLO i pobierany przy pierwszym użyciu.

Licencjonowanie

Sprawdź licencję w repozytorium konkretnych pobieranych wag na Hugging Face. Każdy checkpoint w organizacji LibreYOLO ma licencję, która nie zawsze jest taka sama w całej rodzinie. To repozytorium jest źródłem rozstrzygającym, a poniższe podsumowanie opisuje stan z chwili ostatniej weryfikacji tej strony.

To opis obowiązujących licencji, a nie porada prawna. Jeśli odpowiedź ma znaczenie komercyjne, przeczytaj licencje i zasięgnij własnej porady prawnej.

Oryginalna praca
RF-DETR, Roboflow
Licencja projektu źródłowego
Apache-2.0
Kod źródłowy projektu
github.com/roboflow/rf-detr
Kod LibreYOLO
MIT
Wagi
Apache-2.0, ponownie opublikowane w huggingface.co/LibreYOLO
Interpretacja
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.

Cytowanie

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

Skopiowano z bloku cytowania autorów w github.com/roboflow/rf-detr#citation.

Zweryfikowano z LibreYOLO v1.5.0. Tabele obsługi, checkpointy i wyniki benchmarków na tej stronie są generowane na podstawie wydanej biblioteki i opublikowanych wag, a nie wpisywane ręcznie.