Hugging Face's logo

Transformers documentation

UnlimitedOcr

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).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

Este modelo foi publicado em papers do HF em 2026-06-23 e contribuído para o Hugging Face Transformers em 2026-10-14.

UnlimitedOcr

Visão geral

O modelo UnlimitedOcr foi proposto em Unlimited OCR Works por 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 e Lei Jia, da Baidu Inc.

É um modelo único com 3B parâmetros e um comprimento de contexto padrão de 32.768 tokens.

O resumo do artigo é o seguinte:

Recentemente, modelos de OCR de ponta a ponta, exemplificados pelo DeepSeek OCR, colocaram o OCR novamente em destaque. Uma visão amplamente aceita é que o uso de um grande modelo de linguagem (LLM) como decodificador permite que o modelo aproveite a distribuição a priori da linguagem, resultando em melhor desempenho de OCR. No entanto, a desvantagem é igualmente evidente: à medida que a sequência de saída se alonga, o KV cache acumulado aumenta o consumo de memória e reduz progressivamente a velocidade de geração. Isso contrasta fortemente com os humanos, que não apresentam tal queda de eficiência em tarefas de cópia de longo prazo. Neste relatório técnico, propomos o Unlimited OCR, um modelo projetado para emular a memória de trabalho de análise humana. Tomando o DeepSeek OCR como linha de base, substituímos todas as camadas de atenção no decodificador pela nossa proposta de Reference Sliding Window Attention (R-SWA), que reduz os custos de computação de atenção mantendo um KV cache constante durante todo o processo de decodificação. Ao combinar a alta taxa de compressão do codificador do DeepSeek OCR com nosso design de KV cache constante, o Unlimited OCR pode transcrever dezenas de páginas de documentos em uma única passagem direta sob um comprimento máximo padrão de 32K. Mais importante ainda, a R-SWA é um mecanismo de atenção de análise de uso geral — além do OCR, é igualmente aplicável a tarefas como ASR, tradução, etc. Os códigos e pesos do modelo estão publicamente disponíveis em http://github.com/baidu/Unlimited-OCR

O Unlimited-OCR suporta duas configurações de inferência: o modo padrão “gundam” usa tiles de 640x640 com recorte dinâmico para documentos de alta resolução, e o modo “base” usa uma única visão global de 1024x1024 para entradas de resolução padrão. Para habilitar o modo base, defina crop_to_patches=False no processador ou passe-o via processor_kwargs ao usar apply_chat_template().

A torre de visão segue a abordagem em duas etapas do DeepSeek-OCR-2: um codificador SAM ViT-B alimenta um codificador CLIP ViT. Diferentemente do DeepSeek-OCR-2, os recursos do CLIP são adicionalmente concatenados com os recursos do SAM para gerar os tokens de imagem finais. O Unlimited-OCR também omite as consultas de patch aprendíveis do DeepSeek-OCR-2.

O modelo de texto é idêntico ao DeepSeek-OCR-2, com a adição da Reference Sliding Window Attention (R-SWA). A R-SWA é aplicada apenas aos tokens gerados. Todos os tokens de imagem e de prompt permanecem totalmente visíveis durante todo o decodificação, de modo que documentos longos não perdem o contexto de páginas anteriores.

Este modelo foi contribuído por guarin. O código original pode ser encontrado aqui.

A implementação original executa o modelo com torch.autocast em bfloat16. Envolve as chamadas de forward e generate em um contexto de autocast para reproduzir suas saídas.

with torch.autocast(device_type=model.device.type, dtype=torch.bfloat16):
    output = model.generate(**inputs)
OCR de página única
OCR de várias páginas
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]

Processamento em lote

Para processamento em lote, passe uma lista de mensagens. Defina padding=True no processador se as imagens tiverem tamanhos diferentes.

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]

Detecções de região

Defina skip_special_tokens=False para envolver todas as detecções e tipos de região em marcadores <|det|>...<|/det|>. Isso é útil para o pós-processamento adicional da saída, por exemplo, para plotar as caixas delimitadoras detectadas na imagem. Cada detecção é envolvida como <|det|>region_type [x1, y1, x2, y2]<|/det|>text... com coordenadas normalizadas para um intervalo de [0, 999]. Defina return_detections=True para obter uma lista adicional de dicionários com todas as detecções analisadas como {"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()

UnlimitedOcrConfig

classe transformers.UnlimitedOcrConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Nonetext_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneimage_token_id: int = 128815tie_word_embeddings: bool = False )

Parâmetros

  • vision_config (dict ou UnlimitedOcrVisionConfig, opcional) — Configuração para os codificadores de visão. O padrão é UnlimitedOcrVisionConfig().
  • text_config (Union[dict, ~configuration_utils.PreTrainedConfig], opcional) — O objeto de configuração ou dicionário do backbone de texto.
  • image_token_id (int, opcional, padrão 128815) — O índice do token de imagem usado como marcador de posição para as imagens de entrada.
  • tie_word_embeddings (bool, opcional, padrão False) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.

Esta é a classe de configuração para armazenar a configuração de um UnlimitedOcrModel. Ela é usada para instanciar um modelo Unlimited Ocr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do baidu/Unlimited-OCR

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import UnlimitedOcrConfig, UnlimitedOcrModel

