Unlimited-OCR 2: el modelo OCR abierto de Baidu que convierte PDFs largos en texto listo para RAG

1. La ficha técnica

Unlimited-OCR 2 mantiene el cuerpo de v1: un encoder de visión al estilo DeepSeek-OCR que alimenta un decoder chico de mixture-of-experts. Lo que cambia es cómo el decoder vuelve a mirar las páginas. Acá lo tenés al lado de v1, según las cards, la API de HF y el config.json.

2. Qué trae v2: de parsing largo a parsing ilimitado

La idea de v1 era R-SWA, Reference Sliding Window Attention. Mantenía constante la caché KV mientras el modelo escribía, así que podía transcribir decenas de páginas con un límite de 32K. Pero cada token nuevo seguía atendiendo a todos los tokens visuales de todas las páginas. Con cien páginas, ese contexto visual se vuelve el cuello de botella, y cada paso de decodificación se hace más lento a medida que el documento crece.

v2 reemplaza todas las capas de atención del decoder por SR-SWA, Sparse Reference Sliding Window Attention, y suma una forma nueva de correr documentos largos. La analogía del paper es alguien copiando un libro: la vista en la página actual y un vistazo rápido hacia atrás cuando una tabla sigue en la otra hoja. Tiene tres partes.

Las tres partes, en criollo

El resultado, según el paper: a escala de cien páginas, cada paso de decodificación es 7,0× más rápido que con atención completa y 5,6× más rápido que con el R-SWA de v1 (detalles en la sección 3). En MPDocBench, con documentos de hasta 30 páginas, v2 le gana a v1 en todas las métricas, sobre todo donde el contenido cruza un salto de página.

3. Benchmarks contra otros modelos (autorreportados)

El leaderboard de Baidu enfrenta a v2 con modelos de visión y lenguaje de uso general en dos benchmarks multipágina. Los modelos de OCR dedicados como DeepSeek-OCR 2 solo aparecen en la tabla de una página del paper, así que lo separé en dos tablas.

En MPDocBench la ventaja es real pero moderada: 6,3 puntos sobre Qwen3.8-Max. En MarathonDocBench son 43 puntos sobre el siguiente modelo, y la letra chica explica buena parte de esa diferencia.

En una sola página, v2 es básicamente v1: 94.02 vs 93.92 de overall, con un puntaje de tablas un poco más bajo (89.60 vs 90.16). Le gana a DeepSeek-OCR 2 y a dots.ocr, pero dos modelos más chicos, TeleOCR y OvisOCR2, sacan más. PaddleOCR-VL no está en la tabla: Baidu usó PaddleOCR-VL-v1.6 para generar pseudo-etiquetas. Para documentos de una o dos páginas, v2 no es la elección obvia. Su fuerte es el largo.

4. Quickstart: Transformers, SGLang y un paso de ingesta para RAG

La card de v2 documenta dos caminos: Transformers “for quick tests” y SGLang, “recommended for serving”. Todos los bloques de abajo están copiados de la card, salvo los dos últimos, que son glue mío y lo aclaran. Los dos caminos asumen una GPU NVIDIA, y el setup de SGLang además asume Linux. Si leíste que v2 trae recetas para vLLM y Docker Model Runner, no están en ninguna revisión de la card; la receta de vLLM es para v1.

pip install torch==2.13.0 torchvision pillow transformers==4.52.1 huggingface-hub==0.36.0 \
  tokenizers==0.21.4 addict==2.4.0 einops==0.8.2 easydict==1.13

import torch
from transformers import AutoModel, AutoTokenizer

model_name = "baidu/Unlimited-OCR-2"
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModel.from_pretrained(model_name, trust_remote_code=True, use_safetensors=True,
                                  torch_dtype=torch.bfloat16).eval().cuda()

# Multi-page inference: all pages in one request, in page order
pages = [f"your_doc/page_{i}.jpg" for i in range(1, 8)]

text, num_tokens = model.infer_multi(tokenizer, image_files=pages,
                                     output_path="output/multi", save_results=True)

# Single-page inference: dynamic tiling (gundam mode) by default
text = model.infer(tokenizer, image_file="your_doc/page_1.jpg",
                   output_path="output/single", save_results=True)

uv venv --python 3.10
source .venv/bin/activate

uv pip install wheel/sglang-0.5.20.dev13+g75b9b06b02-py3-none-any.whl
uv pip install pymupdf==1.27.2.2
uv pip install fastokens==0.3.2

