Hugging Face's logo

Transformers documentation

UDOP

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 HF papers em 2022-12-05 e contribuído para Hugging Face Transformers em 2024-03-04.

UDOP

Visão geral

O modelo UDOP foi proposto em Unifying Vision, Text, and Layout for Universal Document Processing por Zineng Tang, Ziyi Yang, Guoxin Wang, Yuwei Fang, Yang Liu, Chenguang Zhu, Michael Zeng, Cha Zhang, Mohit Bansal. O UDOP adota uma arquitetura Transformer encoder-decoder baseada em T5 para tarefas de IA de documentos, como classificação de imagens de documentos, análise de documentos e resposta a perguntas visuais sobre documentos.

O resumo do artigo é o seguinte:

Propomos o Universal Document Processing (UDOP), um modelo de fundação de Document AI que unifica as modalidades de texto, imagem e layout, juntamente com formatos variados de tarefas, incluindo compreensão e geração de documentos. O UDOP aproveita a correlação espacial entre o conteúdo textual e a imagem do documento para modelar as modalidades de imagem, texto e layout com uma representação uniforme. Com um Vision-Text-Layout Transformer inovador, o UDOP unifica o pré-treinamento e as tarefas downstream de múltiplos domínios em um esquema de geração de sequências baseado em prompts. O UDOP é pré-treinado tanto em grandes corpora de documentos não rotulados, usando objetivos auto-supervisionados inovadores, quanto em dados rotulados diversos. O UDOP também aprende a gerar imagens de documentos a partir das modalidades de texto e layout por meio de reconstrução de imagem mascarada. Até onde temos conhecimento, esta é a primeira vez no campo de Document AI que um único modelo alcança simultaneamente edição neural de documentos de alta qualidade e personalização de conteúdo. Nosso método estabelece o estado da arte em 9 tarefas de Document AI, por exemplo, compreensão de documentos e QA, em diversos domínios de dados, como relatórios financeiros, artigos acadêmicos e sites. O UDOP ocupa a primeira posição no leaderboard do Document Understanding Benchmark (DUE).*

drawing UDOP architecture. Taken from the original paper.

Dicas de uso

  • Além de input_ids, o UdopForConditionalGeneration também espera a entrada bbox, que são as caixas delimitadoras (ou seja, posições 2D) dos tokens de entrada. Essas podem ser obtidas usando um mecanismo de OCR externo, como o Tesseract da Google (há um Python wrapper disponível). Cada caixa delimitadora deve estar no formato (x0, y0, x1, y1), em que (x0, y0) corresponde à posição do canto superior esquerdo na caixa delimitadora e (x1, y1) representa a posição do canto inferior direito. Observe que é necessário primeiro normalizar as caixas delimitadoras para uma escala de 0 a 1000. Para normalizar, você pode usar a seguinte função:
def normalize_bbox(bbox, width, height):
    return [
        int(1000 * (bbox[0] / width)),
        int(1000 * (bbox[1] / height)),
        int(1000 * (bbox[2] / width)),
        int(1000 * (bbox[3] / height)),
    ]

Aqui, width e height correspondem à largura e à altura do documento original em que o token ocorre. Esses valores podem ser obtidos, por exemplo, usando a biblioteca Python Image Library (PIL), da seguinte forma:

from PIL import Image


# Document can be a png, jpg, etc. PDFs must be converted to images.
image = Image.open(name_of_your_document).convert("RGB")

width, height = image.size

