Transformers documentation

UnlimitedOcr

Transformers

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).

Join the Hugging Face community

and get access to the augmented documentation experience

Collaborate on models, datasets and Spaces

Faster examples with accelerated inference

Switch between documentation themes

to get started

Ce modèle a été publié dans les papiers HF le 2026-06-23 et contribué à Hugging Face Transformers le 2026-10-14.

UnlimitedOcr

Aperçu

Le modèle UnlimitedOcr a été proposé dans Unlimited OCR Works par Youyang Yin, Huanhuan Liu, Qunyi Xie, Chaorun Liu, Shiqi Yang, Shaohua Wang, Zhanlong Liu, Hao Zou, Jinyue Chen, Shu Wei, Jingjing Wu, Mingxin Huang, Zhen Wu, Guibin Wang, Tengyu Du et Lei Jia de Baidu Inc.

Il s’agit d’un modèle unique de 3 milliards de paramètres, avec une longueur de contexte standard de 32 768 jetons.

L'abstract de l'article est le suivant :

Récemment, les modèles OCR de bout en bout, illustrés par DeepSeek OCR, ont à nouveau placé l’OCR au cœur de l’attention. L’opinion largement partagée est que l’utilisation d’un grand modèle de langage (LLM) comme décodeur permet au modèle d’exploiter la distribution a priori du langage, ce qui améliore les performances OCR. Cependant, l’inconvénient est tout aussi évident : à mesure que la séquence de sortie s’allonge, le cache KV accumulé augmente la consommation mémoire et ralentit progressivement la génération. Cela contraste fortement avec les humains, qui ne présentent aucune telle baisse d’efficacité lors de tâches de copie de longue durée. Dans ce rapport technique, nous proposons Unlimited OCR, un modèle conçu pour émuler la mémoire de travail d’analyse humaine. En prenant DeepSeek OCR comme référence, nous remplaçons toutes les couches d’attention du décodeur par notre mécanisme Reference Sliding Window Attention (R-SWA), qui réduit les coûts de calcul d’attention tout en maintenant un cache KV constant tout au long du processus de décodage. En combinant le taux de compression élevé de l’encodeur de DeepSeek OCR avec notre conception à cache KV constant, Unlimited OCR peut transcrire des dizaines de pages de documents en une seule passe avant sous une longueur maximale standard de 32K. Plus important encore, R-SWA est un mécanisme d’attention d’analyse à usage général — au-delà de l’OCR, il est tout aussi applicable à des tâches telles que l’ASR, la traduction, etc. Les codes et les poids du modèle sont publiquement disponibles sur http://github.com/baidu/Unlimited-OCR

Unlimited-OCR prend en charge deux configurations d’inférence : le mode « gundam » par défaut utilise des tuiles de 640x640 avec un recadrage dynamique pour les documents haute résolution, tandis que le mode « base » utilise une vue globale unique de 1024x1024 pour les entrées de résolution standard. Pour activer le mode base, définissez crop_to_patches=False dans le processeur, ou transmettez-le via processor_kwargs lors de l’utilisation de apply_chat_template().

La tour de vision suit l’approche en deux étapes de DeepSeek-OCR-2 : un encodeur SAM ViT-B alimente un encodeur CLIP ViT. Contrairement à DeepSeek-OCR-2, les caractéristiques CLIP sont également concaténées avec les caractéristiques SAM pour produire les jetons d’image finaux. Unlimited-OCR omet également les requêtes de patch apprenables de DeepSeek-OCR-2.

Le modèle de texte est identique à DeepSeek-OCR-2, avec l’ajout de l’Attention à fenêtre glissante de référence (R-SWA). R-SWA ne s’applique qu’aux jetons générés. Tous les jetons d’image et de prompt restent entièrement visibles tout au long du décodage, de sorte que les documents longs ne perdent pas le contexte des pages précédentes.

Ce modèle a été contribué par guarin. Le code d'origine peut être trouvé ici.

L’implémentation d’origine exécute le modèle avec torch.autocast en bfloat16. Enveloppez les appels forward et generate dans un contexte autocast pour reproduire ses sorties.
with torch.autocast(device_type=model.device.type, dtype=torch.bfloat16):
    output = model.generate(**inputs)

OCR sur une seule page

OCR multi-pages

from transformers import AutoProcessor, AutoModelForImageTextToText

model = AutoModelForImageTextToText.from_pretrained("baidu/Unlimited-OCR", device_map="auto")
processor = AutoProcessor.from_pretrained("baidu/Unlimited-OCR")

image = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg"
messages = [
    {
        "role": "user",
        "content": [{"type": "image", "url": image}, {"type": "text", "text": "document parsing."}],
    }
]
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt"
).to(model.device, model.dtype)

output = model.generate(**inputs, max_new_tokens=512)
processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
# image [383, 87, 497, 171]\ntext [333, 201, 558, 230]R&D QUALITY IMPROVEMENT\nSUGGESTION/SOLUTION FORM...

