Unlimited-OCR: Análisis de documentos de horizonte largo en un solo paso de Baidu | AIBit-Descubre proyectos de código abierto

¿Qué es Unlimited-OCR?

Unlimited-OCR es un nuevo modelo OCR de código abierto de Baidu que busca ampliar los límites del análisis de documentos, específicamente apuntando al análisis de horizonte largo en un solo paso. A diferencia de los sistemas OCR tradicionales que procesan páginas una por una o dependen de ventanas deslizantes, Unlimited-OCR puede tomar un documento completo de varias páginas (o una sola imagen de alta resolución) y producir una salida de texto estructurada en un solo paso hacia adelante.

Este es un avance significativo para la comprensión de documentos, especialmente para contenido extenso como artículos de investigación, contratos legales o informes de varias páginas.

Por qué es importante

La mayoría de los pipelines OCR dividen los documentos en páginas o regiones individuales, las procesan de forma independiente y luego unen los resultados. Este enfoque tiene varios inconvenientes:

Pérdida de contexto: Se pierde información que abarca los límites de las páginas.
Inferencia lenta: Cada página requiere una llamada de modelo separada.
Pipeline complejo: Se necesita detección de páginas, ordenamiento y lógica de fusión.

Unlimited-OCR resuelve esto aceptando múltiples imágenes (o un PDF convertido a imágenes) y generando una única salida coherente. El modelo soporta una longitud de contexto de 32,768 tokens, suficiente para cubrir docenas de páginas densas.

Características clave

Análisis de horizonte largo en un solo paso: Alimenta varias páginas a la vez, obtén una sola salida.
Dos modos de inferencia: gundam (basado en recortes, tamaño de imagen 640px) para imágenes individuales con detalle fino, y base (tamaño de imagen 1024px) para análisis de varias páginas o PDF.
Soporte para vLLM y SGLang: Despliega con motores de inferencia de grado de producción.
Código abierto: Licencia MIT, disponible en GitHub y Hugging Face.
Longitud de contexto de 32K: Maneja documentos largos sin truncamiento.

Cómo usar Unlimited-OCR

Inicio rápido con Transformers

La forma más sencilla de empezar es con Hugging Face Transformers. Aquí tienes un ejemplo mínimo:

import torch
from transformers import AutoModel, AutoTokenizer

model_name = 'baidu/Unlimited-OCR'

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,
)
model = model.eval().cuda()

# Análisis de una sola imagen (modo gundam para alto detalle)
model.infer(
    tokenizer,
    prompt='<image>document parsing.',
    image_file='your_image.jpg',
    output_path='./output',
    base_size=1024, image_size=640, crop_mode=True,
    max_length=32768,
    no_repeat_ngram_size=35, ngram_window=128,
    save_results=True,
)

Análisis de varias páginas / PDF

Para documentos de varias páginas, convierte cada página en una imagen y usa infer_multi:

import fitz  # PyMuPDF

def pdf_to_images(pdf_path, dpi=300):
    doc = fitz.open(pdf_path)
    mat = fitz.Matrix(dpi / 72, dpi / 72)
    paths = []
    for i, page in enumerate(doc):
        out = f'page_{i+1:04d}.png'
        page.get_pixmap(matrix=mat).save(out)
        paths.append(out)
    doc.close()
    return paths

model.infer_multi(
    tokenizer,
    prompt='<image>Multi page parsing.',
    image_files=pdf_to_images('your_doc.pdf', dpi=300),
    output_path='./output',
    image_size=1024,
    max_length=32768,
    no_repeat_ngram_size=35, ngram_window=1024,
    save_results=True,
)

Despliegue con vLLM

Para producción, vLLM es el motor de inferencia recomendado. Baidu proporciona imágenes Docker preconstruidas:

# Predeterminado (CUDA 13.0)
docker pull vllm/vllm-openai:unlimited-ocr

# Para GPUs Hopper (CUDA 12.9)
docker pull vllm/vllm-openai:unlimited-ocr-cu129