É possível usar UdopProcessor para preparar imagens e texto para o modelo, que cuida de tudo isso. Por padrão, essa classe usa o mecanismo Tesseract para extrair uma lista de palavras e caixas (coordenadas) de um documento dado. Sua funcionalidade é equivalente à de LayoutLMv3Processor, portanto, ela suporta a passagem de apply_ocr=False caso você prefira usar seu próprio mecanismo de OCR ou apply_ocr=True caso queira que o mecanismo de OCR padrão seja usado. Consulte o guia de uso do LayoutLMv2 em relação a todos os casos de uso possíveis (a funcionalidade de UdopProcessor é idêntica).

  • Se estiver usando um motor de OCR próprio, uma recomendação é a Read API da Azure, que suporta os chamados segmentos de linha. O uso de embeddings de posição de segmento geralmente resulta em melhor desempenho.
  • No momento da inferência, recomenda-se usar o método generate para gerar texto de forma autoregressiva a partir de uma imagem de documento.
  • O modelo foi pré-treinado em objetivos auto-supervisionados e supervisionados. É possível usar os vários prefixos de tarefa (prompts) utilizados durante o pré-treinamento para testar as capacidades nativas do modelo. Por exemplo, o modelo pode ser acionado com “Question answering. What is the date?”, pois “Question answering.” é o prefixo de tarefa usado durante o pré-treinamento para o DocVQA. Consulte o artigo (tabela 1) para obter todos os prefixos de tarefa.
  • Também é possível fazer o ajuste fino de UdopEncoderModel, que é a parte apenas de codificador do UDOP, que pode ser vista como um codificador Transformer semelhante ao LayoutLMv3. Para tarefas discriminativas, basta adicionar um classificador linear por cima e fazer o ajuste fino em um conjunto de dados rotulado.

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

Recursos

Uma lista de recursos oficiais do Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o UDOP. Se você estiver interessado em enviar um recurso para ser incluído aqui, sinta-se à vontade para abrir um Pull Request e faremos a revisão! O recurso deve, idealmente, demonstrar algo novo, em vez de duplicar um recurso existente.

UdopConfig

classe transformers.UdopConfig

< >

( 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 = 0id2label: 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 = Noneis_encoder_decoder: bool = Truevocab_size: int = 33201d_model: int = 1024d_kv: int = 64d_ff: int = 4096num_layers: int = 24num_decoder_layers: int | None = Nonenum_heads: int = 16relative_attention_num_buckets: int = 32relative_attention_max_distance: int = 128relative_bias_args: list[dict] | None = Nonedropout_rate: float | int = 0.1layer_norm_epsilon: float = 1e-06initializer_factor: float = 1.0feed_forward_proj: str = 'relu'use_cache: bool = Truepad_token_id: int | None = 0eos_token_id: int | list[int] | None = 1max_2d_position_embeddings: int = 1024image_size: int | list[int] | tuple[int, int] = 224patch_size: int | list[int] | tuple[int, int] = 16num_channels: int = 3is_decoder: bool = Falseadd_cross_attention: bool = Falsetie_word_embeddings: bool = True )

Parâmetros

  • is_encoder_decoder (bool, opcional, padrão True) — Indica se o modelo é usado como encoder/decoder ou não.
  • vocab_size (int, opcional, padrão 33201) — Tamanho do vocabulário do modelo. Define o número de tokens diferentes que podem ser representados pelos input_ids.
  • d_model (int, opcional, padrão 1024) — Tamanho das camadas do codificador e da camada pooler.
  • d_kv (int, opcional, padrão 64) — Tamanho das projeções de chave, consulta e valor por cabeça de atenção. O inner_dim da camada de projeção será definido como num_heads * d_kv.
  • d_ff (int, opcional, padrão 4096) — Dimensão das representações do MLP.
  • num_layers (int, opcional, padrão 24) — Número de camadas ocultas no decodificador do Transformer.
  • num_decoder_layers (int, opcional) — Número de camadas ocultas no decodificador do Transformer. Se não for definido, usará o mesmo valor de num_layers.
  • num_heads (int, opcional, padrão 16) — Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.
  • relative_attention_num_buckets (int, opcional, padrão 32) — O número de buckets a serem usados em cada camada de atenção.
  • relative_attention_max_distance (int, opcional, padrão 128) — A distância máxima das sequências mais longas para a separação em buckets.
  • relative_bias_args (list[dict], opcional, padrão [{'type' -- '1d'}, {'type': 'horizontal'}, {'type': 'vertical'}]): Uma lista de dicionários contendo os argumentos para as camadas de viés relativo.
  • dropout_rate (Union[float, int], opcional, padrão 0.1) — A proporção para todas as camadas de dropout.
  • layer_norm_epsilon (float, opcional, padrão 1e-06) — O epsilon usado pelas camadas de normalização de camada.
  • 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).
  • feed_forward_proj (string, opcional, padrão "relu") — Tipo de camada feed forward a ser utilizada. Deve ser "relu" ou "gated-gelu". O Udopv1.1 usa a projeção feed forward "gated-gelu". O Udop original usa "relu".
  • 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, padrão 0) — ID do token usado para preenchimento 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.
  • max_2d_position_embeddings (int, opcional, padrão 1024) — O valor máximo dos embeddings de posição absoluta para a codificação de posição relativa.
  • 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 16) — O tamanho (resolução) de cada patch.
  • num_channels (int, opcional, padrão 3) — O número de canais de entrada.
  • is_decoder (bool, opcional, padrão False) — Indica se o modelo é usado como decodificador ou não. Se False, o modelo é usado como codificador.
  • add_cross_attention (bool, opcional, padrão False) — Se camadas de atenção cruzada devem ser adicionadas ao modelo.
  • tie_word_embeddings (bool, opcional, padrão True) — 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 UdopModel. Ela é usada para instanciar um modelo Udop 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 microsoft/udop-large

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.

