RF-DETR

Um transformer de detecção que prevê um conjunto fixo de objetos em vez de uma grade densa, então não precisa de NMS na inferência. O LibreYOLO o suporta para quatro tarefas.

Tarefas: detection, instance segmentation, pose, oriented boxes
Tamanhos: n, s, m, l for detection and oriented boxes; n through xx for segmentation; x for pose
Instalação: pip install "libreyolo[rfdetr]"
Nível de suporte: Carro-chefe, desde a v1.0.0. Os recursos são projetados e validados por completo em GPU aqui primeiro.
Origem: RF-DETR por Roboflow, Apache-2.0. Artigo, código-fonte
Licenças: Código MIT, pesos Apache-2.0. Uso comercial

LibreRFDETRs, detecção em vídeo a 512 px.

Instalação

O RF-DETR precisa do seu próprio extra, que instala o transformers para o backbone.

bash

pip install "libreyolo[rfdetr]"

Sem ele, carregar um checkpoint ou nome de modelo RF-DETR, em Python ou na CLI, para com um erro que nomeia esta linha de instalação.

Predição

Os pesos são baixados do Hugging Face no primeiro uso e ficam em cache localmente.

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

Vídeo

from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # Qualquer fonte que a biblioteca aceita: arquivo, pasta, URL, índice de# webcam, stream RTSP ou uma lista .streamsfor result in model.predict("clip.mp4", stream=True, save=True):    print(len(result.boxes))

O objeto Results retornado é o mesmo que todas as famílias retornam, então trocar por outro detector é uma mudança de uma linha. conf e max_det filtram a seleção de queries; não existe etapa de NMS para ajustar. Veja predição para fontes, streaming e tratamento de resultados.

Os caminhos de detecção, segmentação e caixas orientadas usam redimensionamento bilinear do OpenCV em ponto flutuante sem antialiasing; pose mantém o redimensionamento com antialiasing. O imgsz=(height, width) retangular deve respeitar a grade de patches/janelas da tarefa. O inventário de checkpoints inclui o detector de interfaces. Histogramas de eventos usam o perfil de entrada registrado.

Variantes

Quatro tamanhos de detecção, de n a l, e quatro tarefas que compartilham uma mesma arquitetura: segmentação, pose e caixas orientadas reaproveitam o decoder de detecção com uma cabeça diferente, então aceitam os mesmos argumentos. A segmentação acrescenta x e xx, e a pose vem apenas em x. Os tamanhos têm contagens de parâmetros parecidas e diferem principalmente na resolução de entrada.

Checkpoint	Entrada (px)	mAP 50-95	Parâmetros (M)
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. Medido pelo conjunto de testes de benchmark do LibreYOLO e publicado no Vision Analysis, onde a latência entre hardwares e runtimes é comparada e os registros completos das execuções ficam disponíveis.

Treinamento

O treinamento parte de um checkpoint publicado, para as quatro tarefas. pretrained=False, em vez disso, reinicializa a rede inteira, backbone incluído, e treina do zero.

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

Dois argumentos importam mais aqui do que em um detector CNN. Mantenha lr0 em 1e-4 ou abaixo, já que detectores transformer divergem com learning rates que um modelo YOLO tolera. Deixe imgsz na resolução nativa do checkpoint, a menos que você tenha um motivo para mudar. A entrada precisa ser divisível exatamente pelo tamanho de patch do backbone vezes o número de janelas; o LibreYOLO verifica isso antes de a execução começar e indica os tamanhos válidos mais próximos.

O fine-tuning de segment parte de um checkpoint segment, porque o RF-DETR não tem transferência de detect para segment. libreyolo train model=LibreRFDETRn-seg.pt task=segment carrega esse checkpoint, e um checkpoint de detecção com task=segment para com um erro.

Veja treinamento para datasets, data augmentation, multi-GPU e loggers.

Novas execuções usam output_dir=None por padrão, que resulta em um runs/train/rfdetr_exp incrementado com exist_ok=False. Uma execução retomada continua gravando no diretório de execução do seu checkpoint. Datasets de pose multiclasse usam kpt_names com o índice ou nome da classe como chave; uma lista vazia indica uma classe só de caixas. As predições completam os keypoints até kpt_shape; o fitness de mAP de keypoints não avalia classes só de caixas.

Validação

val() retorna um dicionário de chaves metrics/ cobrindo mAP 50, mAP 50-95, mAP 75 e o recall médio do COCO, medidas contra qualquer dataset no formato em que você treinou.

Python

from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt") # val() retorna um dict simples, não um objetometrics = 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

Contra o COCO