>>> configuration = UnlimitedOcrConfig()
>>> model = UnlimitedOcrModel(configuration)
>>> configuration = model.config

UnlimitedOcrTextConfig

classe transformers.UnlimitedOcrTextConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 129280hidden_size: int = 1280intermediate_size: int = 6848num_hidden_layers: int = 12num_attention_heads: int = 10num_key_value_heads: int | None = 10hidden_act: str = 'silu'max_position_embeddings: int = 32768initializer_range: float = 0.02rms_norm_eps: float = 1e-06use_cache: bool = Truepad_token_id: int | None = Nonebos_token_id: int | None = 0eos_token_id: int | list[int] | None = 1pretraining_tp: int | None = 1tie_word_embeddings: bool = Falserope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = Noneattention_bias: bool = Falseattention_dropout: float | None = 0.0mlp_bias: bool = Falsehead_dim: int | None = Nonen_group: int | None = 1n_routed_experts: int = 64output_router_logits: bool = Falsen_shared_experts: int = 2routed_scaling_factor: float = 1.0topk_group: int | None = 1topk_method: str | None = 'greedy'num_experts_per_tok: int | None = 6moe_intermediate_size: int = 896mlp_layer_types: list[str] | None = Nonelayer_types: list[str] | None = Nonesliding_window: int | None = 128 )

Parâmetros

  • vocab_size (int, opcional, padrão 129280) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • hidden_size (int, opcional, padrão 1280) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 6848) — Dimensão das representações do MLP.
  • num_hidden_layers (int, opcional, padrão 12) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 10) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_key_value_heads (int, opcional, padrão 10) — Este é o número de cabeças de key_value que devem ser usadas para implementar Grouped Query Attention. Se num_key_value_heads=num_attention_heads, o modelo usará Multi Head Attention (MHA); se num_key_value_heads=1, o modelo usará Multi Query Attention (MQA); caso contrário, será usado GQA. Ao converter um checkpoint multi-head para um checkpoint GQA, cada grupo de cabeças de chave e valor deve ser construído por meio do meanpooling de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte este artigo. Se não for especificado, o valor padrão será num_attention_heads.
  • hidden_act (str, opcional, padrão silu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • max_position_embeddings (int, opcional, padrão 32768) — O comprimento máximo de sequência com o qual este modelo pode ser utilizado.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • rms_norm_eps (float, opcional, padrão 1e-06) — O epsilon usado pelas camadas de normalização rms.
  • use_cache (bool, opcional, padrão True) — Se o modelo deve ou não retornar as últimas chaves/valores de atenção (não usado por todos os modelos). Relevante apenas se config.is_decoder=True ou quando o modelo for um modelo generativo somente decodificador.
  • pad_token_id (int, opcional) — ID do token usado para preenchimento no vocabulário.
  • bos_token_id (int, opcional, padrão 0) — ID do token usado para o início do fluxo no vocabulário.
  • eos_token_id (Union[int, list[int]], opcional, padrão 1) — ID do token usado para o fim do fluxo no vocabulário.
  • pretraining_tp (int, opcional, padrão 1) — Recurso experimental. Rank de paralelismo de tensor usado durante o pré-treinamento. Consulte este documento para entender mais sobre isso. Esse valor é necessário para garantir a reprodutibilidade exata dos resultados do pré-treinamento. Consulte esta issue.
  • tie_word_embeddings (bool, opcional, padrão False) — Se deve vincular as embeddings de pesos de acordo com o mapeamento tied_weights_keys do modelo.
  • rope_parameters (Union[~modeling_rope_utils.RopeParameters, dict], opcional) — Dicionário contendo os parâmetros de configuração para os embeddings RoPE. O dicionário deve conter um valor para rope_theta e, opcionalmente, parâmetros usados para escalonamento, caso você queira usar RoPE com max_position_embeddings maiores.
  • attention_bias (bool, opcional, padrão False) — Indica se deve ser usado um viés nas camadas de projeção de query, key, value e output durante a autoatenção.
  • attention_dropout (float, opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • mlp_bias (bool, opcional, padrão False) — Se deve usar um viés nas camadas up_proj, down_proj e gate_proj das camadas MLP.
  • head_dim (int, opcional) — A dimensão da cabeça de atenção. Se for None, o valor padrão será hidden_size // num_attention_heads
  • n_group (int, opcional) — Número de grupos para roteamento de especialistas top-k agrupados.
  • n_routed_experts (int, opcional, padrão 64) — Número de especialistas roteados.
  • output_router_logits (bool, opcional, padrão False) — Indica se os logits do roteador devem ser retornados pelo modelo. Ativar essa opção também permitirá que o modelo saída a perda auxiliar, incluindo a perda de balanceamento de carga e a perda z do roteador.
  • n_shared_experts (int, opcional, padrão 2) — Número de especialistas compartilhados.
  • routed_scaling_factor (float, opcional, padrão 1.0) — Fator de escala dos especialistas roteados.
  • topk_group (int, opcional, padrão 1) — Número de grupos selecionados para cada token (para cada token, garantindo que os especialistas selecionados estejam apenas dentro de topk_group grupos).
  • topk_method (str, opcional, padrão "greedy") — Método para selecionar os top-k especialistas em camadas MoE.
  • num_experts_per_tok (int, opcional, padrão 6) — Número de especialistas para os quais cada token deve ser roteado. Este é o valor top-k para o roteamento por escolha de token.
  • moe_intermediate_size (int, opcional, padrão 896) — Tamanho intermediário dos MLPs dos especialistas roteados.
  • mlp_layer_types (list[str], opcional) — Tipo de MLP ("dense" ou "sparse") para cada camada do decodificador, por exemplo, ["dense", "sparse", "sparse", ...].
  • layer_types (list[str], opcional) — Tipo de atenção para cada camada do decoder. O padrão é "reference_sliding_attention" em todas as camadas.
  • sliding_window (int, opcional, padrão 128) — Tamanho da janela deslizante para a atenção de janela deslizante de referência. Se definido, cada token presta atenção aos últimos sliding_window e a todos os tokens de imagem e de prompt.

Esta é a classe de configuração para armazenar a configuração de um UnlimitedOcrModel. Ela é usada para instanciar um modelo Unlimited Ocr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do baidu/Unlimited-OCR

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import UnlimitedOcrTextConfig, UnlimitedOcrTextModel

>>> configuration = UnlimitedOcrTextConfig()
>>> model = UnlimitedOcrTextModel(configuration)
>>> configuration = model.config

UnlimitedOcrVisionConfig

classe transformers.UnlimitedOcrVisionConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonesam_config: dict | transformers.configuration_utils.PreTrainedConfig | None = Noneencoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None )

Parâmetros

  • sam_config (dict ou UnlimitedOcrSamVisionConfig, opcional) — Configuração para o codificador de visão do SAM. O padrão é UnlimitedOcrSamVisionConfig().
  • encoder_config (dict ou UnlimitedOcrVisionEncoderConfig, opcional) — Configuração para o codificador de visão. O padrão é UnlimitedOcrVisionEncoderConfig().

Esta é a classe de configuração para armazenar a configuração de um UnlimitedOcrModel. Ela é usada para instanciar um modelo Unlimited Ocr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do baidu/Unlimited-OCR

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import UnlimitedOcrVisionConfig, UnlimitedOcrVisionModel

>>> configuration = UnlimitedOcrVisionConfig()
>>> model = UnlimitedOcrVisionModel(configuration)
>>> configuration = model.config

UnlimitedOcrVisionEncoderConfig

classe transformers.UnlimitedOcrVisionEncoderConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 1024intermediate_size: int = 4096num_hidden_layers: int = 24num_attention_heads: int = 16num_channels: int = 3image_size: int | list[int] | tuple[int, int] | None = 224patch_size: int | list[int] | tuple[int, int] | None = 14hidden_act: str = 'quick_gelu'layer_norm_eps: float = 1e-05attention_dropout: int | float | None = 0.0initializer_range: float = 0.02initializer_factor: float = 1.0 )