UdopTokenizer

classe transformers.UdopTokenizer

< >

( vocab: str | list[tuple[str, float]] | None = Noneeos_token = '</s>'sep_token = '</s>'unk_token = '<unk>'pad_token = '<pad>'sep_token_box = [1000, 1000, 1000, 1000]pad_token_box = [0, 0, 0, 0]pad_token_label = -100only_label_first_subword = Trueextra_special_tokens = None**kwargs )

Parâmetros

  • eos_token (str, opcional, padrão é "</s>") — O token de fim de sequência. Ao construir uma sequência usando tokens especiais, este não é o token usado para o fim da sequência. O token utilizado é o sep_token.

    Ao construir uma sequência usando tokens especiais, este não é o token utilizado para o fim da sequência. O token utilizado é o sep_token.

  • sep_token (str, opcional, padrão "</s>") — O token separador, usado ao construir uma sequência a partir de múltiplas sequências, por exemplo, duas sequências para classificação de sequência ou um texto e uma pergunta para question answering. Também é usado como o último token de uma sequência construída com tokens especiais.
  • unk_token (str, opcional, padrão "<unk>") — O token desconhecido. Um token que não está no vocabulário não pode ser convertido em um ID e é definido como este token em vez disso.
  • pad_token (str, opcional, padrão "<pad>") — O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes.
  • sep_token_box (list[int], opcional, padrão [1000, 1000, 1000, 1000]) — A caixa delimitadora a ser usada para o token especial [SEP].
  • pad_token_box (list[int], opcional, padrão [0, 0, 0, 0]) — A caixa delimitadora a ser usada para o token especial [PAD].
  • pad_token_label (int, opcional, padrão -100) — O rótulo a ser usado para tokens de preenchimento. O padrão é -100, que é o ignore_index da CrossEntropyLoss do PyTorch.
  • only_label_first_subword (bool, opcional, padrão True) — Indica se apenas a primeira subpalavra deve ser rotulada, caso rótulos de palavras sejam fornecidos.
  • extra_special_tokens (list[str], opcional, padrão ["<s>NOTUSED", "</s>NOTUSED"]) — Tokens especiais extras usados pelo tokenizer.

Construa um tokenizador UDOP “rápido” (baseado na biblioteca tokenizers do HuggingFace). Adaptado de LayoutXLMTokenizer e T5Tokenizer. Baseado em BPE.

Este tokenizador herda de TokenizersBackend, que contém a maioria dos métodos principais. Os usuários devem consultar essa superclasse para obter mais informações sobre esses métodos.

build_inputs_with_special_tokens

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Parâmetros

  • token_ids_0 (list[int]) — Lista de IDs aos quais os tokens especiais serão adicionados.
  • token_ids_1 (list[int], opcional) — Lista opcional de IDs para pares de sequências.

Retorna

list[int]

Lista de IDs de entrada com os tokens especiais apropriados.

Construa as entradas do modelo a partir de uma sequência ou de um par de sequências para tarefas de classificação de sequência, concatenando e adicionando tokens especiais. Uma sequência do XLM-RoBERTa tem o seguinte formato:

  • sequência única: <s> X </s>
  • par de sequências: <s> A </s></s> B </s>

get_special_tokens_mask

< >