# All bounding boxes are in (x1, y1, x2, y2) format with coordinates normalized to [0, 999]

Traitement par lots

Pour le traitement par lots, passez une liste de messages. Définissez padding=True pour le processeur si les images ont des tailles différentes.

from transformers import AutoProcessor, AutoModelForImageTextToText

model = AutoModelForImageTextToText.from_pretrained("baidu/Unlimited-OCR", device_map="auto")
processor = AutoProcessor.from_pretrained("baidu/Unlimited-OCR")

image1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg"
image2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_receipt.jpeg"
messages = [
    [
        {
            "role": "user",
            "content": [{"type": "image", "url": image}, {"type": "text", "text": "document parsing."}],
        }
    ]
    for image in [image1, image2]
]
inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    processor_kwargs={"padding": True},
).to(model.device, model.dtype)

output = model.generate(**inputs)
processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
# image [383, 87, 497, 171]\ntext [333, 201, 558, 230]R&D QUALITY IMPROVEMENT\nSUGGESTION/SOLUTION FORM...

# All bounding boxes are in (x1, y1, x2, y2) format with coordinates normalized to [0, 999]

Détections de régions

Définissez skip_special_tokens=False pour encadrer toutes les détections et les types de régions par les marqueurs <|det|>...<|/det|>. Cela est utile pour le post-traitement ultérieur de la sortie, par exemple pour tracer les boîtes englobantes détectées sur l'image. Chaque détection est encadrée sous la forme <|det|>region_type [x1, y1, x2, y2]<|/det|>text... avec des coordonnées normalisées sur l'intervalle [0, 999]. Définissez return_detections=True pour obtenir une liste supplémentaire de dictionnaires contenant toutes les détections analysées sous la forme {"region_type": region_type, "box": [x1, y1, x2, y2], "text": "..."}.

from transformers import AutoProcessor, AutoModelForImageTextToText

model = AutoModelForImageTextToText.from_pretrained("baidu/Unlimited-OCR", device_map="auto")
processor = AutoProcessor.from_pretrained("baidu/Unlimited-OCR")

image = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg"
messages = [
    {
        "role": "user",
        "content": [{"type": "image", "url": image}, {"type": "text", "text": "document parsing."}],
    }
]
inputs = processor.apply_chat_template(
    messages, add_generation_prompt=True, tokenize=True, return_dict=True, return_tensors="pt"
).to(model.device, model.dtype)

output = model.generate(**inputs)
decoded, detections = processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=False, return_detections=True)
# <|det|>image [383, 87, 497, 171]<|/det|>\n<|det|>text [333, 201, 558, 230]<|/det|>R&D QUALITY IMPROVEMENT\nSUGGESTION/SOLUTION FORM...

# Visualization
import random
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from transformers.image_utils import load_image

image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg")
width, height = image.size

figure, axis = plt.subplots(figsize=(10, 12))
axis.imshow(image)
for detection in detections:
    region_type = detection["region_type"]
    x1, y1, x2, y2 = detection["box"]
    x1, y1, x2, y2 = int(x1) / 999 * width, int(y1) / 999 * height, int(x2) / 999 * width, int(y2) / 999 * height
    color = (random.random(), random.random(), random.random())
    rectangle = patches.Rectangle((x1, y1), x2 - x1, y2 - y1, linewidth=1.5, edgecolor=color, facecolor="none")
    axis.add_patch(rectangle)
    axis.text(x1, y1, region_type, color="white", fontsize=8, backgroundcolor=color, verticalalignment="top")
axis.axis("off")
plt.show()

Transformers

UnlimitedOcr

Aperçu

Traitement par lots

Détections de régions

UnlimitedOcrConfig

classe transformers.UnlimitedOcrConfig

UnlimitedOcrTextConfig

classe transformers.UnlimitedOcrTextConfig

UnlimitedOcrVisionConfig

classe transformers.UnlimitedOcrVisionConfig

UnlimitedOcrVisionEncoderConfig

classe transformers.UnlimitedOcrVisionEncoderConfig

UnlimitedOcrSamVisionConfig

classe transformers.UnlimitedOcrSamVisionConfig

UnlimitedOcrImageProcessor

classe transformers.UnlimitedOcrImageProcessor

crop_image_to_patches

get_number_of_image_patches

pad_to_square

UnlimitedOcrProcessor

classe transformers.UnlimitedOcrProcessor

batch_decode

décoder

UnlimitedOcrPreTrainedModel

classe transformers.UnlimitedOcrPreTrainedModel

UnlimitedOcrTextPreTrainedModel

classe transformers.UnlimitedOcrTextPreTrainedModel

UnlimitedOcrTextModel

classe transformers.UnlimitedOcrTextModel

forward

UnlimitedOcrVisionModel

classe transformers.UnlimitedOcrVisionModel

forward

UnlimitedOcrModel

classe transformers.UnlimitedOcrModel

forward

UnlimitedOcrForConditionalGeneration

classe transformers.UnlimitedOcrForConditionalGeneration

forward