Parâmetros

  • hidden_size (int, opcional, padrão 1024) — Dimensão das representações ocultas.
  • intermediate_size (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • num_hidden_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_channels (int, opcional, padrão 3) — O número de canais de entrada.
  • image_size (Union[int, list[int], tuple[int, int]], opcional, padrão 224) — O tamanho (resolução) de cada imagem.
  • patch_size (Union[int, list[int], tuple[int, int]], opcional, padrão 14) — O tamanho (resolução) de cada patch.
  • hidden_act (str, opcional, padrão quick_gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, opcional, padrão 1e-05) — O epsilon usado pelas camadas de normalização de camada.
  • attention_dropout (Union[int, float], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • initializer_range (float, opcional, padrão 0.02) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • initializer_factor (float, opcional, padrão 1.0) — Fator para inicializar todas as matrizes de pesos (deve ser mantido em 1, usado internamente para testes de inicialização).

Esta é a classe de configuração para armazenar a configuração de um UnlimitedOcrModel. Ela é usada para instanciar um modelo Unlimited Ocr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do baidu/Unlimited-OCR

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

Exemplo:

>>> from transformers import UnlimitedOcrVisionEncoderConfig, UnlimitedOcrVisionEncoder

>>> configuration = UnlimitedOcrVisionEncoderConfig()
>>> model = UnlimitedOcrVisionEncoder(configuration)
>>> configuration = model.config

UnlimitedOcrSamVisionConfig

classe transformers.UnlimitedOcrSamVisionConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonehidden_size: int = 768output_channels: int = 256num_hidden_layers: int = 12num_attention_heads: int = 12num_channels: int = 3image_size: int | list[int] | tuple[int, int] = 1024patch_size: int | list[int] | tuple[int, int] = 16hidden_act: str = 'gelu'layer_norm_eps: float = 1e-06attention_dropout: float | int = 0.0initializer_range: float = 1e-10qkv_bias: bool = Trueuse_abs_pos: bool = Trueuse_rel_pos: bool = Truewindow_size: int = 14global_attn_indexes: list[int] | tuple[int, ...] = (2, 5, 8, 11)mlp_dim: int = 3072downsample_channels: list[int] | tuple[int, ...] = (512, 1024) )

Parâmetros

  • hidden_size (int, opcional, padrão 768) — Dimensão das representações ocultas.
  • output_channels (int, opcional, padrão 256) — Dimensão dos canais de saída no Patch Encoder.
  • num_hidden_layers (int, opcional, padrão 12) — Número de camadas ocultas no decodificador do Transformer.
  • num_attention_heads (int, opcional, padrão 12) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • num_channels (int, opcional, padrão 3) — O número de canais de entrada.
  • image_size (Union[int, list[int], tuple[int, int]], opcional, padrão 1024) — O tamanho (resolução) de cada imagem.
  • patch_size (Union[int, list[int], tuple[int, int]], opcional, padrão 16) — O tamanho (resolução) de cada patch.
  • hidden_act (str, opcional, padrão gelu) — A função de ativação não linear (função ou string) no decodificador. Por exemplo, "gelu", "relu", "silu", etc.
  • layer_norm_eps (float, opcional, padrão 1e-06) — O epsilon usado pelas camadas de normalização de camada.
  • attention_dropout (Union[float, int], opcional, padrão 0.0) — A taxa de dropout para as probabilidades de atenção.
  • initializer_range (float, opcional, padrão 1e-10) — O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos.
  • qkv_bias (bool, opcional, padrão True) — Se deve adicionar um viés às queries, keys e values.
  • use_abs_pos (bool, opcional, padrão True) — Se deve usar incorporação de posição absoluta.
  • use_rel_pos (bool, opcional, padrão True) — Se deve usar incorporação de posição relativa.
  • window_size (int, opcional, padrão 14) — Tamanho da janela para posição relativa.
  • global_attn_indexes (list[int], opcional, padrão [2, 5, 8, 11]) — Os índices das camadas de atenção global.
  • mlp_dim (int, opcional, padrão 3072) — A dimensionalidade da camada MLP no codificador Transformer.
  • downsample_channels (list[int], opcional, padrão (512, 1024)) — As dimensões dos canais para as camadas de pescoço de downsampling multiescala.

Esta é a classe de configuração para armazenar a configuração de um UnlimitedOcrModel. Ela é usada para instanciar um modelo Unlimited Ocr de acordo com os argumentos especificados, definindo a arquitetura do modelo. Instanciar uma configuração com os padrões resultará em uma configuração semelhante à do baidu/Unlimited-OCR

Os objetos de configuração herdam de PreTrainedConfig e podem ser usados para controlar as saídas do modelo. Consulte a documentação de PreTrainedConfig para mais informações.

UnlimitedOcrImageProcessor

classe transformers.UnlimitedOcrImageProcessor

< >

( **kwargs: *<class 'transformers.models.unlimited_ocr.image_processing_unlimited_ocr.UnlimitedOcrImageProcessorKwargs'> )

Parâmetros

  • do_convert_rgb (bool, kwargs, opcional, padrão True) — Se a imagem deve ser convertida para RGB.
  • do_resize (bool, kwargs, opcional, padrão True) — Se deve redimensionar a imagem.
  • size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs, padrão {'height' -- 1024, 'width': 1024}): Descreve as dimensões máximas de entrada para o modelo.
  • default_to_square (bool, kwargs, opcional, padrão True) — Se deve usar uma imagem quadrada por padrão ao redimensionar, caso o tamanho seja um inteiro.
  • crop_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — Tamanho da imagem de saída após a aplicação de center_crop.
  • resample (Annotated[Union[int, PILImageResampling, NoneType], None], kwargs, padrão 3) — Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração PILImageResampling. Tem efeito apenas se do_resize estiver definido como True.
  • do_rescale (bool, kwargs, opcional, padrão True) — Se deve reescalar a imagem.
  • rescale_factor (float, kwargs, opcional, padrão 0.00392156862745098) — Fator de reescala para reescalar a imagem, caso do_rescale esteja definido como True.
  • do_normalize (bool, kwargs, opcional, padrão True) — Se a imagem deve ser normalizada.
  • image_mean (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Média da imagem a ser usada para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • image_std (Union[float, list[float], tuple[float, ...]], kwargs, opcional, padrão [0.5, 0.5, 0.5]) — Desvio padrão da imagem a ser usado para normalização. Tem efeito apenas se do_normalize estiver definido como True.
  • do_pad (bool, kwargs, opcional) — Indica se a imagem deve ser preenchida (padding). O preenchimento é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de preenchimento depende do modelo.
  • pad_size (Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None], kwargs) — O tamanho em {"height": int, "width" int} para o preenchimento das imagens. Deve ser maior que qualquer tamanho de imagem fornecido para o pré-processamento. Se pad_size não for fornecido, as imagens serão preenchidas até a maior altura e largura do lote. Aplicado apenas quando do_pad=True.
  • do_center_crop (bool, kwargs, opcional) — Se deve recortar a imagem centralmente.
  • data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — Apenas ChannelDimension.FIRST é suportado. Adicionado para compatibilidade com processadores lentos.
  • input_data_format (Union[str, ~image_utils.ChannelDimension], kwargs, opcional) — O formato da dimensão de canal para a imagem de entrada. Se não definido, o formato da dimensão de canal é inferido a partir da imagem de entrada. Pode ser um dos seguintes:
    • "channels_first" ou ChannelDimension.FIRST: imagem no formato (num_channels, height, width).
    • "channels_last" ou ChannelDimension.LAST: imagem no formato (altura, largura, num_canais).
    • "none" ou ChannelDimension.NONE: imagem no formato (altura, largura).
  • device (Annotated[Union[str, torch.device, NoneType], None], kwargs) — O dispositivo em que os vídeos serão processados. Se não for definido, o dispositivo é inferido a partir dos vídeos de entrada.
  • return_tensors (Annotated[str | ~utils.generic.TensorType | None, None], kwargs) — Retorna tensores empilhados se definido como 'pt'; caso contrário, retorna uma lista de tensores.
  • disable_grouping (bool, kwargs, opcional) — Se deve desabilitar o agrupamento de imagens por tamanho para processá-las individualmente e não em lotes. Se for None, será definido como True se as imagens estiverem na CPU, e False caso contrário. Essa escolha é baseada em observações empíricas, conforme detalhado aqui: https://github.com/huggingface/transformers/pull/38157
  • image_seq_length (int, kwargs, opcional) — O número de tokens de imagem a serem usados para cada imagem na entrada. Adicionado para compatibilidade reversa, mas isso deve ser definido como um atributo do processador em modelos futuros.
  • crop_to_patches (bool, kwargs, opcional, padrão True) — Se deve recortar a imagem em patches. Pode ser sobrescrito pelo parâmetro crop_to_patches no método preprocess.
  • min_patches (int, kwargs, opcional, padrão 2) — O número mínimo de patches a serem extraídos da imagem. Tem efeito apenas se crop_to_patches estiver definido como True. Pode ser sobrescrito pelo parâmetro min_patches no método preprocess.
  • max_patches (int, kwargs, opcional, padrão 32) — O número máximo de patches a serem extraídos da imagem. Tem efeito apenas se crop_to_patches estiver definido como True. Pode ser sobrescrito pelo parâmetro max_patches no método preprocess.
  • tile_size (int, kwargs, opcional, padrão 640) — O tamanho de cada tile local. Deve corresponder ao tamanho do embedding de consulta do modelo.
  • background_color (list[int], kwargs, opcional, padrão [127, 127, 127]) — A cor de fundo para o padding.
  • maximum_pad_value (int, kwargs, opcional, padrão 640) — Se crop_to_patches for False e max(size.height, size.width) for menor ou igual a esse valor, a imagem é redimensionada diretamente para um quadrado de max(size.height, size.width) sem preservar a proporção. Caso contrário, a imagem é redimensionada preservando a proporção e, em seguida, preenchida com background_color para formar um quadrado.