( token_ids_0: list[int]token_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → A list of integers in the range [0, 1]

Parâmetros

  • token_ids_0 — Lista de IDs da sequência (possivelmente já formatada).
  • token_ids_1 — Não utilizado quando already_has_special_tokens=True. Deve ser None nesse caso.
  • already_has_special_tokens — Indica se a sequência já está formatada com tokens especiais.

Retorna

Uma lista de inteiros no intervalo [0, 1]

1 para um token especial, 0 para um token de sequência.

Obter os ids de sequência de uma lista de tokens que não possui tokens especiais adicionados.

Para tokenizadores rápidos, os data collators chamam isso com already_has_special_tokens=True para construir uma máscara sobre uma sequência já formatada. Nesse caso, calculamos a máscara verificando a pertença em all_special_ids.

create_token_type_ids_from_sequences

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

Parâmetros

  • token_ids_0 (list[int]) — Lista de IDs.
  • token_ids_1 (list[int], opcional) — Lista opcional de IDs para pares de sequências.

Retorna

list[int]

Lista de zeros.

Cria uma máscara a partir das duas sequências passadas para ser usada em uma tarefa de classificação de pares de sequências. O XLM-RoBERTa não faz uso de ids de tipo de token, portanto, uma lista de zeros é retornada.

save_vocabulary

< >

( save_directory: strfilename_prefix: str | None = None )

Salve os arquivos de vocabulário do tokenizer. Para o TokenizersBackend, o arquivo tokenizer.json é salvo pela classe base. Este método retorna uma tupla vazia, pois utilizamos apenas o tokenizer.json.

UdopProcessor

classe transformers.UdopProcessor

< >

( image_processortokenizer )

Parâmetros

  • image_processor (LayoutLMv3ImageProcessor) — O processador de imagem é uma entrada obrigatória.
  • tokenizer (UdopTokenizer) — O tokenizer é uma entrada obrigatória.

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

UdopProcessor oferece todas as funcionalidades de LayoutLMv3ImageProcessor e UdopTokenizer. Consulte ~LayoutLMv3ImageProcessor e ~UdopTokenizer para mais informações.

__call__

< >

( images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor'], NoneType] = Nonetext: str | list[str] | list[list[str]] = None**kwargs: *<class 'transformers.models.udop.processing_udop.UdopProcessorKwargs'> ) → ~image_processing_base.BatchFeature

Parâmetros

  • images (Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]], opcional) — Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se passar imagens com valores de pixel entre 0 e 1, defina do_rescale=False.
  • text (Union[str, list[str], list[list[str]]], opcional) — A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string ou uma lista de strings (string pré-tokenizada). Se você passar uma entrada pré-tokenizada, defina is_split_into_words=True para evitar ambiguidade com entradas em lote.
  • return_tensors (str ou TensorType, opcional) — Se definido, retornará tensors de um framework específico. Os valores aceitos são:
    • 'pt': Retorna objetos torch.Tensor do PyTorch.
    • 'np': Retorna objetos np.ndarray do NumPy.
  • **kwargs (ProcessingKwargs, opcional) — Opções de processamento adicionais para cada modalidade (texto, imagens, vídeos, áudio). Os parâmetros específicos do modelo estão listados acima; consulte a classe TypedDict para a lista completa de argumentos suportados.

Retorna

~image_processing_base.BatchFeature

  • data (dict) — Dicionário de listas/arrays/tensors retornados pelo método call (‘pixel_values’, etc.).
  • tensor_type (Union[None, str, TensorType], opcional) — Você pode fornecer um tensor_type aqui para converter as listas de inteiros em Tensors do PyTorch/Numpy na inicialização.

UdopModel

classe transformers.UdopModel

< >

( config: UdopConfig )