# Page-window scheduling for very long documents (the KV tail of the previous window is reused).
export SGLANG_UOCR_EANABLE_DOC_LIMIT=1          # 1 = enable, 0 = whole document in one window
export SGLANG_UOCR_DOC_GUNDAM_PAGE_WINDOW=10    # pages per window (gundam mode)
export SGLANG_UOCR_DOC_BASE_PAGE_WINDOW=10      # pages per window (base mode)
export SGLANG_UOCR_MAX_PAGE_TOKENS=20000        # per-page output cap; must be > 0
# Chunk cap for the SAM attention bias. The built-in default (512) allows a single
# ~462 MiB allocation and can OOM; 64 is equivalent with a lower peak.
export SGLANG_OPT_UOCR_SAM_REL_POS_BIAS_MB=64
# Pass large crop tensors through /dev/shm instead of pickling them into the
# tokenizer -> scheduler frame.
export SGLANG_UOCR_SHM_WRAP_MODEL_DATA=1
export SGLANG_UOCR_SHM_WRAP_MIN_MB=1
export SGLANG_VLM_CACHE_SIZE_MB=0
# Reduces fragmentation failures on the large contiguous allocations.
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True

python -m sglang.launch_server \
    --model-path baidu/Unlimited-OCR-2 \
    --served-model-name Unlimited-OCR-2 \
    --chat-template unlimited-ocr \
    --tokenizer-backend fastokens \
    --tokenizer-worker-num 8 \
    --mem-fraction-static 0.7 \
    --max-running-requests 64 \
    --max-prefill-tokens 2048 \
    --enable-custom-logit-processor \
    --enable-streaming-session \
    --allow-auto-truncate \
    --disable-radix-cache \
    --mm-preprocess-cache-size-mb 0 \
    --cuda-graph-backend-decode full --cuda-graph-max-bs-decode 64 \
    --cuda-graph-backend-prefill full \
    --cuda-graph-max-bs-prefill 16384 \
    --cuda-graph-bs-prefill 1024 2048 \
    --cuda-graph-config '{"prefill": {"backend": "full", "full_prefill_max_req": 64}}' \
    --host 0.0.0.0 \
    --port 10000

import base64
import json
import os
import tempfile

import fitz
import requests
from sglang.srt.sampling.custom_logit_processor import DeepseekOCRNoRepeatNGramLogitProcessor

server_url = "http://127.0.0.1:10000"
NGRAM_PROCESSOR = DeepseekOCRNoRepeatNGramLogitProcessor.to_str()

session = requests.Session()
session.trust_env = False


def pdf_to_images(pdf_path, dpi=300):
    doc = fitz.open(pdf_path)
    tmp_dir = tempfile.mkdtemp(prefix="pdf_ocr_")
    mat = fitz.Matrix(dpi / 72, dpi / 72)
    image_paths = []
    for i, page in enumerate(doc):
        image_path = os.path.join(tmp_dir, f"page_{i + 1:04d}.png")
        page.get_pixmap(matrix=mat).save(image_path)
        image_paths.append(image_path)
    doc.close()
    return image_paths


def encode_image(image_path):
    ext = os.path.splitext(image_path)[1].lower()
    mime = "image/jpeg" if ext in (".jpg", ".jpeg") else f"image/{ext.lstrip('.')}"
    with open(image_path, "rb") as f:
        data = base64.b64encode(f.read()).decode("utf-8")
    return {"type": "image_url", "image_url": {"url": f"data:{mime};base64,{data}"}}


def build_content(image_paths):
    prompt = "<PAGE><image>" * len(image_paths) + "Multi page parsing."
    return [encode_image(path) for path in image_paths] + [{"type": "text", "text": prompt}]


def generate(image_paths, crop_mode=True, tokens_per_page=8000):
    # A wider n-gram window for multi-page documents, as in our evaluation setup.
    window_size = 1024 if len(image_paths) > 1 else 128
    payload = {
        "model": "Unlimited-OCR-2",
        "messages": [{"role": "user", "content": build_content(image_paths)}],
        # Must be positive: it is the global output budget for the whole document.
        "max_tokens": tokens_per_page * len(image_paths),
        "temperature": 0,
        "skip_special_tokens": False,
        "images_config": {"crop_mode": crop_mode},  # True = gundam (tiles), False = base
        "custom_logit_processor": NGRAM_PROCESSOR,
        "custom_params": {
            "ngram_size": 35,
            "window_size": window_size,
            "page_token_id": 128827,   # <PAGE> marker id (= sparse_attention_config.page_token_id)
            "eos_token_id": 1,         # = eos_token_id in config.json
            "max_page_tokens": 20000,  # per-page output cap, <= 0 disables the page guard
        },
        "stream": True,
    }
    response = session.post(
        f"{server_url}/v1/chat/completions",
        headers={"Content-Type": "application/json"},
        data=json.dumps(payload),
        timeout=6000,
        stream=True,
    )
    response.raise_for_status()

    chunks = []
    for line in response.iter_lines(decode_unicode=True):
        if not line or not line.startswith("data:"):
            continue
        data = line[len("data:"):].strip()
        if data == "[DONE]":
            break
        event = json.loads(data)
        choices = event.get("choices") or []  # the final chunk carries usage only
        if not choices:
            continue
        delta = (choices[0].get("delta") or {}).get("content") or ""
        if delta:
            print(delta, end="", flush=True)
            chunks.append(delta)
    return "".join(chunks)