Constrói um processador de imagem UnlimitedOcrImageProcessor.

crop_image_to_patches

< >

( images: torch.Tensormin_patches: intmax_patches: inttile_size: intresample: PIL.Image.Resampling | None = None ) → tuple[torch.Tensor, int]

Parâmetros

  • images (torch.Tensor) — As imagens a serem recortadas, com formato (batch, channels, height, width).
  • min_patches (int) — Número mínimo de patches.
  • max_patches (int) — Número máximo de patches.
  • tile_size (int) — O tamanho de cada tile.
  • resample (PILImageResampling, opcional) — Filtro de reamostragem para redimensionamento.

Retorna

tuple[torch.Tensor, int]

Patches empilhados (batch, num_patches, channels, tile_size, tile_size) e número de patches por imagem.

Corte imagens em lote em patches com base no mosaico ótimo.

get_number_of_image_patches

< >

( height: intwidth: intimages_kwargs: dict | None = None )

Retorna o número de patches de imagem para um determinado tamanho de imagem (1 patch global + patches locais).

pad_to_square

< >

( images: torch.Tensorbackground_color: int | tuple[int, int, int] = 0 ) → torch.Tensor

Parâmetros

  • images (torch.Tensor) — As imagens a serem preenchidas. Formato: (batch_size, num_channels, height, width) ou (num_channels, height, width).
  • background_color (int ou tuple[int, int, int], opcional, padrão 0) — A cor a ser usada para o preenchimento. Pode ser um inteiro para canal único ou uma tupla de inteiros representando imagens multicanal. Se passado como inteiro em modo multicanal, o valor padrão será 0 nos canais subsequentes.