Parâmetros

  • config (UdopConfig) — 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 Udop puro, que produz estados ocultos brutos sem nenhum cabeçalho 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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonebbox: dict[str, typing.Any] | None = Nonepixel_values: typing.Optional[torch.Tensor] = Nonevisual_bbox: dict[str, typing.Any] | None = Nonedecoder_input_ids: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqModelOutput or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.Tensor de formato (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?

  • bbox (torch.LongTensor de forma ({0}, 4), opcional) — Caixas delimitadoras dos tokens de cada sequência de entrada. Selecionadas no intervalo [0, config.max_2d_position_embeddings-1]. Cada caixa delimitadora deve ser uma versão normalizada no formato (x0, y0, x1, y1), onde (x0, y0) corresponde à posição do canto superior esquerdo da caixa delimitadora e (x1, y1) representa a posição do canto inferior direito.

    Observe que sequence_length = token_sequence_length + patch_sequence_length + 1, em que 1 corresponde ao token [CLS]. Consulte pixel_values para patch_sequence_length.

  • 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 LayoutLMv3ImageProcessor. Consulte LayoutLMv3ImageProcessor.call() para detalhes (UdopProcessor usa LayoutLMv3ImageProcessor para processar imagens).
  • visual_bbox (torch.LongTensor de forma (batch_size, patch_sequence_length, 4), opcional) — Caixas delimitadoras de cada patch na imagem. Se não fornecidas, as caixas delimitadoras são criadas no modelo.
  • decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador? O T5 usa o pad_token_id como o token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente apenas o último decoder_input_ids precisa ser inserido (veja past_key_values). Para saber mais sobre como preparar decoder_input_ids para pré-treinamento, veja T5 Training.
  • decoder_attention_mask (torch.BoolTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento em decoder_input_ids. A máscara causal também será usada por padrão.
  • 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.
  • encoder_outputs (torch.Tensor, opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
  • 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).

  • decoder_inputs_embeds (torch.Tensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar decoder_input_ids você pode escolher passar diretamente uma representação incorporada. Se past_key_values for usado, opcionalmente apenas o último decoder_inputs_embeds precisa ser entrada (veja past_key_values). Isso é útil se você quiser mais controle sobre como converter decoder_input_ids índices em vetores associados do que a matriz de busca de incorporação interna do modelo.

    Se decoder_input_ids e decoder_inputs_embeds estiverem ambos não definidos, decoder_inputs_embeds assume o valor de inputs_embeds.

  • 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

Seq2SeqModelOutput ou tuple(torch.Tensor)

Um Seq2SeqModelOutput 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 (UdopConfig) e das entradas.

O método forward do UdopModel 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 decodificador 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 (EncoderDecoderCache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.

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

  • decoder_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 decodificador na saída de cada camada, além das saídas opcionais do embedding inicial.

  • decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

  • cross_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 da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

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

  • encoder_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 codificador na saída de cada camada, além das saídas opcionais do embedding inicial.

  • encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplo:

>>> from transformers import AutoProcessor, AutoModel
>>> from datasets import load_dataset
>>> import torch

>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = AutoModel.from_pretrained("microsoft/udop-large")

>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> inputs = processor(image, words, boxes=boxes, return_tensors="pt")

>>> decoder_input_ids = torch.tensor([[model.config.decoder_start_token_id]])

>>> # forward pass
>>> outputs = model(**inputs, decoder_input_ids=decoder_input_ids)
>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 1, 1024]

UdopForConditionalGeneration

classe transformers.UdopForConditionalGeneration

< >

( config: UdopConfig )

Parâmetros

  • config (UdopConfig) — 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 Transformer encoder-decoder UDOP com uma cabeça de modelagem de linguagem no topo, permitindo gerar texto a partir de imagens de documentos e um prompt opcional.

Esta classe é baseada em T5ForConditionalGeneration, estendida para lidar com dados de imagens e layout (2D).

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.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonebbox: dict[str, typing.Any] | None = Nonepixel_values: typing.Optional[torch.Tensor] = Nonevisual_bbox: dict[str, typing.Any] | None = Nonedecoder_input_ids: typing.Optional[torch.Tensor] = Nonedecoder_attention_mask: typing.Optional[torch.Tensor] = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneencoder_outputs: typing.Optional[torch.Tensor] = Nonepast_key_values: transformers.cache_utils.Cache | None = Nonedecoder_inputs_embeds: typing.Optional[torch.Tensor] = Noneuse_cache: bool | None = Nonelabels: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → Seq2SeqLMOutput or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.Tensor de formato (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?

  • bbox (torch.LongTensor de forma ({0}, 4), opcional) — Caixas delimitadoras dos tokens de cada sequência de entrada. Selecionadas no intervalo [0, config.max_2d_position_embeddings-1]. Cada caixa delimitadora deve ser uma versão normalizada no formato (x0, y0, x1, y1), onde (x0, y0) corresponde à posição do canto superior esquerdo da caixa delimitadora e (x1, y1) representa a posição do canto inferior direito.

    Observe que sequence_length = token_sequence_length + patch_sequence_length + 1, em que 1 corresponde ao token [CLS]. Consulte pixel_values para patch_sequence_length.

  • 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 LayoutLMv3ImageProcessor. Consulte LayoutLMv3ImageProcessor.call() para detalhes (UdopProcessor usa LayoutLMv3ImageProcessor para processar imagens).
  • visual_bbox (torch.LongTensor de forma (batch_size, patch_sequence_length, 4), opcional) — Caixas delimitadoras de cada patch na imagem. Se não fornecidas, as caixas delimitadoras são criadas no modelo.
  • decoder_input_ids (torch.LongTensor de forma (batch_size, target_sequence_length), opcional) — Índices dos tokens da sequência de entrada do decodificador no vocabulário. Os índices podem ser obtidos usando AutoTokenizer. Consulte PreTrainedTokenizer.encode() e PreTrainedTokenizer.call() para mais detalhes. O que são IDs de entrada do decodificador? O T5 usa o pad_token_id como o token inicial para a geração de decoder_input_ids. Se past_key_values for usado, opcionalmente apenas o último decoder_input_ids precisa ser inserido (veja past_key_values). Para saber mais sobre como preparar decoder_input_ids para pré-treinamento, veja T5 Training.
  • decoder_attention_mask (torch.BoolTensor de forma (batch_size, target_sequence_length), opcional) — Comportamento padrão: gera um tensor que ignora tokens de preenchimento em decoder_input_ids. A máscara causal também será usada por padrão.
  • 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.
  • encoder_outputs (torch.Tensor, opcional) — A tupla consiste em (last_hidden_state, opcional: hidden_states, opcional: attentions) last_hidden_state de forma (batch_size, sequence_length, hidden_size), opcional) é uma sequência de hidden-states na saída da última camada do encoder. Usado na cross-attention do decoder.
  • 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).

  • decoder_inputs_embeds (torch.Tensor de forma (batch_size, target_sequence_length, hidden_size), opcional) — Opcionalmente, em vez de passar decoder_input_ids você pode escolher passar diretamente uma representação incorporada. Se past_key_values for usado, opcionalmente apenas o último decoder_inputs_embeds precisa ser entrada (veja past_key_values). Isso é útil se você quiser mais controle sobre como converter decoder_input_ids índices em vetores associados do que a matriz de busca de incorporação interna do modelo.

    Se decoder_input_ids e decoder_inputs_embeds estiverem ambos não definidos, decoder_inputs_embeds assume o valor de inputs_embeds.

  • 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).
  • labels (torch.LongTensor de forma (batch_size,), opcional) — Rótulos para o cálculo da perda de modelagem de linguagem. Os índices devem estar em [-100, 0, ..., config.vocab_size - 1]. Todos os rótulos definidos como -100 são ignorados (mascarados); a perda é calculada apenas para os rótulos em [0, ..., config.vocab_size].

Retorna

Seq2SeqLMOutput ou tuple(torch.Tensor)

Um Seq2SeqLMOutput 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 (UdopConfig) e das entradas.

O método forward de UdopForConditionalGeneration 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.

  • 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 (EncoderDecoderCache, opcional, retornado quando use_cache=True é passado ou quando config.use_cache=True) — Trata-se de uma instância de EncoderDecoderCache. Para mais detalhes, consulte nosso guia de cache kv.

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

  • decoder_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 decodificador na saída de cada camada, além das saídas do embedding inicial.

  • decoder_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 do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

  • cross_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 da camada de atenção cruzada do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de atenção cruzada.

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

  • encoder_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 codificador na saída de cada camada, além das saídas do embedding inicial.

  • encoder_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 do codificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de autoatenção.

Exemplos:

>>> from transformers import AutoProcessor, UdopForConditionalGeneration
>>> from datasets import load_dataset

>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = UdopForConditionalGeneration.from_pretrained("microsoft/udop-large")

>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]