# Multi page: all pages of a document, parsed in one request
pages = [f"your_doc/page_{i}.jpg" for i in range(1, 8)]
generate(pages)

# Single page
generate(["your_doc/page_1.jpg"])

# PDF
generate(pdf_to_images("your_doc.pdf", dpi=300))

Del PDF a los chunks: un paso de ingesta para RAG

Así lo conectaría yo a la ingesta. El cliente de la card ya renderiza el PDF a imágenes de 300 DPI y devuelve la salida cruda. El primer bloque de abajo la guarda de tres formas: cruda, como Markdown del documento completo para chunking, y como un Markdown por página para las citas. El segundo es un chunker mínimo que respeta los títulos. Probé el chunker con un Markdown de ejemplo escrito a mano; ninguno de los dos bloques vio salida real del modelo. Si estás eligiendo estrategia, mi guía de chunking para RAG compara chunking fijo, semántico y tardío.

# Glue code (mine, not from the model card). Run it after the card's client above.
# Needs utils/process_unlimitedOCR2.py from github.com/baidu/Unlimited-OCR (stdlib only).
import sys
from pathlib import Path

sys.path.append("Unlimited-OCR/utils")
import process_unlimitedOCR2 as uocr

# My tweak: running headers, footers and page numbers repeat on every page
uocr.DROP_LABELS.update({"header", "footer", "page_number"})


def save_for_chunker(doc_id, raw, out_dir="ocr_out"):
    out = Path(out_dir)
    out.mkdir(parents=True, exist_ok=True)
    # 1) Raw layout blocks: one <PAGE> marker per input page, with bounding boxes
    (out / f"{doc_id}.raw.txt").write_text(raw, encoding="utf-8")
    # 2) Whole-document Markdown: cross-page tables and paragraphs merged
    (out / f"{doc_id}.md").write_text(uocr.convert(raw), encoding="utf-8")
    # 3) One Markdown file per page, for page-level citations (no cross-page merging)
    pages = raw.split("<PAGE>")[1:]
    for n, page in enumerate(pages, start=1):
        (out / f"{doc_id}.p{n:04d}.md").write_text(uocr.convert(page), encoding="utf-8")
    return len(pages)


raw = generate(pdf_to_images("your_doc.pdf", dpi=300))
print(save_for_chunker("your_doc", raw), "pages saved")

# Glue code (mine): split on Markdown headings, then pack blocks up to a size cap.
import re


def chunk_markdown(md, doc_id, max_chars=2000):
    chunks = []
    for section in re.split(r"(?m)^(?=#{1,6} )", md):
        section = section.strip()
        if not section:
            continue
        heading = section.splitlines()[0] if section.startswith("#") else ""
        buf = ""
        # convert() separates blocks with blank lines, so a table usually stays whole
        for block in section.split("\n\n"):
            if buf.strip() not in ("", heading) and len(buf) + len(block) > max_chars:
                chunks.append({"doc": doc_id, "heading": heading, "text": buf.strip()})
                buf = ""
            buf += block + "\n\n"
        if buf.strip() not in ("", heading):
            chunks.append({"doc": doc_id, "heading": heading, "text": buf.strip()})
    return chunks


md = open("ocr_out/your_doc.md", encoding="utf-8").read()
chunks = chunk_markdown(md, "your_doc")
print(len(chunks), "chunks ready for your embedding model")

5. Límites honestos

Tenelos en cuenta antes de pasar tu archivo de documentos por este modelo.

Veredicto: ¿va a tu pipeline RAG?

Si tu corpus son PDFs largos (manuales, presentaciones regulatorias, informes, libros, archivos escaneados) y tenés una GPU NVIDIA, Unlimited-OCR 2 es el lanzamiento de OCR abierto más interesante del mes. Lee un documento entero en un solo request, mantiene juntas las tablas que cruzan saltos de página y sale con licencia MIT. Esas fallas entre páginas son justamente las que arruinan el chunking más adelante.

No es una mejora universal. En una sola página es v1 con una capa de atención nueva, hay modelos más chicos que sacan más, y todos los números son de Baidu. Tomá los benchmarks como un motivo para probar, no para migrar: pasá 20 documentos tuyos, compará el Markdown con el de tu parser actual y mirá con lupa las tablas y los títulos.

Quién debería probarlo