Retorna

torch.Tensor

As imagens com preenchimento.

Preenche uma imagem até formar um quadrado com base na aresta mais longa.

UnlimitedOcrProcessor

classe transformers.UnlimitedOcrProcessor

< >

( image_processor = Nonetokenizer = Nonechat_template = Nonepatch_size = 16downsample_ratio = 4**kwargs )

Parâmetros

  • image_processor (UnlimitedOcrImageProcessor) — O processador de imagem é uma entrada obrigatória.
  • tokenizer (tokenizer_class) — O tokenizer é uma entrada obrigatória.
  • chat_template (str) — Um modelo Jinja para converter listas de mensagens em um chat em uma string tokenizável.
  • patch_size (int, opcional, padrão 16) — O tamanho do patch usado pelo codificador de visão (tamanho do embedding de patch do ViT do SAM).
  • downsample_ratio (int, opcional, padrão 4) — A taxa de redução de resolução aplicada após o codificador de visão.

Constrói um UnlimitedOcrProcessor que encapsula um processador de imagem e um tokenizer em um único processador.

UnlimitedOcrProcessor oferece todas as funcionalidades de UnlimitedOcrImageProcessor e tokenizer_class. Consulte ~UnlimitedOcrImageProcessor e ~tokenizer_class para mais informações.