>>> # one can use the various task prefixes (prompts) used during pre-training
>>> # e.g. the task prefix for DocVQA is "Question answering. "
>>> question = "Question answering. What is the date on the form?"
>>> encoding = processor(image, question, text_pair=words, boxes=boxes, return_tensors="pt")

>>> # autoregressive generation
>>> predicted_ids = model.generate(**encoding)
>>> print(processor.batch_decode(predicted_ids, skip_special_tokens=True)[0])
9/30/92

UdopEncoderModel

classe transformers.UdopEncoderModel

< >

( config: UdopConfig )

Parâmetros

  • config (UdopConfig) — 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 Udop puro, que produz estados ocultos brutos sem nenhum cabeçalho 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.Tensor] = Nonebbox: dict[str, typing.Any] | None = Noneattention_mask: typing.Optional[torch.Tensor] = Nonepixel_values: typing.Optional[torch.Tensor] = Nonevisual_bbox: dict[str, typing.Any] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = None**kwargs: *<class 'transformers.utils.generic.TransformersKwargs'> ) → BaseModelOutputWithAttentionMask or tuple(torch.Tensor)

Parâmetros

  • input_ids (torch.LongTensor de forma (batch_size, sequence_length)) — Índices dos tokens da sequência de entrada no vocabulário. O T5 é um modelo com embeddings de posição relativa, portanto, você deve poder fazer padding das entradas tanto à direita quanto à esquerda.

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

    Para saber mais sobre como preparar input_ids para o pré-treino, veja T5 Training.

  • bbox (torch.LongTensor de forma ({0}, 4), opcional) — Caixas delimitadoras dos tokens de cada sequência de entrada. Selecionadas no intervalo [0, config.max_2d_position_embeddings-1]. Cada caixa delimitadora deve ser uma versão normalizada no formato (x0, y0, x1, y1), onde (x0, y0) corresponde à posição do canto superior esquerdo da caixa delimitadora e (x1, y1) representa a posição do canto inferior direito.

    Observe que sequence_length = token_sequence_length + patch_sequence_length + 1, em que 1 corresponde ao token [CLS]. Consulte pixel_values para patch_sequence_length.

  • 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?

  • 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 LayoutLMv3ImageProcessor. Consulte LayoutLMv3ImageProcessor.call() para detalhes (UdopProcessor usa LayoutLMv3ImageProcessor para processar imagens).
  • visual_bbox (torch.LongTensor de forma (batch_size, patch_sequence_length, 4), opcional) — Caixas delimitadoras de cada patch na imagem. Se não fornecidas, as caixas delimitadoras são criadas no modelo.
  • 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.