# O yaml do COCO que vem junto carrega um script de download embutido,# então ele precisa de permissão explícita a menos que o dataset já# esteja local.libreyolo val model=LibreRFDETRn.pt data=coco.yaml imgsz=384 \  allow_download_scripts=True

Exportação

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

Um artefato exportado é recarregado pelo LibreYOLO() a partir do sufixo do arquivo, então um arquivo .onnx ou .engine se comporta como um checkpoint e devolve o mesmo Results. Rodar o grafo em um runtime pelado, sem o LibreYOLO instalado, também é suportado, mas aí o pré-processamento e o pós-processamento ficam por sua conta.

Python

from libreyolo import LibreYOLO model = LibreYOLO("LibreRFDETRs.pt")model.export(format="onnx", imgsz=512)model.export(format="tensorrt", imgsz=512, half=True) # Argumentos aceitos por todos os formatos:##   format    "onnx" | "torchscript" | "executorch" | "tensorrt"#             | "openvino" | "paddle" | "mnn" | "rknn" | "ncnn"#             | "tflite" | "coreml" | "coreai".#             "engine" é um alias para tensorrt, e "litert" para tflite.#   imgsz     int, ou (altura, largura). Por padrão, a resolução nativa#             do checkpoint.#   batch     int, padrão 1.#   half      bool, exporta em FP16. Padrão False.#   int8      bool, exporta em INT8. Padrão False. Precisa de `data`.#   data      caminho para um YAML de dataset, usado para calibrar o int8.#   fraction  float, parcela desse conjunto de calibração a usar. Padrão 1.0.#   dynamic   bool, eixos dinâmicos. Padrão True.#   simplify  bool, roda a simplificação do grafo ONNX. Padrão True.#   opset     int, opset do ONNX. Escolhido por família quando não informado.#   device    str, dispositivo em que rastrear. Padrão: o do modelo.#   output_path  str, padrão é um nome derivado do checkpoint.#   verbose   bool, padrão False.#   allow_download_scripts  bool, padrão False. Permite Python embutido#             em um YAML de dataset que precise ser baixado.## Alguns formatos aceitam argumentos extras próprios, como uma# plataforma alvo de RKNN. Esses estão documentados na página de cada# formato.

CLI

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

Usar o arquivo exportado

from libreyolo import LibreYOLO, SAMPLE_IMAGE # A factory decide pelo sufixo do arquivo, então um artefato exportado# carrega como qualquer checkpoint e devolve o mesmo objeto Results.model = LibreYOLO("LibreRFDETRs.onnx")result = model(SAMPLE_IMAGE) print(result.boxes.xyxy)

Sem o LibreYOLO

import numpy as npimport onnxruntime as ort # Rodar o grafo diretamente significa fazer seu próprio pré-processamento# e pós-processamento. Inspecione a assinatura antes de ligar qualquer# coisa.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)

Entradas e saídas ONNX

Tensor	`input` `float32` `[batch, 3, height, width]`
Cor	RGB
Escala	pixel / 255
Normalização	média [0.485,0.456,0.406], desvio padrão [0.229,0.224,0.225]
Redimensionamento	`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, exportação padrão

Saída	Forma	Significado
`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.

Pós-processamento

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, exportação padrão

Saída	Forma	Significado
`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.

Pós-processamento

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, exportação padrão

Saída	Forma	Significado
`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.

Pós-processamento

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, exportação padrão

Saída	Forma	Significado
`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.

Pós-processamento

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.

Para conferir a sua própria implementação, passe o mesmo arquivo pelo LibreYOLO: LibreYOLO("model.onnx").predict("image.jpg") devolve os resultados de referência. Verificado com o LibreYOLO 1.7.0.

Checkpoints

Todos os arquivos de pesos publicados desta família.

Arquivo	Entrada (px)	Licença dos pesos
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

Todos os arquivos acima existem hoje na organização LibreYOLO e são baixados no primeiro uso.

Licenciamento

Confira a licença no repositório do Hugging Face correspondente aos pesos que você baixar. Cada checkpoint na organização LibreYOLO tem uma licença, e ela nem sempre é a mesma em toda a família. Esse repositório é a fonte oficial. O resumo abaixo descreve o que se aplicava na última verificação desta página.

Esta é uma descrição das licenças envolvidas, não uma orientação jurídica. Se a resposta tiver importância comercial, leia as licenças e procure sua própria assessoria.

Trabalho original: RF-DETR, Roboflow
Licença original: Apache-2.0
Código-fonte original: github.com/roboflow/rf-detr
Código do LibreYOLO: MIT
Pesos: Apache-2.0, republicado em huggingface.co/LibreYOLO
Interpretação: 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.

Citação

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

Copiado do bloco de citação dos autores em github.com/roboflow/rf-detr#citation.