batch_decode

< >

( *argsreturn_detections: bool = False**kwargs ) → list[str] or tuple[list[str], list[list[dict]]]

Parâmetros

  • return_detections (bool, opcional, padrão False) — Indica se as detecções de layout analisadas a partir do texto decodificado devem ser retornadas também.

Retorna

list[str] ou tuple[list[str], list[list[dict]]]

O texto decodificado. Se return_detections for True, uma tupla contendo o texto decodificado e as detecções de cada sequência, onde cada detecção é um dicionário com as chaves region_type, box e text. As caixas estão no formato [x1, y1, x2, y2] com coordenadas normalizadas para [0, 999].

Este método encaminha todos os seus argumentos para o batch_decode() do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

decode

< >

( *argsreturn_detections: bool = False**kwargs ) → str or tuple[str, list[dict]]

Parâmetros

  • return_detections (bool, opcional, padrão False) — Indica se as detecções de layout analisadas a partir do texto decodificado devem ser retornadas também.

Retorna

str ou tuple[str, list[dict]]

O texto decodificado. Se return_detections for True, uma tupla contendo o texto decodificado e uma lista de detecções, em que cada detecção é um dicionário com as chaves region_type, box e text. As caixas estão no formato [x1, y1, x2, y2], com coordenadas normalizadas para [0, 999].

Este método encaminha todos os seus argumentos para o decode() do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações.

UnlimitedOcrPreTrainedModel