Luego sigue la receta oficial: https://recipes.vllm.ai/baidu/Unlimited-OCR

Despliegue con SGLang

SGLang también es compatible. Configura el entorno e inicia el servidor:

uv venv --python 3.12
source .venv/bin/activate
uv pip install wheel/sglang-0.0.0.dev11416+g92e8bb79e-py3-none-any.whl
uv pip install kernels==0.11.7
uv pip install pymupdf==1.27.2.2

python -m sglang.launch_server \
    --model baidu/Unlimited-OCR \
    --served-model-name Unlimited-OCR \
    --attention-backend fa3 \
    --page-size 1 \
    --mem-fraction-static 0.8 \
    --context-length 32768 \
    --enable-custom-logit-processor \
    --disable-overlap-schedule \
    --skip-server-warmup \
    --host 0.0.0.0 \
    --port 10000

Luego envía solicitudes a través de la API compatible con OpenAI:

import requests

response = requests.post(
    "http://127.0.0.1:10000/v1/chat/completions",
    json={
        "model": "Unlimited-OCR",
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "document parsing."},
                    {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
                ]
            }
        ],
        "temperature": 0,
        "images_config": {"image_mode": "gundam"},
        "custom_logit_processor": "DeepseekOCRNoRepeatNGramLogitProcessor",
        "custom_params": {"ngram_size": 35, "window_size": 128},
        "stream": True,
    },
    timeout=1200,
    stream=True,
)

Rendimiento y benchmarks

Aunque el README no incluye benchmarks detallados, la arquitectura del modelo está diseñada para el análisis de horizonte largo. La longitud de contexto de 32K y el parámetro no_repeat_ngram_size (configurado en 35) ayudan a evitar la repetición en salidas largas, un problema común en modelos autorregresivos.

El modo gundam utiliza un enfoque basado en recortes con image_size=640, ideal para imágenes individuales donde el detalle fino importa (por ejemplo, una página densa de texto). El modo base usa image_size=1024 sin recortes, más adecuado para documentos de varias páginas donde el diseño global es importante.

Comparación con DeepSeek-OCR

Unlimited-OCR se posiciona explícitamente como un avance de "DeepSeek-OCR un paso más allá". Las mejoras clave parecen ser:

Contexto más largo: 32K tokens frente a modelos anteriores.
Soporte para varias páginas: Manejo nativo de múltiples imágenes en un solo paso.
Listo para producción: Soporte para vLLM y SGLang de serie.
Código abierto: Licencia MIT, completamente reproducible.

Casos de uso

Análisis de artículos de investigación: Alimenta un PDF completo, obtén texto estructurado.
Análisis de documentos legales: Contratos, acuerdos y formularios.
Procesamiento de facturas y recibos: Procesamiento por lotes de documentos.
Digitalización de documentos históricos: Documentos largos con diseños complejos.
Pipelines RAG: Usa Unlimited-OCR como analizador de documentos antes de la indexación.

Primeros pasos

Clona el repositorio: git clone https://github.com/baidu/Unlimited-OCR
Instala las dependencias: pip install torch transformers pillow pymupdf
Ejecuta la inferencia con los ejemplos anteriores.
Para producción, usa las imágenes Docker de vLLM.

Conclusión

Unlimited-OCR es una solución práctica y de código abierto para el análisis de documentos de horizonte largo en un solo paso. Su soporte para entradas de varias páginas, contexto de 32K y motores de inferencia de grado de producción lo convierten en una opción sólida para desarrolladores que construyen pipelines de comprensión de documentos. La licencia MIT y el soporte activo de la comunidad (más de 13k estrellas en GitHub) sugieren que continuará evolucionando.

Si trabajas con OCR, análisis de documentos o pipelines RAG, este es un proyecto que vale la pena probar.

Fuente

baidu/Unlimited-OCR: Unlimited OCR Works: Welcome the Era of One-shot Long-horizon Parsing.