rf-detr-large-doclay

This model is a fine-tuned version of Roboflow/rf-detr-large on the DocLayNet v1.2 dataset.

It achieves the following results on the DocLayNet validation split (6,489 pages):

• mAP: 0.7559
• mAP@50: 0.9218
• mAP@75: 0.8207
• mAP (small): 0.5363
• mAP (medium): 0.6524
• mAP (large): 0.8064
• mAR@1: 0.3834
• mAR@10: 0.7858
• mAR@100: 0.8386
• mAR (small): 0.7269
• mAR (medium): 0.7735
• mAR (large): 0.8964

Per-class results (epoch 40)

Model description

Fine-tuned version of Roboflow/rf-detr-large for document layout analysis.

It detects the 11 layout regions annotated in DocLayNet v1.2 dataset:

{
  "0": "Caption",
  "1": "Footnote",
  "2": "Formula",
  "3": "List - item",
  "4": "Page - footer",
  "5": "Page - header",
  "6": "Picture",
  "7": "Section - header",
  "8": "Table",
  "9": "Text",
  "10": "Title"
}

This was an exploratory run: the schedule (40 epochs, cosine, LR 5e-5) was not tuned and the published weights are the last checkpoint, not the best-scoring one.

33.6 M parameters (FP32, ~128 MiB), ViT backbone at 704 x 704, up to 300 boxes per page.

Intended uses & limitations

Usage

Requires transformers ≥ 5.9.0

import torch
from PIL import Image, ImageDraw, ImageFont
from transformers import AutoImageProcessor, AutoModelForObjectDetection

checkpoint_name = "nie3e/rf-detr-large-doclay"
device = "cuda" if torch.cuda.is_available() else "cpu"
image_processor = AutoImageProcessor.from_pretrained(checkpoint_name)
model = AutoModelForObjectDetection.from_pretrained(checkpoint_name).to(device)
model.eval()

image = Image.open("/path/to/your/image.jpg").convert("RGB")

# Inference
with torch.no_grad():
    inputs = image_processor(images=[image], return_tensors="pt").to(device)
    outputs = model(**inputs)

    target_sizes = torch.tensor([[image.height, image.width]])

    results = image_processor.post_process_object_detection(
        outputs,
        threshold=0.5,  # change this if needed
        target_sizes=target_sizes,
    )[0]

# Print detections
for score, label, box in zip(
    results["scores"],
    results["labels"],
    results["boxes"],
):
    box = [round(x, 2) for x in box.tolist()]

    print(
        f"Detected {model.config.id2label[label.item()]} "
        f"with confidence {score.item():.3f} "
        f"at {box}"
    )

# Show detections
draw = ImageDraw.Draw(image)
colors = {
    "Caption": "#F59E0B",
    "Footnote": "#8B5CF6",
    "Formula": "#EC4899",
    "List - item": "#14B8A6",
    "Page - footer": "#64748B",
    "Page - header": "#06B6D4",
    "Picture": "#7C3AED",
    "Section - header": "#F97316",
    "Table": "#22C55E",
    "Text": "#2563EB",
    "Title": "#DC2626",
}

try:
    font = ImageFont.truetype("DejaVuSans-Bold.ttf", 18)
except OSError:
    font = ImageFont.load_default(size=18)
for score, label, box in zip(
        results["scores"], results["labels"], results["boxes"]
):
    box = [round(i, 2) for i in box.tolist()]
    x, y, x2, y2 = tuple(box)

    label_name = model.config.id2label[label.item()]
    color = colors.get(label_name, "red")

    draw.rectangle((x, y, x2, y2), outline=color, width=2)

    text = f"{label_name} {score:.2f}"

    text_bbox = draw.textbbox((0, 0), text, font=font)
    text_width = text_bbox[2] - text_bbox[0]
    text_height = text_bbox[3] - text_bbox[1]

    padding = 4

    bg_x1 = x
    bg_y1 = max(0, y - text_height - 2 * padding)
    bg_x2 = x + text_width + 2 * padding
    bg_y2 = y

    draw.rounded_rectangle(
        (bg_x1, bg_y1, bg_x2, bg_y2),
        radius=4,
        fill=color
    )

    draw.text(
        (x + padding, bg_y1 + padding - text_bbox[1]),
        text,
        font=font,
        fill="white"
    )

image.show()

Limitations

• may not perform well on small objects, mAP (small) 0.5363 vs 0.8064 for large
• boxes and class ids only
• no OCR
• no masks
• no table cell structure
• no reading order
• weakest classes: Formula, Page - footer, Page - header
• print-oriented corpus

Sample detections

Example 1 Example 2 Example 3

Training and evaluation data

Dataset: DocLayNet v1.2

Evaluation was run every 5 epochs on the validation split.

Data augmentation

Applied to the train split only (validation is used raw).

import albumentations as A

train_augment = A.Compose(
    [
        A.RandomBrightnessContrast(brightness_limit=0.2,
                                   contrast_limit=0.2, p=0.5),
        A.HueSaturationValue(hue_shift_limit=5, sat_shift_limit=10,
                             val_shift_limit=10, p=0.2),
        A.Rotate(limit=2, border_mode=0, value=(255, 255, 255), p=0.3),
        A.Affine(translate_percent=(-0.05, 0.05), scale=(0.95, 1.05),
                 rotate=0, p=0.3),
        A.GaussNoise(p=0.15),
        A.ImageCompression(quality_range=(85, 100), p=0.2),
        A.Blur(blur_limit=3, p=0.15),
    ],
    bbox_params=A.BboxParams(
        format="coco",
        label_fields=["category"],
        clip=True,
        min_area=4,
    ),
)

Training procedure

Training hyperparameters

The following hyperparameters were used during training:

• learning_rate: 5e-05
• train_batch_size: 8
• eval_batch_size: 8
• seed: 42
• distributed_type: multi-GPU
• num_devices: 4
• gradient_accumulation_steps: 4
• total_train_batch_size: 128
• total_eval_batch_size: 32
• optimizer: AdamW (fused PyTorch implementation), β=(0.9, 0.999), ε=1e-8
• lr_scheduler_type: cosine
• num_epochs: 40

Training results

Metrics by epoch

Per-class mAP by epoch

Per-class mAR@100 by epoch

Framework versions

• Transformers 5.17.0
• PyTorch 2.13.0+rocm10.0.0
• Datasets 5.0.1
• Tokenizers 0.23.2
• Albumentations 2.0.8
• Accelerate 1.15.0

Citation

This model is a fine-tune of RF-DETR trained on DocLayNet. If you use it, please cite both:

@article{robinson2025rfdetr,
  title   = {RF-DETR: Neural Architecture Search for Real-Time Detection Transformers},
  author  = {Robinson, Isaac and Robicheaux, Peter and Popov, Matvei and Ramanan, Deva and Peri, Neehar},
  journal = {arXiv preprint arXiv:2511.09554},
  year    = {2025},
  url     = {https://arxiv.org/abs/2511.09554}
}

@inproceedings{pfitzmann2022doclaynet,
  title     = {DocLayNet: A Large Human-Annotated Dataset for Document-Layout Analysis},
  author    = {Pfitzmann, Birgit and Auer, Christoph and Dolfi, Michele and Nassar, Ahmed S. and Staar, Peter W. J.},
  booktitle = {Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (KDD 22)},
  year      = {2022},
  doi       = {10.1145/3534678.3539043},
  url       = {https://arxiv.org/abs/2206.01062}
}