classe transformers.UnlimitedOcrPreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Parâmetros

  • config (PreTrainedConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

UnlimitedOcrTextPreTrainedModel

classe transformers.UnlimitedOcrTextPreTrainedModel

< >

( config: PreTrainedConfig*inputs**kwargs )

Parâmetros

  • config (PreTrainedConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

UnlimitedOcrTextModel

classe transformers.UnlimitedOcrTextModel

< >

( config: UnlimitedOcrTextConfig )

Parâmetros

  • config (UnlimitedOcrTextConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo Unlimited Ocr Text básico, que gera os hidden-states brutos sem nenhum head específico no topo.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → MoeModelOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).

Retorna

MoeModelOutputWithPast ou tuple(torch.Tensor)

Um MoeModelOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (UnlimitedOcrConfig) e das entradas.

O método forward do UnlimitedOcrTextModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e, opcionalmente, se config.is_encoder_decoder=True, nos blocos de atenção cruzada) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • router_logits (tuple(torch.Tensor), opcional, retornado quando output_router_probs=True e config.add_router_probs=True são passados ou quando config.output_router_probs=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, sequence_length, num_experts).

    Logits brutos do roteador (pós-softmax) calculados pelos roteadores MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts.

UnlimitedOcrVisionModel

classe transformers.UnlimitedOcrVisionModel

< >

( config: UnlimitedOcrVisionConfig )

Parâmetros

  • config (UnlimitedOcrVisionConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

Codificação de imagens pelo modelo de visão primeiro com SAM, seguida por um modelo adicional (CLIP).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( pixel_values: Tensor**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutput or tuple(torch.Tensor)

Parâmetros

Retorna

BaseModelOutput ou tuple(torch.Tensor)

Um BaseModelOutput ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (UnlimitedOcrConfig) e das entradas.

O método forward do UnlimitedOcrVisionModel substitui o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Exemplo:

>>> import torch
>>> from transformers import AutoConfig, AutoImageProcessor, AutoModel
>>> from transformers.image_utils import load_image

>>> model_id = "baidu/Unlimited-OCR"
>>> config = AutoConfig.from_pretrained(model_id)
>>> model = AutoModel.from_pretrained(model_id, config=config.vision_config, device_map="auto")
>>> image_processor = AutoImageProcessor.from_pretrained(model_id)

>>> image = load_image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg")
>>> inputs = image_processor(images=image, return_tensors="pt").to(model.device, model.dtype)

>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> # Patch tokens without class tokens (batch_size, height * width, vision_hidden_size + sam_hidden_size)
>>> patch_tokens = outputs.last_hidden_state

UnlimitedOcrModel

classe transformers.UnlimitedOcrModel

< >

( config: UnlimitedOcrConfig )

Parâmetros

  • config (UnlimitedOcrConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O modelo UnlimitedOcr, que consiste em um backbone de visão e um modelo de linguagem.

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_local: typing.Optional[torch.Tensor] = Nonenum_local_patches: list[int] | None = Nonepatches_grid: list[list[int]] | None = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonemm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → UnlimitedOcrModelOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando UnlimitedOcrImageProcessor. Consulte UnlimitedOcrImageProcessor.call() para mais detalhes (UnlimitedOcrProcessor usa UnlimitedOcrImageProcessor para processar imagens).
  • pixel_values_local (torch.Tensor, opcional) — Valores de pixels dos patches locais com forma (total_patches, 3, H, W).
  • num_local_patches (list[int], opcional) — Número de patches locais por imagem no lote.
  • patches_grid (list[list[int]], opcional) — A grade de patches (num_columns, num_rows) por imagem.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional: last_hidden_states, opcional: hidden_states, opcional: attentions) pooler_output de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

Retorna

UnlimitedOcrModelOutputWithPast ou tuple(torch.Tensor)

Uma UnlimitedOcrModelOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (UnlimitedOcrConfig) e das entradas.

O método forward do UnlimitedOcrModel sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • last_hidden_state (torch.Tensor de forma (batch_size, sequence_length, hidden_size)) — Sequência de estados ocultos na saída da última camada do modelo.

    Se past_key_values for usado, apenas o último hidden-state das sequências, com forma (batch_size, 1, hidden_size), é retornado.

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple(torch.Tensor), opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • image_hidden_states (torch.Tensor, opcional) — Um torch.Tensor de tamanho (batch_size, num_images, sequence_length, hidden_size). image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.

  • router_logits (tuple[torch.Tensor], opcional, retornado quando output_router_logits=True é passado ou quando config.add_router_probs=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, sequence_length, num_experts).

    Logits do roteador do modelo, úteis para calcular a perda auxiliar em modelos Mixture of Experts.

UnlimitedOcrForConditionalGeneration

classe transformers.UnlimitedOcrForConditionalGeneration

< >

( config: UnlimitedOcrConfig )

Parâmetros

  • config (UnlimitedOcrConfig) — Classe de configuração do modelo com todos os parâmetros do modelo. A inicialização com um arquivo de configuração não carrega os pesos associados ao modelo, apenas a configuração. Consulte o método from_pretrained() para carregar os pesos do modelo.

O Modelo Unlimited Ocr para geração de tokens condicionada a outras modalidades (por exemplo, geração de texto a partir de imagem e texto).

Este modelo herda de PreTrainedModel. Consulte a documentação da classe pai para os métodos genéricos que a biblioteca implementa para todos os seus modelos (como download ou salvamento, redimensionamento dos embeddings de entrada, poda de cabeças, etc.)

Este modelo também é uma subclasse de torch.nn.Module do PyTorch. Use-o como um Módulo PyTorch regular e consulte a documentação do PyTorch para todos os assuntos relacionados ao uso geral e ao comportamento.

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonepixel_values_local: typing.Optional[torch.Tensor] = Nonenum_local_patches: list[int] | None = Nonepatches_grid: list[list[int]] | None = Noneattention_mask: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.LongTensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.LongTensor] = Noneuse_cache: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → UnlimitedOcrCausalLMOutputWithPast or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices dos tokens da sequência de entrada no vocabulário. O padding será ignorado por padrão.

    Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes.

    O que são IDs de entrada?

  • pixel_values (torch.Tensor de forma (batch_size, num_channels, image_size, image_size), opcional) — Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando UnlimitedOcrImageProcessor. Consulte UnlimitedOcrImageProcessor.call() para mais detalhes (UnlimitedOcrProcessor usa UnlimitedOcrImageProcessor para processar imagens).
  • pixel_values_local (torch.Tensor, opcional) — Valores de pixels dos patches locais com forma (total_patches, 3, H, W).
  • num_local_patches (list[int], opcional) — Número de patches locais por imagem no lote.
  • patches_grid (list[list[int]], opcional) — A grade de patches (num_columns, num_rows) por imagem.
  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara para evitar a execução de atenção nos índices de tokens de preenchimento. Valores de máscara selecionados em [0, 1]:
    • 1 para tokens que não estão mascarados,
    • 0 para tokens que estão mascarados.

    O que são máscaras de atenção?

  • position_ids (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Índices das posições dos tokens de cada sequência de entrada nos embeddings de posição. Selecionados no intervalo [0, config.n_positions - 1].

    O que são IDs de posição?

  • past_key_values (~cache_utils.Cache, opcional) — Estados ocultos pré-computados (chaves e valores nos blocos de autoatenção e nos blocos de atenção cruzada) que podem ser usados para acelerar a decodificação sequencial. Isso geralmente consiste no past_key_values retornado pelo modelo em uma etapa anterior da decodificação, quando use_cache=True ou config.use_cache=True.

    Apenas uma instância de Cache é permitida como entrada, consulte nosso guia de cache de kv. Se nenhum past_key_values for passado, DynamicCache será inicializado por padrão.

    O modelo sairá no mesmo formato de cache que é fornecido como entrada.

    Se past_key_values forem usados, espera-se que o usuário insira apenas os input_ids não processados (aqueles que não têm seus estados de chave e valor passados fornecidos a este modelo) com a forma (batch_size, unprocessed_length), em vez de todos os input_ids com a forma (batch_size, sequence_length).

  • inputs_embeds (torch.Tensor de forma (batch_size, sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar input_ids, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de input_ids nos vetores associados do que a matriz de busca de incorporação interna do modelo.
  • labels (torch.LongTensor de forma (batch_size, sequence_length), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem mascarada. Os índices devem estar em [0, ..., config.vocab_size] ou ser -100 (veja a docstring de input_ids). Tokens com índices definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em [0, ..., config.vocab_size].
  • use_cache (bool, opcional) — Se definido como True, os estados de chave-valor past_key_values são retornados e podem ser usados para acelerar a decodificação (veja past_key_values).
  • logits_to_keep (Union[int, torch.Tensor], opcional, padrão 0) — Se for um int, calcula os logits para os últimos logits_to_keep tokens. Se for 0, calcula os logits para todos os input_ids (caso especial). Apenas os logits do último token são necessários para a geração, e calculá-los apenas para esse token pode economizar memória, o que se torna bastante significativo para sequências longas ou tamanho de vocabulário grande. Se for um torch.Tensor, deve ser 1D, correspondendo aos índices a serem mantidos na dimensão de comprimento da sequência. Isso é útil ao usar o formato de tensor empacotado (uma única dimensão para lote e comprimento da sequência).
  • mm_encoder_outputs (dict[str, ~modeling_outputs.BaseModelOutputWithPooling], opcional) — Dicionário em que as chaves são as modalidades suportadas e os valores são as saídas codificadas para essa modalidade. Cada saída codificada é uma tupla que consiste em (pooler_output, opcional: last_hidden_states, opcional: hidden_states, opcional: attentions) pooler_output de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de recursos multimodais do codificador mesclados em incorporações de texto.

Retorna

UnlimitedOcrCausalLMOutputWithPast ou tuple(torch.Tensor)

Um UnlimitedOcrCausalLMOutputWithPast ou uma tupla de torch.Tensor (se return_dict=False for passado ou quando config.return_dict=False) contendo vários elementos, dependendo da configuração (UnlimitedOcrConfig) e das entradas.

O método forward de UnlimitedOcrForConditionalGeneration sobrescreve o método especial __call__.

Embora a receita para a passagem direta precise ser definida dentro desta função, deve-se chamar a instância de Module em seguida, em vez desta, pois a primeira cuida da execução das etapas de pré e pós-processamento, enquanto a segunda as ignora silenciosamente.

  • loss (torch.Tensor de forma (1,), opcional, retornado quando labels é fornecido) — Perda de modelagem de linguagem (para previsão do próximo token).

  • logits (torch.Tensor de forma (batch_size, sequence_length, config.vocab_size)) — Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).

  • past_key_values (Cache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — É uma instância de Cache. Para mais detalhes, consulte nosso guia de cache kv.

    Contém estados ocultos pré-computados (chaves e valores nos blocos de autoatenção) que podem ser usados (veja a entrada past_key_values) para acelerar a decodificação sequencial.

  • hidden_states (tuple[torch.Tensor], opcional, retornado quando output_hidden_states=True é passado ou quando config.output_hidden_states=True) — Tupla de torch.Tensor (um para a saída dos embeddings, se o modelo tiver uma camada de embedding, + um para a saída de cada camada) de forma (batch_size, sequence_length, hidden_size).

    Estados ocultos do modelo na saída de cada camada, além das saídas opcionais do embedding inicial.

  • attentions (tuple[torch.Tensor], opcional, retornado quando output_attentions=True é passado ou quando config.output_attentions=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, num_heads, sequence_length, sequence_length).

    Pesos de atenção após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • image_hidden_states (torch.Tensor, opcional) — Um torch.Tensor de tamanho (batch_size * num_patches, num_images, sequence_length, hidden_size)`. image_hidden_states do modelo produzido pelo codificador de visão e após projetar o último estado oculto.

  • router_logits (tuple[torch.Tensor], opcional, retornado quando output_router_logits=True é passado ou quando config.add_router_probs=True) — Tupla de torch.Tensor (um para cada camada) com forma (batch_size, sequence_length, num_experts).

    Logits do roteador do modelo, úteis para calcular a perda auxiliar em modelos Mixture of Experts.

Exemplo de OCR de página única:

>>> 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)
>>> 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...

Exemplo de OCR de várias páginas:

>>> from transformers import AutoProcessor, AutoModelForImageTextToText

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

>>> page1 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_suggestion_form.jpg"
>>> page2 = "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/model_doc/ocr_receipt.jpeg"

>>> messages = [
...     {
...         "role": "user",
...         "content": [{"type": "image", "url": page} for page in [page1, page2]]
...         + [{"type": "text", "text": "Multi page parsing."}],
...     }
... ]
>>> inputs = processor.apply_chat_template(
...     messages,
...     add_generation_prompt=True,
...     tokenize=True,
...     return_dict=True,
...     return_tensors="pt",
...     processor_kwargs={"crop_to_patches": False},
... ).to(model.device, model.dtype)

>>> output = model.generate(
...     **inputs,
...     no_repeat_ngram_window_size=1024,
... )
>>> processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True)
>>> # <PAGE>image [382, 87, 489, 174]\ntitle [333, 201, 556, 230]R&D QUALITY IMPROVEMENT\nSUGGESTION/SCLUTION FORM...
Update on GitHub

←UDOP VideoLlama3→