# LayoutLMV2 ## Visão geral O modelo LayoutLMV2 foi proposto em [LayoutLMv2: Multi-modal Pre-training for Visually-Rich Document Understanding](https://huggingface.co/papers/2012.14740) por Yang Xu, Yiheng Xu, Tengchao Lv, Lei Cui, Furu Wei, Guoxin Wang, Yijuan Lu, Dinei Florencio, Cha Zhang, Wanxiang Che, Min Zhang, Lidong Zhou. O LayoutLMV2 melhora o [LayoutLM](layoutlm) para obter resultados de estado da arte em vários benchmarks de compreensão de imagens de documentos: - extração de informações de documentos digitalizados: o conjunto de dados [FUNSD](https://guillaumejaume.github.io/FUNSD/) (uma coleção de 199 formulários anotados, contendo mais de 30.000 palavras), o conjunto de dados [CORD](https://github.com/clovaai/cord) (uma coleção de 800 recibos para treinamento, 100 para validação e 100 para teste), o conjunto de dados [SROIE](https://rrc.cvc.uab.es/?ch=13) (uma coleção de 626 recibos para treinamento e 347 recibos para teste) e o conjunto de dados [Kleister-NDA](https://github.com/applicaai/kleister-nda) (uma coleção de acordos de confidencialidade do banco de dados EDGAR, incluindo 254 documentos para treinamento, 83 documentos para validação e 203 documentos para teste). - classificação de imagens de documentos: o conjunto de dados [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/) (uma coleção de 400.000 imagens pertencentes a uma de 16 classes). - resposta a perguntas sobre documentos: o conjunto de dados [DocVQA](https://huggingface.co/papers/2007.00398) (uma coleção de 50.000 perguntas definidas em mais de 12.000 imagens de documentos). O resumo do artigo é o seguinte: *O pré-treino de texto e layout demonstrou ser eficaz em uma variedade de tarefas de compreensão de documentos visualmente ricos, devido à sua arquitetura de modelo eficaz e à vantagem de documentos digitalizados/nativos digitais não rotulados em larga escala. Neste artigo, apresentamos o LayoutLMv2 por meio do pré-treino de texto, layout e imagem em um framework multimodal, no qual novas arquiteturas de modelo e tarefas de pré-treino são aproveitadas. Especificamente, o LayoutLMv2 não apenas utiliza a tarefa existente de modelagem visual-linguística mascarada, mas também as novas tarefas de alinhamento texto-imagem e correspondência texto-imagem na etapa de pré-treino, onde a interação entre modalidades é melhor aprendida. Ao mesmo tempo, ele também integra um mecanismo de autoatenção com consciência espacial na arquitetura Transformer, para que o modelo possa compreender plenamente o relacionamento posicional relativo entre diferentes blocos de texto. Os resultados experimentais mostram que o LayoutLMv2 supera baselines fortes e alcança novos resultados state-of-the-art em uma ampla variedade de tarefas downstream de compreensão de documentos visualmente ricos, incluindo FUNSD (0.7895 -> 0.8420), CORD (0.9493 -> 0.9601), SROIE (0.9524 -> 0.9781), Kleister-NDA (0.834 -> 0.852), RVL-CDIP (0.9443 -> 0.9564) e DocVQA (0.7295 -> 0.8672). O modelo LayoutLMv2 pré-treinado está publicamente disponível neste https URL.* O LayoutLMv2 depende de `detectron2`, `torchvision` e `tesseract`. Execute o seguinte para instalá-los: ```bash python -m pip install 'git+https://github.com/facebookresearch/detectron2.git' python -m pip install torchvision tesseract ``` (Se você está desenvolvendo para o LayoutLMv2, observe que a execução dos doctests também requer a instalação desses pacotes.) ## Dicas de uso - A principal diferença entre LayoutLMv1 e LayoutLMv2 é que o segundo incorpora embeddings visuais durante o pré-treino (enquanto o LayoutLMv1 adiciona embeddings visuais apenas durante o ajuste fino). - O LayoutLMv2 adiciona tanto um viés de atenção relativo 1D quanto um viés de atenção espacial 2D às pontuações de atenção nas camadas de autoatenção. Os detalhes podem ser encontrados na página 5 do [artigo](https://huggingface.co/papers/2012.14740). - Notebooks de demonstração sobre como usar o modelo LayoutLMv2 em RVL-CDIP, FUNSD, DocVQA e CORD podem ser encontrados [aqui](https://github.com/NielsRogge/Transformers-Tutorials). - O LayoutLMv2 usa o pacote [Detectron2](https://github.com/facebookresearch/detectron2/) da Facebook AI para sua espinha dorsal visual. Consulte [este link](https://detectron2.readthedocs.io/en/latest/tutorials/install.html) para as instruções de instalação. - Além de `input_ids`, [forward()](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Model.forward) espera 2 entradas adicionais, a saber, `image` e `bbox`. A entrada `image` corresponde à imagem original do documento em que os tokens de texto ocorrem. O modelo espera que cada imagem de documento tenha o tamanho 224x224. Isso significa que, se você tiver um lote de imagens de documentos, `image` deve ser um tensor de forma (batch_size, 3, 224, 224). Isso pode ser um `torch.Tensor` ou um `Detectron2.structures.ImageList`. Você não precisa normalizar os canais, pois isso é feito pelo modelo. É importante observar que o backbone visual espera canais BGR em vez de RGB, pois todos os modelos no Detectron2 são pré-treinados usando o formato BGR. A entrada `bbox` são as caixas delimitadoras (ou seja, posições 2D) dos tokens de texto de entrada. Isso é idêntico ao [LayoutLMModel](/docs/transformers/main/pt/model_doc/layoutlm#transformers.LayoutLMModel). Essas podem ser obtidas usando um mecanismo de OCR externo, como o [Tesseract](https://github.com/tesseract-ocr/tesseract) da Google (há um [Python wrapper](https://pypi.org/project/pytesseract/) disponível). Cada caixa delimitadora deve estar no formato (x0, y0, x1, y1), onde (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 primeiro é necessário normalizar as caixas delimitadoras para uma escala de 0-1000. Para normalizar, você pode usar a seguinte função: ```python 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 (antes do redimensionamento da imagem). Esses valores podem ser obtidos, por exemplo, usando a biblioteca Python Image Library (PIL), da seguinte forma: ```python from PIL import Image image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ) width, height = image.size ``` No entanto, este modelo inclui um [LayoutLMv2Processor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) totalmente novo, que pode ser usado para preparar diretamente os dados para o modelo (incluindo a aplicação de OCR internamente). Mais informações podem ser encontradas na seção "Usage" abaixo. - Internamente, o [LayoutLMv2Model](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Model) envia a entrada `image` por meio de seu backbone visual para obter um mapa de recursos de resolução mais baixa, cuja forma é igual ao atributo `image_feature_pool_shape` de [LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config). Esse mapa de recursos é, em seguida, achatado para obter uma sequência de tokens de imagem. Como o tamanho do mapa de recursos é 7x7 por padrão, obtêm-se 49 tokens de imagem. Esses tokens são, então, concatenados com os tokens de texto e enviados por meio do codificador Transformer. Isso significa que os últimos estados ocultos do modelo terão um comprimento de 512 + 49 = 561, se você preencher os tokens de texto até o comprimento máximo. De forma mais geral, os últimos estados ocultos terão uma forma de `seq_length` + `image_feature_pool_shape[0]` * `config.image_feature_pool_shape[1]`. - Ao chamar [from_pretrained()](/docs/transformers/main/pt/main_classes/model#transformers.PreTrainedModel.from_pretrained), um aviso será exibido com uma longa lista de nomes de parâmetros que não foram inicializados. Isso não é um problema, pois esses parâmetros são estatísticas de normalização de lote, que terão valores ao fazer fine-tuning em um conjunto de dados personalizado. - Se você deseja treinar o modelo em um ambiente distribuído, certifique-se de chamar `synchronize_batch_norm` no modelo para sincronizar corretamente as camadas de normalização de lote do backbone visual. Além disso, existe o LayoutXLM, que é uma versão multilíngue do LayoutLMv2. Mais informações podem ser encontradas na [página de documentação do LayoutXLM](layoutxlm). ## Recursos Uma lista de recursos oficiais do Hugging Face e da comunidade (indicados por 🌎) para ajudar você a começar com o LayoutLMv2. Se você tiver interesse 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. - Um notebook sobre como [ajustar finamente o LayoutLMv2 para classificação de texto no conjunto de dados RVL-CDIP](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/RVL-CDIP/Fine_tuning_LayoutLMv2ForSequenceClassification_on_RVL_CDIP.ipynb). - Veja também: [Guia da tarefa de classificação de texto](../tasks/sequence_classification) - Um notebook sobre como [ajustar finamente o LayoutLMv2 para resposta a perguntas no conjunto de dados DocVQA](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/DocVQA/Fine_tuning_LayoutLMv2ForQuestionAnswering_on_DocVQA.ipynb). - Veja também: [Guia da tarefa de resposta a perguntas](../tasks/question_answering) - Veja também: [Guia da tarefa de resposta a perguntas sobre documentos](../tasks/document_question_answering) - Um notebook sobre como [ajustar finamente o LayoutLMv2 para classificação de tokens no conjunto de dados CORD](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/CORD/Fine_tuning_LayoutLMv2ForTokenClassification_on_CORD.ipynb). - Um notebook sobre como [ajustar finamente o LayoutLMv2 para classificação de tokens no conjunto de dados FUNSD](https://colab.research.google.com/github/NielsRogge/Transformers-Tutorials/blob/master/LayoutLMv2/FUNSD/Fine_tuning_LayoutLMv2ForTokenClassification_on_FUNSD_using_HuggingFace_Trainer.ipynb). - Veja também: [Guia da tarefa de classificação de tokens](../tasks/token_classification) ## Uso: LayoutLMv2Processor A maneira mais fácil de preparar os dados para o modelo é usar o [LayoutLMv2Processor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Processor), que internamente combina um processador de imagem ([LayoutLMv2ImageProcessor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor)) e um tokenizador ([LayoutLMv2Tokenizer](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) ou [LayoutLMv2TokenizerFast](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer)). O processador de imagem lida com a modalidade de imagem, enquanto o tokenizador lida com a modalidade de texto. Um processador combina ambos, o que é ideal para um modelo multimodal como o LayoutLMv2. Observe que você ainda pode usar ambos separadamente, caso queira lidar com apenas uma modalidade. ```python from transformers import LayoutLMv2ImageProcessor, LayoutLMv2Processor, LayoutLMv2TokenizerFast image_processor = LayoutLMv2ImageProcessor() # apply_ocr is set to True by default tokenizer = LayoutLMv2TokenizerFast.from_pretrained("microsoft/layoutlmv2-base-uncased") processor = LayoutLMv2Processor(image_processor, tokenizer) ``` Em resumo, é possível fornecer uma imagem de documento (e possivelmente dados adicionais) ao [LayoutLMv2Processor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Processor), e ele criará as entradas esperadas pelo modelo. Internamente, o processador primeiro usa o [LayoutLMv2ImageProcessor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) para aplicar OCR na imagem e obter uma lista de palavras e caixas delimitadoras normalizadas, além de redimensionar a imagem para um tamanho específico a fim de obter a entrada `image`. As palavras e as caixas delimitadoras normalizadas são então fornecidas ao [LayoutLMv2Tokenizer](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) ou ao [LayoutLMv2TokenizerFast](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer), que as convertem em `input_ids`, `attention_mask`, `token_type_ids` e `bbox` no nível de tokens. Opcionalmente, é possível fornecer rótulos de palavras ao processador, que são convertidos em `labels` no nível de tokens. [LayoutLMv2Processor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) utiliza [PyTesseract](https://pypi.org/project/pytesseract/), um wrapper em Python para o mecanismo de OCR Tesseract da Google, por baixo dos panos. Observe que você ainda pode usar seu próprio mecanismo de OCR de preferência e fornecer as palavras e as caixas normalizadas por conta própria. Isso requer inicializar o [LayoutLMv2ImageProcessor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) com `apply_ocr` definido como `False`. No total, há 5 casos de uso suportados pelo processador. Abaixo, listamos todos eles. Observe que cada um desses casos de uso funciona tanto para entradas em lote (batched) quanto para entradas não em lote (non-batched) (ilustramos para entradas não em lote). **Caso de uso 1: classificação de imagem de documento (treinamento, inferência) + classificação de tokens (inferência), apply_ocr = True** Esse é o caso mais simples, no qual o processador (na verdade, o processador de imagem) executará OCR na imagem para obter as palavras e as caixas delimitadoras normalizadas. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") encoding = processor( image, return_tensors="pt" ) # you can also add all tokenizer parameters here such as padding, truncation print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Caso de uso 2: classificação de imagem de documento (treinamento, inferência) + classificação de token (inferência), apply_ocr=False** Caso se queira realizar o OCR por conta própria, é possível inicializar o processador de imagem com `apply_ocr` definido como `False`. Nesse caso, deve-se fornecer as palavras e as caixas delimitadoras (normalizadas) correspondentes diretamente ao processador. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes encoding = processor(image, words, boxes=boxes, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Caso de uso 3: classificação de tokens (treinamento), apply_ocr=False** Para tarefas de classificação de tokens (como FUNSD, CORD, SROIE, Kleister-NDA), também é possível fornecer os rótulos de palavras correspondentes para treinar um modelo. O processador converterá esses rótulos em `labels` no nível de token. Por padrão, ele rotulará apenas o primeiro wordpiece de uma palavra e rotulará os wordpieces restantes com -100, que é o `ignore_index` do CrossEntropyLoss do PyTorch. Caso você queira que todos os wordpieces de uma palavra sejam rotulados, pode inicializar o tokenizer com `only_label_first_subword` definido como `False`. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes word_labels = [1, 2] encoding = processor(image, words, boxes=boxes, word_labels=word_labels, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'labels', 'image']) ``` **Caso de uso 4: resposta a perguntas visuais (inferência), apply_ocr=True** Para tarefas de resposta a perguntas visuais (como DocVQA), você pode fornecer uma pergunta ao processador. Por padrão, o processador aplica OCR na imagem e cria [CLS] tokens da pergunta [SEP] tokens das palavras [SEP]. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") question = "What's his name?" encoding = processor(image, question, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` **Caso de uso 5: resposta a perguntas visuais (inferência), apply_ocr=False** Para tarefas de resposta a perguntas visuais (como DocVQA), você pode fornecer uma pergunta ao processador. Se quiser executar o OCR por conta própria, pode fornecer suas próprias palavras e caixas delimitadoras (normalizadas) ao processador. ```python from PIL import Image from transformers import LayoutLMv2Processor processor = LayoutLMv2Processor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") image = Image.open( "name_of_your_document - can be a png, jpg, etc. of your documents (PDFs must be converted to images)." ).convert("RGB") question = "What's his name?" words = ["hello", "world"] boxes = [[1, 2, 3, 4], [5, 6, 7, 8]] # make sure to normalize your bounding boxes encoding = processor(image, question, words, boxes=boxes, return_tensors="pt").to(model.device) print(encoding.keys()) # dict_keys(['input_ids', 'token_type_ids', 'attention_mask', 'bbox', 'image']) ``` ## LayoutLMv2Config[[transformers.LayoutLMv2Config]] #### transformers.LayoutLMv2Config[[transformers.LayoutLMv2Config]] ```python transformers.LayoutLMv2Config(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 = 30522, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = 'gelu', hidden_dropout_prob: float | int = 0.1, attention_probs_dropout_prob: float | int = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 2, initializer_range: float = 0.02, layer_norm_eps: float = 1e-12, pad_token_id: int | None = 0, max_2d_position_embeddings: int = 1024, max_rel_pos: int = 128, rel_pos_bins: int = 32, fast_qkv: bool = True, max_rel_2d_pos: int = 256, rel_2d_pos_bins: int = 64, convert_sync_batchnorm: bool = True, image_feature_pool_shape: list[int] | tuple[int, ...] = (7, 7, 256), coordinate_size: int = 128, shape_size: int = 128, has_relative_attention_bias: bool = True, has_spatial_attention_bias: bool = True, has_visual_segment_embedding: bool = False, detectron2_config_args: dict | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/configuration_layoutlmv2.py#L29) **Parâmetros:** vocab_size (`int`, *opcional*, padrão `30522`) : 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 `768`) : Dimensão das representações ocultas. 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. intermediate_size (`int`, *opcional*, padrão `3072`) : Dimensão das representações do MLP. 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. hidden_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A probabilidade de dropout para todas as camadas totalmente conectadas nos embeddings, encoder e pooler. attention_probs_dropout_prob (`Union[float, int]`, *opcional*, padrão `0.1`) : A taxa de dropout para as probabilidades de atenção. max_position_embeddings (`int`, *opcional*, padrão `512`) : O comprimento máximo de sequência com o qual este modelo pode ser utilizado. type_vocab_size (`int`, *opcional*, padrão `2`) : O tamanho do vocabulário dos `token_type_ids`. initializer_range (`float`, *opcional*, padrão `0.02`) : O desvio padrão do truncated_normal_initializer para inicializar todas as matrizes de pesos. layer_norm_eps (`float`, *opcional*, padrão `1e-12`) : O epsilon usado pelas camadas de normalização de camada. pad_token_id (`int`, *opcional*, padrão `0`) : ID do token usado para preenchimento no vocabulário. max_2d_position_embeddings (`int`, *opcional*, padrão 1024) : O valor máximo com o qual a incorporação de posição 2D pode ser usada. Normalmente, defina este valor para algo grande, apenas por precaução (por exemplo, 1024). max_rel_pos (`int`, *opcional*, padrão 128) : O número máximo de posições relativas a serem usadas no mecanismo de autoatenção. rel_pos_bins (`int`, *opcional*, padrão 32) : O número de bins de posição relativa a serem usados no mecanismo de autoatenção. fast_qkv (`bool`, *opcional*, padrão `True`) : Indica se deve ou não usar uma única matriz para as queries, keys e values nas camadas de autoatenção. max_rel_2d_pos (`int`, *opcional*, padrão 256) : O número máximo de posições 2D relativas no mecanismo de autoatenção. rel_2d_pos_bins (`int`, *opcional*, padrão 64) : O número de bins de posição relativa 2D no mecanismo de autoatenção. convert_sync_batchnorm (`bool`, *opcional*, padrão `True`) : Indica se as camadas de normalização de lote devem ser convertidas em camadas de normalização de lote sincronizada. image_feature_pool_shape (`list[int]`, *opcional*, padrão `[7, 7, 256]`) : A forma do mapa de recursos com pooling médio. coordinate_size (`int`, *opcional*, padrão 128) : Dimensão dos embeddings de coordenadas. shape_size (`int`, *opcional*, padrão 128) : Dimensão dos embeddings de largura e altura. has_relative_attention_bias (`bool`, *opcional*, padrão `True`) : Indica se deve ou não usar um viés de atenção relativo no mecanismo de autoatenção. has_spatial_attention_bias (`bool`, *opcional*, padrão `True`) : Indica se deve ou não usar um viés de atenção espacial no mecanismo de autoatenção. has_visual_segment_embedding (`bool`, *opcional*, padrão `False`) : Indica se deve ou não adicionar embeddings de segmentos visuais. detectron2_config_args (`dict`, *opcional*) : Dicionário contendo os argumentos de configuração do backbone visual do Detectron2. Consulte [este arquivo](https://github.com/microsoft/unilm/blob/master/layoutlmft/layoutlmft/models/layoutlmv2/detectron2_config.py) para obter detalhes sobre os valores padrão. Esta é a classe de configuração para armazenar a configuração de um LayoutLMv2Model. Ela é usada para instanciar um modelo Layoutlmv2 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/layoutlmv2-base-uncased](https://huggingface.co/microsoft/layoutlmv2-base-uncased) 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 LayoutLMv2Config, LayoutLMv2Model >>> # Initializing a LayoutLMv2 microsoft/layoutlmv2-base-uncased style configuration >>> configuration = LayoutLMv2Config() >>> # Initializing a model (with random weights) from the microsoft/layoutlmv2-base-uncased style configuration >>> model = LayoutLMv2Model(configuration) >>> # Accessing the model configuration >>> configuration = model.config ``` ## LayoutLMv2ImageProcessor[[transformers.LayoutLMv2ImageProcessor]] #### transformers.LayoutLMv2ImageProcessor[[transformers.LayoutLMv2ImageProcessor]] ```python transformers.LayoutLMv2ImageProcessor(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_layoutlmv2.py#L118) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : 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' : 224, 'width': 224}`): 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 `2`) : 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*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `None`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : 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*) : 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. apply_ocr (`bool`, *kwargs*, *opcional*, padrão é `self.apply_ocr`) : Se deve aplicar o mecanismo de OCR Tesseract para obter palavras + caixas delimitadoras normalizadas. Pode ser sobrescrito pelo parâmetro `apply_ocr` no método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : O idioma, especificado por seu código ISO, a ser usado pelo mecanismo de OCR Tesseract. Por padrão, o inglês é utilizado. Pode ser substituído pelo parâmetro `ocr_lang` no método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Quaisquer flags de configuração personalizadas adicionais que são encaminhadas para o parâmetro `config` ao chamar o Tesseract. Por exemplo: '--psm 6'. Pode ser substituído pelo parâmetro `tesseract_config` no método `preprocess`. Constrói um processador de imagem LayoutLMv2ImageProcessor. #### preprocess[[transformers.LayoutLMv2ImageProcessor.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_layoutlmv2.py#L131) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : 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*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : 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*) : 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. apply_ocr (`bool`, *kwargs*, *opcional*, padrão é `self.apply_ocr`) : Se deve aplicar o mecanismo de OCR Tesseract para obter palavras + caixas delimitadoras normalizadas. Pode ser sobrescrito pelo parâmetro `apply_ocr` no método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : O idioma, especificado por seu código ISO, a ser usado pelo mecanismo de OCR Tesseract. Por padrão, o inglês é utilizado. Pode ser substituído pelo parâmetro `ocr_lang` no método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Quaisquer flags de configuração personalizadas adicionais que são encaminhadas para o parâmetro `config` ao chamar o Tesseract. Por exemplo: '--psm 6'. Pode ser substituído pelo parâmetro `tesseract_config` no método `preprocess`. **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. ## LayoutLMv2ImageProcessorPil[[transformers.LayoutLMv2ImageProcessorPil]] #### transformers.LayoutLMv2ImageProcessorPil[[transformers.LayoutLMv2ImageProcessorPil]] ```python transformers.LayoutLMv2ImageProcessorPil(**kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_pil_layoutlmv2.py#L121) **Parâmetros:** do_convert_rgb (`bool`, *kwargs*, *opcional*) : 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' : 224, 'width': 224}`): 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 `2`) : 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*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*, padrão `None`) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : 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*) : 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. apply_ocr (`bool`, *kwargs*, *opcional*, padrão é `self.apply_ocr`) : Se deve aplicar o mecanismo de OCR Tesseract para obter palavras + caixas delimitadoras normalizadas. Pode ser sobrescrito pelo parâmetro `apply_ocr` no método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : O idioma, especificado por seu código ISO, a ser usado pelo mecanismo de OCR Tesseract. Por padrão, o inglês é utilizado. Pode ser substituído pelo parâmetro `ocr_lang` no método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Quaisquer flags de configuração personalizadas adicionais que são encaminhadas para o parâmetro `config` ao chamar o Tesseract. Por exemplo: '--psm 6'. Pode ser substituído pelo parâmetro `tesseract_config` no método `preprocess`. Constrói um processador de imagem LayoutLMv2ImageProcessor. #### preprocess[[transformers.LayoutLMv2ImageProcessorPil.preprocess]] ```python preprocess(images: typing.Union[ForwardRef('PIL.Image.Image'), numpy.ndarray, ForwardRef('torch.Tensor'), list['PIL.Image.Image'], list[numpy.ndarray], list['torch.Tensor']], **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/image_processing_pil_layoutlmv2.py#L134) **Parâmetros:** images (`Union[PIL.Image.Image, numpy.ndarray, torch.Tensor, list[PIL.Image.Image], list[numpy.ndarray], list[torch.Tensor]]`) : Imagem a ser pré-processada. Espera uma única imagem ou um lote de imagens com valores de pixel variando de 0 a 255. Se estiver passando imagens com valores de pixel entre 0 e 1, defina `do_rescale=False`. do_convert_rgb (`bool`, *kwargs*, *opcional*) : Se deve converter a imagem para RGB. do_resize (`bool`, *kwargs*, *opcional*) : Se deve redimensionar a imagem. size (`Annotated[int | list[int] | tuple[int, ...] | dict[str, int] | None, None]`, *kwargs*) : Descreve as dimensões máximas de entrada para o modelo. default_to_square (`bool`, *kwargs*, *opcional*) : 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*) : Filtro de redimensionamento a ser usado ao redimensionar a imagem. Pode ser um dos valores da enumeração `PILImageResampling`. Tem efeito apenas se `do_resize` estiver definido como `True`. do_rescale (`bool`, *kwargs*, *opcional*) : Se deve reescalar a imagem. rescale_factor (`float`, *kwargs*, *opcional*) : Fator de redimensionamento para redimensionar a imagem, caso `do_rescale` esteja definido como `True`. do_normalize (`bool`, *kwargs*, *opcional*) : Se a imagem deve ser normalizada. image_mean (`Union[float, list[float], tuple[float, ...]]`, *kwargs*, *opcional*) : 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*) : 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. apply_ocr (`bool`, *kwargs*, *opcional*, padrão é `self.apply_ocr`) : Se deve aplicar o mecanismo de OCR Tesseract para obter palavras + caixas delimitadoras normalizadas. Pode ser sobrescrito pelo parâmetro `apply_ocr` no método `preprocess`. ocr_lang (`str`, *kwargs*, *opcional*) : O idioma, especificado por seu código ISO, a ser usado pelo mecanismo de OCR Tesseract. Por padrão, o inglês é utilizado. Pode ser substituído pelo parâmetro `ocr_lang` no método `preprocess`. tesseract_config (`str`, *kwargs*, *opcional*) : Quaisquer flags de configuração personalizadas adicionais que são encaminhadas para o parâmetro `config` ao chamar o Tesseract. Por exemplo: '--psm 6'. Pode ser substituído pelo parâmetro `tesseract_config` no método `preprocess`. **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. ## LayoutLMv2Tokenizer[[transformers.LayoutLMv2Tokenizer]] #### transformers.LayoutLMv2Tokenizer[[transformers.LayoutLMv2Tokenizer]] ```python transformers.LayoutLMv2Tokenizer(vocab: str | dict[str, int] | None = None, do_lower_case = True, unk_token = '[UNK]', sep_token = '[SEP]', pad_token = '[PAD]', cls_token = '[CLS]', mask_token = '[MASK]', cls_token_box = [0, 0, 0, 0], sep_token_box = [1000, 1000, 1000, 1000], pad_token_box = [0, 0, 0, 0], pad_token_label = -100, only_label_first_subword = True, tokenize_chinese_chars = True, strip_accents = None, model_max_length = 512, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/tokenization_layoutlmv2.py#L112) **Parâmetros:** vocab_file (`str`) : Arquivo contendo o vocabulário. do_lower_case (`bool`, *opcional*, padrão `True`) : Indica se a entrada deve ser convertida para minúsculas durante a tokenização. 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. sep_token (`str`, *opcional*, padrão `"[SEP]"`) : 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 resposta a perguntas. Também é usado como o último token de uma sequência construída com tokens especiais. pad_token (`str`, *opcional*, padrão `"[PAD]"`) : O token usado para preenchimento, por exemplo, ao agrupar sequências de comprimentos diferentes. cls_token (`str`, *opcional*, padrão `"[CLS]"`) : O token de classificador usado ao realizar classificação de sequência (classificação da sequência inteira, em vez de classificação por token). É o primeiro token da sequência quando esta é construída com tokens especiais. mask_token (`str`, *opcional*, padrão `"[MASK]"`) : O token usado para mascarar valores. Este é o token utilizado ao treinar este modelo com modelagem de linguagem mascarada. É o token que o modelo tentará prever. cls_token_box (`List[int]`, *opcional*, padrão `[0, 0, 0, 0]`) : A caixa delimitadora a ser usada para o token especial [CLS]. 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 corresponde ao `ignore_index` do CrossEntropyLoss do PyTorch. only_label_first_subword (`bool`, *opcional*, padrão `True`) : Indica se apenas o primeiro subtoken deve ser rotulado, caso rótulos de palavras sejam fornecidos. tokenize_chinese_chars (`bool`, *opcional*, padrão `True`) : Se deve ou não tokenizar caracteres chineses. Isso provavelmente deve ser desativado para o japonês (veja [este problema](https://github.com/huggingface/transformers/issues/328)). strip_accents (`bool`, *opcional*) : Se deve ou não remover todos os acentos. Se essa opção não for especificada, ela será determinada pelo valor de `lowercase` (como no LayoutLMv2 original). Construa um tokenizador "rápido" do LayoutLMv2 (baseado na biblioteca *tokenizers* do HuggingFace). Baseado em WordPiece. Este tokenizer herda de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.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. #### __call__[[transformers.LayoutLMv2Tokenizer.__call__]] ```python __call__(text: str | list[str] | list[list[str]], text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy | None = None, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, padding_side: str | None = None, return_tensors: str | transformers.utils.generic.TensorType | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/tokenization_layoutlmv2.py#L243) **Parâmetros:** text (`str`, `List[str]`, `List[List[str]]`) : A sequência ou lote de sequências a ser codificada. Cada sequência pode ser uma string, uma lista de strings (palavras de um único exemplo ou perguntas de um lote de exemplos) ou uma lista de listas de strings (lote de palavras). text_pair (`List[str]`, `List[List[str]]`) : A sequência ou lote de sequências a ser codificada. Cada sequência deve ser uma lista de strings (string pretokenizada). boxes (`List[List[int]]`, `List[List[List[int]]]`) : Caixas delimitadoras no nível de palavra. Cada caixa delimitadora deve ser normalizada em uma escala de 0 a 1000. word_labels (`List[int]`, `List[List[int]]`, *opcional*) : Rótulos inteiros em nível de palavra (para tarefas de classificação de tokens, como FUNSD e CORD). add_special_tokens (`bool`, *opcional*, padrão `True`) : Se as sequências devem ser codificadas com os tokens especiais relativos ao seu modelo. padding (`bool`, `str` ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores: - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes). truncation (`bool`, `str` ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores: - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável para o modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível do modelo). max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado. stride (`int`, *opcional*, padrão 0) : Se definido como um número junto com `max_length`, os tokens excedentes retornados quando `return_overflowing_tokens=True` conterão alguns tokens do final da sequência truncada retornada, para fornecer alguma sobreposição entre as sequências truncada e excedente. O valor deste argumento define o número de tokens sobrepostos. pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Isso é especialmente útil para habilitar o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta). return_token_type_ids (`bool`, *opcional*) : Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são máscaras de atenção?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, padrão `False`) : Indica se as sequências de tokens que excedem o limite devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com `truncation_strategy = longest_first` ou `True`, um erro será lançado em vez de retornar os tokens excedentes. return_special_tokens_mask (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar informações da máscara de tokens especiais. return_offsets_mapping (`bool`, *opcional*, padrão `False`) : Indica se deve ou não retornar `(char_start, char_end)` para cada token. Isso está disponível apenas em tokenizadores rápidos que herdam de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador do Python, este método lançará `NotImplementedError`. return_length (`bool`, *opcional*, padrão `False`) : Indica se as comprimentos das entradas codificadas devem ser retornados. verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos. - ****kwargs** : passados para o método `self.tokenize()` Método principal para tokenizar e preparar para o modelo uma ou várias sequências ou um ou vários pares de sequências com caixas delimitadoras normalizadas em nível de palavra e rótulos opcionais. #### save_vocabulary[[transformers.LayoutLMv2Tokenizer.save_vocabulary]] ```python save_vocabulary(save_directory: str, filename_prefix: str | None = None) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_utils_tokenizers.py#L546) ## LayoutLMv2Processor[[transformers.LayoutLMv2Processor]] #### transformers.LayoutLMv2Processor[[transformers.LayoutLMv2Processor]] ```python transformers.LayoutLMv2Processor(image_processor = None, tokenizer = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/processing_layoutlmv2.py#L24) **Parâmetros:** image_processor (`LayoutLMv2ImageProcessor`) : O processador de imagem é uma entrada obrigatória. tokenizer (`LayoutLMv2Tokenizer`) : O tokenizer é uma entrada obrigatória. Constrói um LayoutLMv2Processor que encapsula um processador de imagem e um tokenizer em um único processador. [LayoutLMv2Processor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Processor) oferece todas as funcionalidades de [LayoutLMv2ImageProcessor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) e [LayoutLMv2Tokenizer](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer). Consulte [~LayoutLMv2ImageProcessor](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ImageProcessor) e [~LayoutLMv2Tokenizer](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Tokenizer) para mais informações. #### __call__[[transformers.LayoutLMv2Processor.__call__]] ```python __call__(images, text: str | list[str] | list[list[str]] = None, text_pair: list[str] | list[list[str]] | None = None, boxes: list[list[int]] | list[list[list[int]]] | None = None, word_labels: list[int] | list[list[int]] | None = None, add_special_tokens: bool = True, padding: bool | str | transformers.utils.generic.PaddingStrategy = False, truncation: bool | str | transformers.tokenization_utils_base.TruncationStrategy = False, max_length: int | None = None, stride: int = 0, pad_to_multiple_of: int | None = None, return_token_type_ids: bool | None = None, return_attention_mask: bool | None = None, return_overflowing_tokens: bool = False, return_special_tokens_mask: bool = False, return_offsets_mapping: bool = False, return_length: bool = False, verbose: bool = True, return_tensors: str | transformers.utils.generic.TensorType | None = None, **kwargs) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/processing_layoutlmv2.py#L28) **Parâmetros:** images (``) : Image to preprocess. Expects a single or batch of images with pixel values ranging from 0 to 255. If passing in images with pixel values between 0 and 1, set `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 pretokenizada). Se você passar uma entrada pretokenizada, defina `is_split_into_words=True` para evitar ambiguidade com entradas em lote. text_pair (`str, list[str] or list[int]`, *opcional*) : Sequência secundária opcional a ser codificada. Pode ser uma string, uma lista de strings (string tokenizada usando o método `tokenize`) ou uma lista de inteiros (ids de strings tokenizadas usando o método `convert_tokens_to_ids`). boxes (`list[list[int]] or list[list[list[int]]]`, *opcional*) : Caixas delimitadoras de nível de palavra. Cada caixa delimitadora deve ser normalizada em uma escala de 0 a 1000. word_labels (`list[int] or list[list[int]]`, *opcional*) : Rótulos inteiros em nível de palavra (para tarefas de classificação de tokens, como FUNSD e CORD). add_special_tokens (`bool`, *opcional*, padrão `True`) : Indica se tokens especiais devem ser adicionados ao codificar as sequências. Isso utiliza a função subjacente `PretrainedTokenizerBase.build_inputs_with_special_tokens`, que define quais tokens são adicionados automaticamente aos ids de entrada. Isso é útil se você deseja adicionar automaticamente tokens `bos` ou `eos`. padding (bool, str ou [PaddingStrategy](/docs/transformers/main/pt/internal/file_utils#transformers.utils.PaddingStrategy), *opcional*, padrão `False`) : Ativa e controla o padding. Aceita os seguintes valores: - `True` ou `'longest'`: Preenche até a sequência mais longa do lote (ou não aplica padding se apenas uma sequência for fornecida). - `'max_length'`: Preenche até o comprimento máximo especificado com o argumento `max_length` ou até o comprimento máximo aceitável de entrada para o modelo, caso esse argumento não seja fornecido. - `False` ou `'do_not_pad'` (padrão): Sem padding (ou seja, pode gerar um lote com sequências de comprimentos diferentes). truncation (bool, str ou [TruncationStrategy](/docs/transformers/main/pt/internal/tokenization_utils#transformers.tokenization_utils_base.TruncationStrategy), *opcional*, padrão `False`) : Ativa e controla a truncagem. Aceita os seguintes valores: - `True` ou `'longest_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável pelo modelo, caso esse argumento não seja fornecido. Isso trunca token por token, removendo um token da sequência mais longa do par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_first'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável pelo modelo, caso esse argumento não seja fornecido. Isso trunca apenas a primeira sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `'only_second'`: Trunca para um comprimento máximo especificado com o argumento `max_length` ou para o comprimento máximo de entrada aceitável pelo modelo, caso esse argumento não seja fornecido. Isso trunca apenas a segunda sequência de um par, se um par de sequências (ou um lote de pares) for fornecido. - `False` ou `'do_not_truncate'` (padrão): Sem truncagem (ou seja, pode gerar um lote com comprimentos de sequência maiores que o tamanho máximo de entrada admissível pelo modelo). max_length (`int`, *opcional*) : Controla o comprimento máximo a ser usado por um dos parâmetros de truncamento/preenchimento. Se não for definido ou for definido como `None`, será usado o comprimento máximo predefinido do modelo, caso um dos parâmetros de truncamento/preenchimento exija um comprimento máximo. Se o modelo não tiver um comprimento máximo de entrada específico (como o XLNet), o truncamento/preenchimento até um comprimento máximo será desativado. stride (`int`, *opcional*, padrão `0`) : Se definido como um número junto com `max_length`, os tokens excedentes retornados quando `return_overflowing_tokens=True` conterão alguns tokens do final da sequência truncada retornada, para fornecer alguma sobreposição entre as sequências truncada e excedente. O valor deste argumento define o número de tokens sobrepostos. pad_to_multiple_of (`int`, *opcional*) : Se definido, a sequência será preenchida até um múltiplo do valor fornecido. Exige que `padding` esteja ativado. Isso é especialmente útil para permitir o uso de Tensor Cores em hardware NVIDIA com capacidade de computação `>= 7.5` (Volta). return_token_type_ids (`bool`, *opcional*) : Se deve retornar os IDs de tipo de token. Se mantido no padrão, retornará os IDs de tipo de token de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são IDs de tipo de token?](../glossary#token-type-ids) return_attention_mask (`bool`, *opcional*) : Indica se a máscara de atenção deve ser retornada. Se mantido o valor padrão, a máscara de atenção será retornada de acordo com o padrão do tokenizer específico, definido pelo atributo `return_outputs`. [O que são máscaras de atenção?](../glossary#attention-mask) return_overflowing_tokens (`bool`, *opcional*, padrão `False`) : Indica se as sequências de tokens que excedem o limite devem ser retornadas. Se um par de sequências de ids de entrada (ou um lote de pares) for fornecido com `truncation_strategy = longest_first` ou `True`, um erro será lançado em vez de retornar os tokens excedentes. return_special_tokens_mask (`bool`, *opcional*, padrão `False`) : Se deve ou não retornar informações da máscara de tokens especiais. return_offsets_mapping (`bool`, *opcional*, padrão `False`) : Indica se deve ou não retornar `(char_start, char_end)` para cada token. Isso está disponível apenas em tokenizadores rápidos que herdam de [PreTrainedTokenizerFast](/docs/transformers/main/pt/main_classes/tokenizer#transformers.TokenizersBackend); se estiver usando o tokenizador do Python, este método lançará `NotImplementedError`. return_length (`bool`, *opcional*, padrão `False`) : Indica se os comprimentos das entradas codificadas devem ser retornados. verbose (`bool`, *opcional*, padrão `True`) : Se deve ou não exibir mais informações e avisos. return_tensors (`Union[str, ~utils.generic.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. **Retorna:** `~tokenization_utils_base.BatchEncoding` - **data** (`dict`, *opcional*) -- Dicionário de listas/arrays/tensors retornados pelos métodos `__call__`/`encode_plus`/`batch_encode_plus` ('input_ids', 'attention_mask', etc.). - **encoding** (`tokenizers.Encoding` ou `Sequence[tokenizers.Encoding]`, *opcional*) -- Se o tokenizer for um fast tokenizer que fornece informações adicionais, como o mapeamento do espaço de palavras/caracteres para o espaço de tokens, a instância de `tokenizers.Encoding` ou a lista de instâncias (para lotes) armazena essas informações. - **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. - **prepend_batch_axis** (`bool`, *opcional*, padrão `False`) -- Indica se deve ou não adicionar um eixo de lote ao converter para tensores (veja `tensor_type` acima). Observe que este parâmetro tem efeito se o parâmetro `tensor_type` estiver definido, *caso contrário, não tem efeito*. - **n_sequences** (`int`, *opcional*) -- O número de sequências de entrada representadas por cada codificação (`None` para desconhecido, `1` para uma única sequência e `2` para um par de sequências). ## LayoutLMv2Model[[transformers.LayoutLMv2Model]] #### transformers.LayoutLMv2Model[[transformers.LayoutLMv2Model]] ```python transformers.LayoutLMv2Model(config: LayoutLMv2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L551) **Parâmetros:** config ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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 Layoutlmv2 puro, que produz estados ocultos brutos sem nenhum cabeçalho 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.LayoutLMv2Model.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L663) **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) bbox (`torch.LongTensor` de forma `((batch_size, sequence_length), 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 na caixa delimitadora, e (x1, y1) representa a posição do canto inferior direito. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` cujo `tensors` é de forma `(batch_size, num_channels, height, width)`) : Lote de imagens de documentos. 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) token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas porções das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) 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) 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:** [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) ou `tuple(torch.Tensor)` Um [BaseModelOutputWithPooling](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.BaseModelOutputWithPooling) 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 ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) e das entradas. O método forward do [LayoutLMv2Model](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Model) 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. - **pooler_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação) após processamento adicional pelas camadas usadas para a tarefa de pré-treinamento auxiliar. Por exemplo, para modelos da família BERT, isso retorna o token de classificação após o processamento por uma camada linear e uma função de ativação tanh. Os pesos da camada linear são treinados a partir do objetivo de previsão da próxima frase (classificação) durante o pré-treinamento. - **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. Exemplos: ```python >>> from transformers import AutoProcessor, LayoutLMv2Model, set_seed >>> from PIL import Image >>> import torch >>> from datasets import load_dataset >>> set_seed(0) >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2Model.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa") >>> image = dataset["test"][0]["image"] >>> encoding = processor(image, return_tensors="pt") >>> outputs = model(**encoding) >>> last_hidden_states = outputs.last_hidden_state >>> last_hidden_states.shape torch.Size([1, 342, 768]) ``` ## LayoutLMv2ForSequenceClassification[[transformers.LayoutLMv2ForSequenceClassification]] #### transformers.LayoutLMv2ForSequenceClassification[[transformers.LayoutLMv2ForSequenceClassification]] ```python transformers.LayoutLMv2ForSequenceClassification(config: LayoutLMv2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L792) **Parâmetros:** config ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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. Modelo LayoutLMv2 com uma cabeça de classificação de sequência no topo (uma camada linear sobre a concatenação do estado oculto final do token [CLS], dos embeddings visuais iniciais com pooling médio e dos embeddings visuais finais com pooling médio, por exemplo, para tarefas de classificação de imagens de documentos, como o conjunto de dados [RVL-CDIP](https://www.cs.cmu.edu/~aharley/rvl-cdip/)). 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.LayoutLMv2ForSequenceClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L806) **Parâmetros:** input_ids (`torch.LongTensor` de forma `batch_size, sequence_length`) : Índices dos tokens da sequência de entrada no vocabulário. 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) bbox (`torch.LongTensor` de forma `(batch_size, sequence_length, 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 na caixa delimitadora e (x1, y1) representa a posição do canto inferior direito. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` cujo `tensors` é de forma `(batch_size, num_channels, height, width)`) : Lote de imagens de documentos. 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) token_type_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) 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.max_position_embeddings - 1]`. [O que são IDs de posição?](../glossary#position-ids) 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,)`, *opcional*) : Rótulos para o cálculo da perda de classificação/regressão de sequência. Os índices devem estar em `[0, ..., config.num_labels - 1]`. Se `config.num_labels == 1`, uma perda de regressão é calculada (perda de erro quadrático médio). Se `config.num_labels > 1`, uma perda de classificação é calculada (entropia cruzada). **Retorna:** [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) ou `tuple(torch.Tensor)` Um [SequenceClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) e das entradas. O método forward de [LayoutLMv2ForSequenceClassification](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ForSequenceClassification) 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. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação (ou de regressão se config.num_labels==1). - **logits** (`torch.Tensor` de forma `(batch_size, config.num_labels)`) -- Pontuações de classificação (ou regressão, se config.num_labels==1) (antes do SoftMax). - **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 >>> from transformers import AutoProcessor, LayoutLMv2ForSequenceClassification, set_seed >>> from PIL import Image >>> import torch >>> from datasets import load_dataset >>> set_seed(0) >>> dataset = load_dataset("aharley/rvl_cdip", split="train", streaming=True) >>> data = next(iter(dataset)) >>> image = data["image"].convert("RGB") >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2ForSequenceClassification.from_pretrained( ... "microsoft/layoutlmv2-base-uncased", num_labels=dataset.info.features["label"].num_classes ... ) >>> encoding = processor(image, return_tensors="pt") >>> sequence_label = torch.tensor([data["label"]]) >>> outputs = model(**encoding, labels=sequence_label) >>> loss, logits = outputs.loss, outputs.logits >>> predicted_idx = logits.argmax(dim=-1).item() >>> predicted_answer = dataset.info.features["label"].names[4] >>> predicted_idx, predicted_answer # results are not good without further fine-tuning (7, 'advertisement') ``` ## LayoutLMv2ForTokenClassification[[transformers.LayoutLMv2ForTokenClassification]] #### transformers.LayoutLMv2ForTokenClassification[[transformers.LayoutLMv2ForTokenClassification]] ```python transformers.LayoutLMv2ForTokenClassification(config: LayoutLMv2Config) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L986) **Parâmetros:** config ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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. Modelo LayoutLMv2 com uma cabeça de classificação de tokens no topo (uma camada linear sobre a parte de texto dos estados ocultos), por exemplo, para tarefas de rotulagem de sequência (extração de informações) como [FUNSD](https://guillaumejaume.github.io/FUNSD/), [SROIE](https://rrc.cvc.uab.es/?ch=13), [CORD](https://github.com/clovaai/cord) e [Kleister-NDA](https://github.com/applicaai/kleister-nda). 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.LayoutLMv2ForTokenClassification.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1000) **Parâmetros:** input_ids (`torch.LongTensor` de forma `batch_size, sequence_length`) : Índices dos tokens da sequência de entrada no vocabulário. 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) bbox (`torch.LongTensor` de forma `(batch_size, sequence_length, 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 na caixa delimitadora e (x1, y1) representa a posição do canto inferior direito. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` cujo `tensors` é de forma `(batch_size, num_channels, height, width)`) : Lote de imagens de documentos. 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) token_type_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) 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.max_position_embeddings - 1]`. [O que são IDs de posição?](../glossary#position-ids) 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 classificação de tokens. Os índices devem estar em `[0, ..., config.num_labels - 1]`. **Retorna:** [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) ou `tuple(torch.Tensor)` Um [TokenClassifierOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) e das entradas. O método forward de [LayoutLMv2ForTokenClassification](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ForTokenClassification) 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. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecido) -- Perda de classificação. - **logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.num_labels)`) -- Pontuações de classificação (antes do SoftMax). - **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 >>> from transformers import AutoProcessor, LayoutLMv2ForTokenClassification, set_seed >>> from PIL import Image >>> from datasets import load_dataset >>> set_seed(0) >>> datasets = load_dataset("nielsr/funsd", split="test") >>> labels = datasets.features["ner_tags"].feature.names >>> id2label = {v: k for v, k in enumerate(labels)} >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased", revision="no_ocr") >>> model = LayoutLMv2ForTokenClassification.from_pretrained( ... "microsoft/layoutlmv2-base-uncased", num_labels=len(labels) ... ) >>> data = datasets[0] >>> image = Image.open(data["image_path"]).convert("RGB") >>> words = data["words"] >>> boxes = data["bboxes"] # make sure to normalize your bounding boxes >>> word_labels = data["ner_tags"] >>> encoding = processor( ... image, ... words, ... boxes=boxes, ... word_labels=word_labels, ... padding="max_length", ... truncation=True, ... return_tensors="pt", ... ) >>> outputs = model(**encoding) >>> logits, loss = outputs.logits, outputs.loss >>> predicted_token_class_ids = logits.argmax(-1) >>> predicted_tokens_classes = [id2label[t.item()] for t in predicted_token_class_ids[0]] >>> predicted_tokens_classes[:5] # results are not good without further fine-tuning ['I-HEADER', 'I-HEADER', 'I-QUESTION', 'I-HEADER', 'I-QUESTION'] ``` ## LayoutLMv2ForQuestionAnswering[[transformers.LayoutLMv2ForQuestionAnswering]] #### transformers.LayoutLMv2ForQuestionAnswering[[transformers.LayoutLMv2ForQuestionAnswering]] ```python transformers.LayoutLMv2ForQuestionAnswering(config: LayoutLMv2Config, has_visual_segment_embedding = True) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1121) **Parâmetros:** config ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) : 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. has_visual_segment_embedding (`bool`, *opcional*, padrão `True`) : Indica se deve ou não adicionar embeddings de segmentos visuais. O transformer Layoutlmv2 com uma cabeça de classificação de spans no topo para tarefas de resposta a perguntas extrativas, como SQuAD (uma camada linear no topo da saída dos hidden-states para calcular `span start logits` e `span end logits`). 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.LayoutLMv2ForQuestionAnswering.forward]] ```python forward(input_ids: typing.Optional[torch.LongTensor] = None, bbox: typing.Optional[torch.LongTensor] = None, image: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, position_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.LongTensor] = None, end_positions: typing.Optional[torch.LongTensor] = None, **kwargs: *) ``` [Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/layoutlmv2/modeling_layoutlmv2.py#L1139) **Parâmetros:** input_ids (`torch.LongTensor` de forma `batch_size, sequence_length`) : Índices dos tokens da sequência de entrada no vocabulário. 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) bbox (`torch.LongTensor` de forma `(batch_size, sequence_length, 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 na caixa delimitadora e (x1, y1) representa a posição do canto inferior direito. image (`torch.Tensor` de forma `(batch_size, num_channels, height, width)` ou `detectron.structures.ImageList` cujo `tensors` é de forma `(batch_size, num_channels, height, width)`) : Lote de imagens de documentos. 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) token_type_ids (`torch.LongTensor` de forma `batch_size, sequence_length`, *opcional*) : Índices de tokens de segmento para indicar as primeiras e segundas partes das entradas. Os índices são selecionados em `[0, 1]`: - 0 corresponde a um token de *frase A*, - 1 corresponde a um token de *frase B*. [O que são IDs de tipo de token?](../glossary#token-type-ids) 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.max_position_embeddings - 1]`. [O que são IDs de posição?](../glossary#position-ids) 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. start_positions (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do início do trecho rotulado para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda. end_positions (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para a posição (índice) do final do trecho rotulado, para o cálculo da perda de classificação de tokens. As posições são limitadas ao comprimento da sequência (`sequence_length`). Posições fora da sequência não são consideradas no cálculo da perda. **Retorna:** [QuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) ou `tuple(torch.Tensor)` Um [QuestionAnsweringModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 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 ([LayoutLMv2Config](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2Config)) e das entradas. O método forward de [LayoutLMv2ForQuestionAnswering](/docs/transformers/main/pt/model_doc/layoutlmv2#transformers.LayoutLMv2ForQuestionAnswering) 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. - **loss** (`torch.Tensor` de forma `(1,)`, *opcional*, retornado quando `labels` é fornecida) -- A perda total de extração de spans é a soma de uma Cross-Entropy para as posições de início e fim. - **start_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Pontuações de início de span (antes do SoftMax). - **end_logits** (`torch.Tensor` de forma `(batch_size, sequence_length)`) -- Pontuações de fim de span (antes do SoftMax). - **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: Neste exemplo abaixo, fornecemos ao modelo LayoutLMv2 uma imagem (de textos) e fazemos uma pergunta. Ele nos fornecerá uma previsão do que ele acredita ser a resposta (o trecho da resposta dentro dos textos extraídos da imagem). ```python >>> from transformers import AutoProcessor, LayoutLMv2ForQuestionAnswering, set_seed >>> import torch >>> from PIL import Image >>> from datasets import load_dataset >>> set_seed(0) >>> processor = AutoProcessor.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> model = LayoutLMv2ForQuestionAnswering.from_pretrained("microsoft/layoutlmv2-base-uncased") >>> dataset = load_dataset("hf-internal-testing/fixtures_docvqa") >>> image = dataset["test"][0]["image"] >>> question = "When is coffee break?" >>> encoding = processor(image, question, return_tensors="pt") >>> outputs = model(**encoding) >>> predicted_start_idx = outputs.start_logits.argmax(-1).item() >>> predicted_end_idx = outputs.end_logits.argmax(-1).item() >>> predicted_start_idx, predicted_end_idx (30, 191) >>> predicted_answer_tokens = encoding.input_ids.squeeze()[predicted_start_idx : predicted_end_idx + 1] >>> predicted_answer = processor.tokenizer.decode(predicted_answer_tokens) >>> predicted_answer # results are not good without further fine-tuning '44 a. m. to 12 : 25 p. m. 12 : 25 to 12 : 58 p. m. 12 : 58 to 4 : 00 p. m. 2 : 00 to 5 : 00 p. m. coffee break coffee will be served for men and women in the lobby adjacent to exhibit area. please move into exhibit area. ( exhibits open ) trrf general session ( part | ) presiding : lee a. waller trrf vice president " introductory remarks " lee a. waller, trrf vice presi - dent individual interviews with trrf public board members and sci - entific advisory council mem - bers conducted by trrf treasurer philip g. kuehn to get answers which the public refrigerated warehousing industry is looking for. plus questions from' ``` ```python >>> target_start_index = torch.tensor([7]) >>> target_end_index = torch.tensor([14]) >>> outputs = model(**encoding, start_positions=target_start_index, end_positions=target_end_index) >>> predicted_answer_span_start = outputs.start_logits.argmax(-1).item() >>> predicted_answer_span_end = outputs.end_logits.argmax(-1).item() >>> predicted_answer_span_start, predicted_answer_span_end (30, 191) ```