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 and oriented boxes; n through xx for segmentation; x for pose
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]"

Bez niego wczytanie checkpointu lub nazwy modelu RF-DETR, z Pythona albo z CLI, kończy się błędem, który podaje tę linię instalacji.

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.

Ścieżki detekcji, segmentacji i obróconych ramek używają zmiany rozmiaru metodą dwuliniową OpenCV w arytmetyce zmiennoprzecinkowej, bez antyaliasingu; estymacja pozy zachowuje antyaliasing. Prostokątny imgsz=(height, width) musi pasować do siatki patchy/okien zadania. Lista checkpointów obejmuje detektor elementów interfejsu. Histogramy zdarzeń używają zapisanego profilu wejścia.

Warianty

Dostępne są cztery rozmiary detekcji, od n do l, 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. Segmentacja dodaje x i xx, a estymacja pozy jest dostępna tylko w rozmiarze x. Rozmiary mają podobną liczbę parametrów i różnią się głównie rozdzielczością wejściową.

Checkpoint modelu	Wejście (px)	mAP 50-95	Parametry (mln)
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. 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. pretrained=False zamiast tego ponownie inicjalizuje całą sieć, łącznie z backbone, i trenuje od zera.

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.

Dostrajanie segmentacji zaczyna się od checkpointu segmentacji, ponieważ RF-DETR nie ma transferu z detekcji do segmentacji. libreyolo train model=LibreRFDETRn-seg.pt task=segment wczytuje ten checkpoint, a checkpoint detekcji z task=segment kończy się błędem.

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

Nowe uruchomienia domyślnie używają output_dir=None, co tworzy katalog runs/train/rfdetr_exp z kolejnym numerem i exist_ok=False. Wznowione uruchomienie nadal zapisuje do katalogu uruchomienia swojego punktu kontrolnego. Wieloklasowe zbiory pozy używają kpt_names z indeksem lub nazwą klasy jako kluczem; pusta lista oznacza klasę z samymi ramkami. Predykcje uzupełniają punkty kluczowe do kpt_shape; funkcja fitness oparta na mAP punktów kluczowych nie ocenia klas z samymi ramkami.

Walidacja

Metoda val() zwraca słownik kluczy metrics/ obejmujących mAP 50, mAP 50-95, mAP 75 i średni recall COCO, 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/mAP75"], metrics["metrics/AR100"])

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

Zadanie	ONNX	TorchScript	ExecuTorch	TensorRT	OpenVINO	Paddle	MNN	RKNN	ncnn	TFLite	CoreML	Core AI
Detection	Detection to ONNX: obsługiwane	Detection to TorchScript: obsługiwane	Detection to ExecuTorch: obsługiwane	Detection 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ługi	Detection to MNN: obsługiwane	Detection to RKNN: brak obsługi	Detection to ncnn: brak obsługi	Detection to TFLite: brak obsługi	Detection to CoreML: obsługiwane. Conversion is available, but runtime parity requires a macOS runner.	Detection to Core AI: obsługiwane
Instance segmentation	Instance segmentation to ONNX: obsługiwane	Instance segmentation to TorchScript: obsługiwane	Instance segmentation to ExecuTorch: obsługiwane	Instance 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ługi	Instance segmentation to MNN: brak obsługi	Instance segmentation to RKNN: brak obsługi	Instance segmentation to ncnn: brak obsługi	Instance segmentation to TFLite: brak obsługi	Instance segmentation to CoreML: brak obsługi	Instance segmentation to Core AI: brak obsługi
Pose	Pose to ONNX: obsługiwane	Pose to TorchScript: obsługiwane	Pose to ExecuTorch: obsługiwane	Pose 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ługi	Pose to MNN: brak obsługi	Pose to RKNN: brak obsługi	Pose to ncnn: brak obsługi	Pose to TFLite: brak obsługi	Pose to CoreML: brak obsługi	Pose to Core AI: brak obsługi
Oriented boxes	Oriented boxes to ONNX: obsługiwane	Oriented boxes to TorchScript: obsługiwane	Oriented boxes to ExecuTorch: obsługiwane	Oriented 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ługi	Oriented boxes to MNN: brak obsługi	Oriented boxes to RKNN: brak obsługi	Oriented boxes to ncnn: brak obsługi	Oriented boxes to TFLite: brak obsługi	Oriented boxes to CoreML: brak obsługi	Oriented 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, SAMPLE_IMAGE # 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("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)

Wejścia i wyjścia ONNX

Tensor	`input` `float32` `[batch, 3, height, width]`
Kolor	RGB
Skalowanie	piksel / 255
Normalizacja	średnia [0.485,0.456,0.406], odchylenie standardowe [0.229,0.224,0.225]
Zmiana rozmiaru	`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, eksport domyślny

Wyjście	Kształt	Znaczenie
`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.

Przetwarzanie końcowe

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, eksport domyślny

Wyjście	Kształt	Znaczenie
`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.

Przetwarzanie końcowe

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, eksport domyślny

Wyjście	Kształt	Znaczenie
`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.

Przetwarzanie końcowe

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, eksport domyślny

Wyjście	Kształt	Znaczenie
`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.

Przetwarzanie końcowe

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.

Aby sprawdzić własną implementację, uruchom ten sam plik w LibreYOLO: LibreYOLO("model.onnx").predict("image.jpg") zwraca wyniki wzorcowe. Zweryfikowano w LibreYOLO 1.7.0.

Punkty kontrolne

Wszystkie opublikowane pliki wag dla tej rodziny.

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

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.