Retorna

BaseModelOutputWithAttentionMask ou tuple(torch.Tensor)

Uma BaseModelOutputWithAttentionMask 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 (UdopConfig) e das entradas.

O método forward do UdopEncoderModel 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 hidden-states na saída da última camada do modelo. Se past_key_values for usado, apenas o último hidden-state das sequências, de forma (batch_size, 1, hidden_size), é retornado.

  • attention_mask (torch.Tensor de forma (batch_size, sequence_length), opcional) — Máscara de atenção usada na passagem direta do modelo 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.

  • 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) com a forma (batch_size, sequence_length, hidden_size). Hidden-states do modelo na saída de cada camada, além das saídas iniciais opcionais dos embeddings.

  • 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 das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

  • cross_attentions (tuple(torch.Tensor), opcional, retornado quando output_attentions=True e config.add_cross_attention=True são passados 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 da camada de cross-attention do decodificador, após o softmax de atenção, usados para calcular a média ponderada nas cabeças de cross-attention.

Exemplo:

>>> from transformers import AutoProcessor, UdopEncoderModel
>>> from huggingface_hub import hf_hub_download
>>> from datasets import load_dataset

>>> # load model and processor
>>> # in this case, we already have performed OCR ourselves
>>> # so we initialize the processor with `apply_ocr=False`
>>> processor = AutoProcessor.from_pretrained("microsoft/udop-large", apply_ocr=False)
>>> model = UdopEncoderModel.from_pretrained("microsoft/udop-large")

>>> # load an example image, along with the words and coordinates
>>> # which were extracted using an OCR engine
>>> dataset = load_dataset("nielsr/funsd-layoutlmv3", split="train")
>>> example = dataset[0]
>>> image = example["image"]
>>> words = example["tokens"]
>>> boxes = example["bboxes"]
>>> encoding = processor(image, words, boxes=boxes, return_tensors="pt")

>>> outputs = model(**encoding)
>>> last_hidden_states = outputs.last_hidden_state
Update on GitHub

←TVP UnlimitedOcr→