# UnlimitedOcr ## Visão geral O modelo UnlimitedOcr foi proposto em [Unlimited OCR Works](https://huggingface.co/papers/2606.23050) 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 um desempenho aprimorado de OCR. No entanto, a desvantagem é igualmente evidente: à medida que o comprimento da sequência de saída aumenta, o cache KV acumulado eleva 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 cache KV 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 cache KV 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* 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()](/docs/transformers/main/pt/main_classes/processors#transformers.ProcessorMixin.apply_chat_template). A torre de visão segue a abordagem em duas etapas do [DeepSeek-OCR-2](./deepseek_ocr2): 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](https://huggingface.co/guarin). O código original pode ser encontrado [aqui](https://github.com/baidu/Unlimited-OCR). > [!TIP] > A implementação original executa o modelo com [torch.autocast](https://pytorch.org/docs/stable/amp.html#torch.autocast) em bfloat16. Envolve as chamadas de forward e generate em um contexto de autocast para reproduzir suas saídas. > > ```python > with torch.autocast(device_type=model.device.type, dtype=torch.bfloat16): > output = model.generate(**inputs) > ``` ```python 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. ```python 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": "..."}`. ```python 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() ``` Documentos de várias páginas podem ser analisados conjuntamente em uma única passagem de frente, passando todas as imagens das páginas juntas. Adicione um bloco de imagem por página à mensagem para que o modelo processe todas as páginas como um documento contínuo. ```python 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, # default: 128, larger window size recommended for long documents ) processor.decode(output[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True) # image [382, 87, 489, 174]\ntitle [333, 201, 556, 230]R&D QUALITY IMPROVEMENT\nSUGGESTION/SCLUTION FORM... # All bounding boxes are in (x1, y1, x2, y2) format with coordinates normalized to [0, 999] ``` ## UnlimitedOcrConfig[[transformers.UnlimitedOcrConfig]] #### transformers.UnlimitedOcrConfig[[transformers.UnlimitedOcrConfig]] ```python transformers.UnlimitedOcrConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vision_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, text_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, image_token_id: int = 128815, tie_word_embeddings: bool = False) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/configuration_unlimited_ocr.py#L262) **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 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](https://huggingface.co/baidu/Unlimited-OCR) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import UnlimitedOcrConfig, UnlimitedOcrModel >>> configuration = UnlimitedOcrConfig() >>> model = UnlimitedOcrModel(configuration) >>> configuration = model.config ``` ## UnlimitedOcrTextConfig[[transformers.UnlimitedOcrTextConfig]] #### transformers.UnlimitedOcrTextConfig[[transformers.UnlimitedOcrTextConfig]] ```python transformers.UnlimitedOcrTextConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, vocab_size: int = 129280, hidden_size: int = 1280, intermediate_size: int = 6848, num_hidden_layers: int = 12, num_attention_heads: int = 10, num_key_value_heads: int | None = 10, hidden_act: str = 'silu', max_position_embeddings: int = 32768, initializer_range: float = 0.02, rms_norm_eps: float = 1e-06, use_cache: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, pretraining_tp: int | None = 1, tie_word_embeddings: bool = False, rope_parameters: transformers.modeling_rope_utils.RopeParameters | dict | None = None, attention_bias: bool = False, attention_dropout: float | None = 0.0, mlp_bias: bool = False, head_dim: int | None = None, n_group: int | None = 1, n_routed_experts: int = 64, output_router_logits: bool = False, n_shared_experts: int = 2, routed_scaling_factor: float = 1.0, topk_group: int | None = 1, topk_method: str | None = 'greedy', num_experts_per_tok: int | None = 6, moe_intermediate_size: int = 896, mlp_layer_types: list[str] | None = None, layer_types: list[str] | None = None, sliding_window: int | None = 128) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/configuration_unlimited_ocr.py#L141) **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 cabeça de chave e valor do grupo deve ser construída pela média (meanpooling) de todas as cabeças originais dentro desse grupo. Para mais detalhes, consulte [este artigo](https://huggingface.co/papers/2305.13245). 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 usado. 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`) : Indica se o modelo deve retornar as últimas atenções de chave/valor (não utilizado por todos os modelos). Relevante apenas se `config.is_decoder=True` ou quando o modelo for um modelo generativo somente de decodificador. pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) 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`) : Funcionalidade experimental. Rank de paralelismo de tensor usado durante o pré-treinamento. Consulte [este documento](https://huggingface.co/docs/transformers/main/perf_train_gpu_many#tensor-parallelism) para entender mais sobre isso. Esse valor é necessário para garantir a reprodutibilidade exata dos resultados do pré-treinamento. Consulte [esta issue](https://github.com/pytorch/pytorch/issues/76232). 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`) : Se deve usar 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 permite que o modelo outpute 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 ou 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 principais especialistas nas camadas MoE. num_experts_per_tok (`int`, *opcional*, padrão `6`) : Número de especialistas para os quais cada token é roteado. Este é o valor top-k para o roteamento de 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 decodificador. 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](https://huggingface.co/baidu/Unlimited-OCR) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import UnlimitedOcrTextConfig, UnlimitedOcrTextModel >>> configuration = UnlimitedOcrTextConfig() >>> model = UnlimitedOcrTextModel(configuration) >>> configuration = model.config ``` ## UnlimitedOcrVisionConfig[[transformers.UnlimitedOcrVisionConfig]] #### transformers.UnlimitedOcrVisionConfig[[transformers.UnlimitedOcrVisionConfig]] ```python transformers.UnlimitedOcrVisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, sam_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None, encoder_config: dict | transformers.configuration_utils.PreTrainedConfig | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/configuration_unlimited_ocr.py#L112) **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](https://huggingface.co/baidu/Unlimited-OCR) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import UnlimitedOcrVisionConfig, UnlimitedOcrVisionModel >>> configuration = UnlimitedOcrVisionConfig() >>> model = UnlimitedOcrVisionModel(configuration) >>> configuration = model.config ``` ## UnlimitedOcrVisionEncoderConfig[[transformers.UnlimitedOcrVisionEncoderConfig]] #### transformers.UnlimitedOcrVisionEncoderConfig[[transformers.UnlimitedOcrVisionEncoderConfig]] ```python transformers.UnlimitedOcrVisionEncoderConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 1024, intermediate_size: int = 4096, num_hidden_layers: int = 24, num_attention_heads: int = 16, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] | None = 224, patch_size: int | list[int] | tuple[int, int] | None = 14, hidden_act: str = 'quick_gelu', layer_norm_eps: float = 1e-05, attention_dropout: int | float | None = 0.0, initializer_range: float = 0.02, initializer_factor: float = 1.0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/configuration_unlimited_ocr.py#L74) **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`) : Um 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](https://huggingface.co/baidu/Unlimited-OCR) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. Exemplo: ```python >>> from transformers import UnlimitedOcrVisionEncoderConfig, UnlimitedOcrVisionEncoder >>> configuration = UnlimitedOcrVisionEncoderConfig() >>> model = UnlimitedOcrVisionEncoder(configuration) >>> configuration = model.config ``` ## UnlimitedOcrSamVisionConfig[[transformers.UnlimitedOcrSamVisionConfig]] #### transformers.UnlimitedOcrSamVisionConfig[[transformers.UnlimitedOcrSamVisionConfig]] ```python transformers.UnlimitedOcrSamVisionConfig(transformers_version: str | None = None, architectures: list[str] | None = None, output_hidden_states: bool | None = False, return_dict: bool | None = True, dtype: str | torch.dtype | None = None, chunk_size_feed_forward: int = 0, is_encoder_decoder: bool = False, id2label: dict[int, str] | dict[str, str] | None = None, label2id: dict[str, int] | dict[str, str] | None = None, problem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = None, hidden_size: int = 768, output_channels: int = 256, num_hidden_layers: int = 12, num_attention_heads: int = 12, num_channels: int = 3, image_size: int | list[int] | tuple[int, int] = 1024, patch_size: int | list[int] | tuple[int, int] = 16, hidden_act: str = 'gelu', layer_norm_eps: float = 1e-06, attention_dropout: float | int = 0.0, initializer_range: float = 1e-10, qkv_bias: bool = True, use_abs_pos: bool = True, use_rel_pos: bool = True, window_size: int = 14, global_attn_indexes: list[int] | tuple[int, ...] = (2, 5, 8, 11), mlp_dim: int = 3072, downsample_channels: list[int] | tuple[int, ...] = (512, 1024)) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/configuration_unlimited_ocr.py#L29) **Parâmetros:** hidden_size (`int`, *opcional*, padrão `768`) : Dimensão das representações ocultas. output_channels (`int`, *opcional*, padrão 256) : Dimensionalidade 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 do 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](https://huggingface.co/baidu/Unlimited-OCR) Os objetos de configuração herdam de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) e podem ser usados para controlar as saídas do modelo. Leia a documentação de [PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.PreTrainedConfig) para mais informações. ## UnlimitedOcrImageProcessor[[transformers.UnlimitedOcrImageProcessor]] #### transformers.UnlimitedOcrImageProcessor[[transformers.UnlimitedOcrImageProcessor]] ```python transformers.UnlimitedOcrImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/image_processing_unlimited_ocr.py#L141) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*, padrão `True`) : Se deve converter a imagem 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 aplicar `center_crop`. resample (`Annotated[Union[int, PILImageResampling, NoneType], None]`, *kwargs*, padrão `3`) : Filtro de reamostragem 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 redimensionamento para redimensionar 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*) : Se deve aplicar padding à imagem. O padding é feito até o maior tamanho do lote ou até um tamanho quadrado fixo por imagem. A estratégia exata de padding 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 preencher as imagens. Deve ser maior que o tamanho de qualquer imagem fornecida 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 centralizar o recorte da imagem. 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 for 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 (height, width, num_channels). - `"none"` ou `ChannelDimension.NONE`: imagem no formato (height, width). device (`Annotated[Union[str, torch.device, NoneType], None]`, *kwargs*) : O dispositivo no qual 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 a imagem deve ser recortada 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 preenchimento. 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 até formar um quadrado com `background_color`. Constrói um processador de imagem UnlimitedOcrImageProcessor. #### crop_image_to_patches[[transformers.UnlimitedOcrImageProcessor.crop_image_to_patches]] ```python crop_image_to_patches(images: torch.Tensor, min_patches: int, max_patches: int, tile_size: int, resample: PIL.Image.Resampling | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/image_processing_unlimited_ocr.py#L163) **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[[transformers.UnlimitedOcrImageProcessor.get_number_of_image_patches]] ```python get_number_of_image_patches(height: int, width: int, images_kwargs: dict | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/image_processing_unlimited_ocr.py#L309) Retorna o número de patches de imagem para um determinado tamanho de imagem (1 patch global + patches locais). #### pad_to_square[[transformers.UnlimitedOcrImageProcessor.pad_to_square]] ```python pad_to_square(images: torch.Tensor, background_color: int | tuple[int, int, int] = 0) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/image_processing_unlimited_ocr.py#L328) **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 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[[transformers.UnlimitedOcrProcessor]] #### transformers.UnlimitedOcrProcessor[[transformers.UnlimitedOcrProcessor]] ```python transformers.UnlimitedOcrProcessor(image_processor = None, tokenizer = None, chat_template = None, patch_size = 16, downsample_ratio = 4, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/processing_unlimited_ocr.py#L30) **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 patch embedding do SAM ViT). downsample_ratio (`int`, *opcional*, padrão `4`) : A taxa de redução de amostragem 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](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrProcessor) oferece todas as funcionalidades de [UnlimitedOcrImageProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrImageProcessor) e `tokenizer_class`. Consulte [~UnlimitedOcrImageProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrImageProcessor) e `~tokenizer_class` para mais informações. #### batch_decode[[transformers.UnlimitedOcrProcessor.batch_decode]] ```python batch_decode(*args, return_detections: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/processing_unlimited_ocr.py#L85) **Parâmetros:** return_detections (`bool`, *opcional*, padrão `False`) : Se as detecções de layout analisadas a partir do texto decodificado também devem ser retornadas. **Retorna:** `list[str]` ou `tuple[list[str], list[list[dict]]]` O texto decodificado. Se `return_detections` for `True`, uma tupla com 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()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.batch_decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações. #### decode[[transformers.UnlimitedOcrProcessor.decode]] ```python decode(*args, return_detections: bool = False, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/processing_unlimited_ocr.py#L106) **Parâmetros:** return_detections (`bool`, *opcional*, padrão `False`) : Se as detecções de layout analisadas a partir do texto decodificado também devem ser retornadas. **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, 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 [decode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.decode) do PreTrainedTokenizer. Consulte a docstring deste método para obter mais informações. ## UnlimitedOcrPreTrainedModel[[transformers.UnlimitedOcrPreTrainedModel]] #### transformers.UnlimitedOcrPreTrainedModel[[transformers.UnlimitedOcrPreTrainedModel]] ```python transformers.UnlimitedOcrPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L281) **Parâmetros:** config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. ## UnlimitedOcrTextPreTrainedModel[[transformers.UnlimitedOcrTextPreTrainedModel]] #### transformers.UnlimitedOcrTextPreTrainedModel[[transformers.UnlimitedOcrTextPreTrainedModel]] ```python transformers.UnlimitedOcrTextPreTrainedModel(config: PreTrainedConfig, *inputs, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L1269) **Parâmetros:** config ([PreTrainedConfig](/docs/transformers/main/pt/main_classes/configuration#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained) para carregar os pesos do modelo. Este modelo herda de [PreTrainedModel](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. ## UnlimitedOcrTextModel[[transformers.UnlimitedOcrTextModel]] #### transformers.UnlimitedOcrTextModel[[transformers.UnlimitedOcrTextModel]] ```python transformers.UnlimitedOcrTextModel(config: UnlimitedOcrTextConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L1731) **Parâmetros:** config ([UnlimitedOcrTextConfig](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.UnlimitedOcrTextModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L1748) **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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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?](../glossary#attention-mask) 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?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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 nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para 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 de `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](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrConfig)) e das entradas. O método forward do [UnlimitedOcrTextModel](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). 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) com a 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 a 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 nas cabeças 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 a forma `(batch_size, sequence_length, num_experts)`. Logits brutos do roteador (pós-softmax) calculados pelos roteadores de MoE; esses termos são usados para calcular a perda auxiliar em modelos Mixture of Experts. ## UnlimitedOcrVisionModel[[transformers.UnlimitedOcrVisionModel]] #### transformers.UnlimitedOcrVisionModel[[transformers.UnlimitedOcrVisionModel]] ```python transformers.UnlimitedOcrVisionModel(config: UnlimitedOcrVisionConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L927) **Parâmetros:** config ([UnlimitedOcrVisionConfig](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.UnlimitedOcrVisionModel.forward]] ```python forward(pixel_values: Tensor, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L936) **Parâmetros:** pixel_values (`torch.Tensor` de forma `(batch_size, num_channels, image_size, image_size)`) : Os tensores correspondentes às imagens de entrada. Os valores de pixels podem ser obtidos usando [UnlimitedOcrImageProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrImageProcessor). Veja [UnlimitedOcrImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([UnlimitedOcrProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrProcessor) usa [UnlimitedOcrImageProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrImageProcessor) para processar imagens). **Retorna:** [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutput) ou `tuple(torch.Tensor)` Um [BaseModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.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](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrConfig)) e das entradas. O método forward do [UnlimitedOcrVisionModel](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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) com a 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 a 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 nas cabeças de autoatenção. Exemplo: ```python >>> 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[[transformers.UnlimitedOcrModel]] #### transformers.UnlimitedOcrModel[[transformers.UnlimitedOcrModel]] ```python transformers.UnlimitedOcrModel(config: UnlimitedOcrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L1816) **Parâmetros:** config ([UnlimitedOcrConfig](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.UnlimitedOcrModel.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_local: typing.Optional[torch.Tensor] = None, num_local_patches: list[int] | None = None, patches_grid: list[list[int]] | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, use_cache: bool | None = None, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L1933) **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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrImageProcessor). Veja [UnlimitedOcrImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([UnlimitedOcrProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrProcessor) usa [UnlimitedOcrImageProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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?](../glossary#attention-mask) 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?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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 nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para 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 de `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)` Um `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](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrConfig)) e das entradas. O método forward do [UnlimitedOcrModel](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). 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) com a 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 a 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 nas cabeças 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 a forma `(batch_size, sequence_length, num_experts)`. Logits do roteador do modelo, úteis para calcular a perda auxiliar em modelos Mixture of Experts. ## UnlimitedOcrForConditionalGeneration[[transformers.UnlimitedOcrForConditionalGeneration]] #### transformers.UnlimitedOcrForConditionalGeneration[[transformers.UnlimitedOcrForConditionalGeneration]] ```python transformers.UnlimitedOcrForConditionalGeneration(config: UnlimitedOcrConfig) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L1999) **Parâmetros:** config ([UnlimitedOcrConfig](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.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](/docs/transformers/main/pt/main_classes/model#transformers.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](https://pytorch.org/docs/stable/nn.html#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 e comportamento gerais. #### forward[[transformers.UnlimitedOcrForConditionalGeneration.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, pixel_values: typing.Optional[torch.Tensor] = None, pixel_values_local: typing.Optional[torch.Tensor] = None, num_local_patches: list[int] | None = None, patches_grid: list[list[int]] | None = None, attention_mask: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, past_key_values: transformers.cache_utils.Cache | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, use_cache: bool | None = None, logits_to_keep: typing.Union[int, torch.Tensor] = 0, mm_encoder_outputs: dict[str, transformers.modeling_outputs.BaseModelOutputWithPooling] | None = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/unlimited_ocr/modeling_unlimited_ocr.py#L2037) **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 preenchimento (padding) será ignorado por padrão. Os índices podem ser obtidos usando [AutoTokenizer](/docs/transformers/main/pt/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) e [PreTrainedTokenizer.__call__()](/docs/transformers/main/pt/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para mais detalhes. [O que são IDs de entrada?](../glossary#input-ids) 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](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrImageProcessor). Veja [UnlimitedOcrImageProcessor.__call__()](/docs/transformers/main/pt/model_doc/molmo2#transformers.Molmo2ImageProcessor.__call__) para detalhes ([UnlimitedOcrProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrProcessor) usa [UnlimitedOcrImageProcessor](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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?](../glossary#attention-mask) 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?](../glossary#position-ids) past_key_values (`~cache_utils.Cache`, *opcional*) : hidden-states 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 nos `past_key_values` retornados pelo modelo em uma etapa anterior da decodificação, quando `use_cache=True` ou `config.use_cache=True`. Apenas uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache) é permitida como entrada, consulte nosso [guia de kv cache](https://huggingface.co/docs/transformers/en/kv_cache). Se nenhum `past_key_values` for passado, [DynamicCache](/docs/transformers/main/pt/internal/generation_utils#transformers.DynamicCache) será inicializado por padrão. O modelo sairá no mesmo formato de cache que foi fornecido como entrada. Se `past_key_values` forem usados, espera-se que o usuário insira apenas `input_ids` não processados (aqueles que não têm seus estados de chave e valor passados para 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 calcular a 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 de `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](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.UnlimitedOcrConfig)) e das entradas. O método forward de [UnlimitedOcrForConditionalGeneration](/docs/transformers/main/pt/model_doc/unlimited_ocr#transformers.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`) -- Trata-se de uma instância de [Cache](/docs/transformers/main/pt/internal/generation_utils#transformers.Cache). Para mais detalhes, consulte nosso [guia de cache kv](https://huggingface.co/docs/transformers/en/kv_cache). 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 a 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 nas cabeças 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 a 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: ```python >>> 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: ```python >>> 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) >>> # image [382, 87, 489, 174]\ntitle [333, 201, 556, 230]R&D QUALITY IMPROVEMENT\nSUGGESTION/SCLUTION FORM... ```