# LXMERT

## Visão geral

O modelo LXMERT foi proposto em [LXMERT: Learning Cross-Modality Encoder Representations from Transformers](https://huggingface.co/papers/1908.07490) por Hao Tan & Mohit Bansal. Trata-se de uma série de codificadores transformer bidirecionais (um para a modalidade visual, um para a modalidade linguística e, em seguida, um para fundir ambas as modalidades) pré-treinados usando uma combinação de modelagem de linguagem mascarada, alinhamento de texto visual-linguístico, regressão de recursos ROI, modelagem de atributos visuais mascarados, modelagem de objetos visuais mascarados e objetivos de resposta a perguntas visuais. O pré-treinamento consiste em vários conjuntos de dados multimodais: MSCOCO, Visual-Genome + Visual-Genome Question Answering, VQA 2.0 e GQA.

O resumo do artigo é o seguinte:

*O raciocínio entre visão e linguagem requer a compreensão de conceitos visuais, semântica da linguagem e, mais importante, o alinhamento e as relações entre essas duas modalidades. Assim, propomos o framework LXMERT (Learning Cross-Modality Encoder Representations from Transformers) para aprender essas conexões entre visão e linguagem. No LXMERT, construímos um modelo Transformer de grande escala que consiste em três codificadores: um codificador de relações de objetos, um codificador de linguagem e um codificador de multimodalidade. Em seguida, para dotar nosso modelo da capacidade de conectar a semântica da visão e da linguagem, pré-treinamos o modelo com grandes quantidades de pares de imagem e sentença, por meio de cinco tarefas de pré-treinamento diversas e representativas: modelagem de linguagem mascarada, previsão de objetos mascarados (regressão de recursos e classificação de rótulos), correspondência entre modalidades e resposta a perguntas sobre imagens. Essas tarefas auxiliam no aprendizado tanto das relações intra-modalidade quanto das relações entre modalidades. Após o ajuste fino a partir dos nossos parâmetros pré-treinados, nosso modelo alcança resultados de estado da arte em dois conjuntos de dados de resposta a perguntas visuais (ou seja, VQA e GQA). Também demonstramos a generalizabilidade do nosso modelo de multimodalidade pré-treinado ao adaptá-lo a uma tarefa desafiadora de raciocínio visual, NLVR, e melhorar o melhor resultado anterior em 22% absoluto (de 54% para 76%). Por fim, demonstramos estudos de ablação detalhados para provar que tanto os nossos novos componentes do modelo quanto as estratégias de pré-treinamento contribuem significativamente para os nossos fortes resultados; e também apresentamos várias visualizações de atenção para os diferentes codificadores*

Este modelo foi contribuído por [eltoto1219](https://huggingface.co/eltoto1219). O código original pode ser encontrado [aqui](https://github.com/airsplay/lxmert).

## Dicas de uso

- Bounding boxes não são necessários para serem usados nos embeddings de recursos visuais; qualquer tipo de recurso visual-espacial funcionará.
- Os estados ocultos de linguagem e os estados ocultos visuais que o LXMERT produz são passados pela camada de multimodalidade cruzada, portanto, contêm informações de ambas as modalidades. Para acessar uma modalidade que atende apenas a si mesma, selecione os estados ocultos de visão/linguagem da primeira entrada da tupla.
- A atenção do codificador bidirecional de cross-modality retorna valores de atenção apenas quando a modalidade de linguagem é usada como entrada e a modalidade de visão é usada como vetor de contexto. Além disso, embora o codificador de cross-modality contenha autoatenção para cada modalidade respectiva e cross-atenção, apenas a cross-atenção é retornada e as duas saídas de autoatenção são descartadas.

## Recursos

- [Guia da tarefa de resposta a perguntas](../tasks/question_answering)

## LxmertConfig[[transformers.LxmertConfig]]

#### transformers.LxmertConfig[[transformers.LxmertConfig]]

```python
transformers.LxmertConfig(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_attention_heads: int = 12, num_qa_labels: int = 9500, num_object_labels: int = 1600, num_attr_labels: int = 400, 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, l_layers: int = 9, x_layers: int = 5, r_layers: int = 5, visual_feat_dim: int = 2048, visual_pos_dim: int = 4, visual_loss_normalizer: float = 6.67, task_matched: bool = True, task_mask_lm: bool = True, task_obj_predict: bool = True, task_qa: bool = True, visual_obj_loss: bool = True, visual_attr_loss: bool = True, visual_feat_loss: bool = True, pad_token_id: int | None = None, bos_token_id: int | None = None, eos_token_id: int | list[int] | None = None, tie_word_embeddings: bool = True)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/configuration_lxmert.py#L24)

**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_attention_heads (`int`, *opcional*, padrão `12`) : Número de cabeças de atenção para cada camada de atenção no decodificador do Transformer.

num_qa_labels (`int`, *opcional*, padrão 9500) : Representa o número total de rótulos diferentes de question answering (QA). Ao usar mais de um conjunto de dados com QA, o usuário deverá considerar o número total de rótulos presentes em todos os conjuntos de dados.

num_object_labels (`int`, *opcional*, padrão 1600) : Representa o número total de objetos semanticamente únicos para os quais o lxmert poderá classificar um recurso de objeto agregado como pertencente.

num_attr_labels (`int`, *opcional*, padrão 400) : Representa o número total de atributos semanticamente únicos que o lxmert poderá classificar como possuídos por um recurso de objeto agregado.

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.

l_layers (`int`, *opcional*, padrão 9) : Número de camadas ocultas no codificador de linguagem Transformer.

x_layers (`int`, *opcional*, padrão 5) : Número de camadas ocultas no codificador de modalidade cruzada do Transformer.

r_layers (`int`, *opcional*, padrão 5) : Número de camadas ocultas no codificador visual do Transformer.

visual_feat_dim (`int`, *opcional*, padrão 2048) : Representa a última dimensão dos recursos de objetos agregados usados como entrada para o modelo, indicando o tamanho de cada recurso de objeto.

visual_pos_dim (`int`, *opcional*, padrão 4) : Representa o número de características espaciais que são combinadas com as características visuais. O padrão é definido como 4, pois, na maioria dos casos, isso representa a localização de uma caixa delimitadora. Ou seja, (x, y, largura, altura)

visual_loss_normalizer (`float`, *opcional*, padrão 6.67) : Representa o fator de escala pelo qual cada perda visual é multiplicada, caso, durante o pré-treino, tenha-se decidido treinar com múltiplos objetivos de perda baseados em visão.

task_matched (`bool`, *opcional*, padrão `True`) : Esta tarefa é usada para correspondência entre sentença e imagem. Se a sentença descreve corretamente a imagem, o rótulo será 1. Se a sentença não descreve corretamente a imagem, o rótulo será 0.

task_mask_lm (`bool`, *opcional*, padrão `True`) : Indica se deve ou não adicionar modelagem de linguagem mascarada (usada em modelos de pré-treinamento, como o BERT) ao objetivo de perda.

task_obj_predict (`bool`, *opcional*, padrão `True`) : Indica se a previsão de objetos, a previsão de atributos e a regressão de recursos devem ser adicionadas ao objetivo de perda.

task_qa (`bool`, *opcional*, padrão `True`) : Se deve ou não adicionar a perda de resposta a perguntas ao objetivo

visual_obj_loss (`bool`, *opcional*, padrão `True`) : Se deve ou não calcular a função de perda de previsão de objeto

visual_attr_loss (`bool`, *opcional*, padrão `True`) : Se deve ou não calcular a função de perda de predição de atributos

visual_feat_loss (`bool`, *opcional*, padrão `True`) : Se deve ou não calcular o objetivo de perda de regressão de características

pad_token_id (`int`, *opcional*) : ID do token usado para preenchimento (padding) no vocabulário.

bos_token_id (`int`, *opcional*) : ID do token usado para o início do fluxo no vocabulário.

eos_token_id (`Union[int, list[int]]`, *opcional*) : ID do token usado para o fim do fluxo no vocabulário.

tie_word_embeddings (`bool`, *opcional*, padrão `True`) : Se deve vincular as embeddings de pesos de acordo com o mapeamento `tied_weights_keys` do modelo.

Esta é a classe de configuração para armazenar a configuração de um LxmertModel. Ela é usada para instanciar um modelo Lxmert 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 [unc-nlp/lxmert-base-uncased](https://huggingface.co/unc-nlp/lxmert-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.

## LxmertTokenizer[[transformers.BertTokenizer]]

#### transformers.BertTokenizer[[transformers.BertTokenizer]]

```python
transformers.BertTokenizer(vocab: str | dict[str, int] | None = None, do_lower_case: bool = True, unk_token: str = '[UNK]', sep_token: str = '[SEP]', pad_token: str = '[PAD]', cls_token: str = '[CLS]', mask_token: str = '[MASK]', tokenize_chinese_chars: bool = True, strip_accents: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/bert/tokenization_bert.py#L41)

**Parâmetros:**

vocab (`str` ou `dict[str, int]`, *opcional*) : Dicionário de vocabulário personalizado. Se não for fornecido, o vocabulário é carregado a partir de `vocab_file`.

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.

tokenize_chinese_chars (`bool`, *opcional*, padrão `True`) : Se deve ou não tokenizar caracteres chineses.

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

Construa um tokenizador BERT (baseado na biblioteca tokenizers da HuggingFace). Baseado em WordPiece.

Este tokenizer herda de [TokenizersBackend](/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.

## Saídas específicas do Lxmert[[transformers.models.lxmert.modeling_lxmert.LxmertModelOutput]]

#### transformers.models.lxmert.modeling_lxmert.LxmertModelOutput[[transformers.models.lxmert.modeling_lxmert.LxmertModelOutput]]

```python
transformers.models.lxmert.modeling_lxmert.LxmertModelOutput(language_output: typing.Optional[torch.Tensor] = None, vision_output: typing.Optional[torch.Tensor] = None, pooled_output: typing.Optional[torch.Tensor] = None, language_hidden_states: tuple[torch.Tensor] | None = None, vision_hidden_states: tuple[torch.Tensor] | None = None, language_attentions: tuple[torch.Tensor] | None = None, vision_attentions: tuple[torch.Tensor] | None = None, cross_encoder_attentions: tuple[torch.Tensor] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L49)

**Parâmetros:**

language_output (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Sequência de estados ocultos na saída da última camada do codificador de linguagem.

vision_output (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Sequência de estados ocultos na saída da última camada do codificador visual.

pooled_output (`torch.Tensor` de forma `(batch_size, hidden_size)`) : Estado oculto da última camada do primeiro token da sequência (classificação, CLS, token), processado adicionalmente por uma camada Linear e uma função de ativação Tanh. O Linear

language_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.

vision_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.

language_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

vision_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

cross_encoder_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

As saídas do Lxmert que contêm os últimos estados ocultos, as saídas agregadas e as probabilidades de atenção para os codificadores de linguagem, visual e de multimodalidade cruzada. (observação: o codificador visual no Lxmert é referido como o codificador de "relação")

#### transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput[[transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput]]

```python
transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput(loss: typing.Optional[torch.Tensor] = None, prediction_logits: typing.Optional[torch.Tensor] = None, cross_relationship_score: typing.Optional[torch.Tensor] = None, question_answering_score: typing.Optional[torch.Tensor] = None, language_hidden_states: tuple[torch.Tensor] | None = None, vision_hidden_states: tuple[torch.Tensor] | None = None, language_attentions: tuple[torch.Tensor] | None = None, vision_attentions: tuple[torch.Tensor] | None = None, cross_encoder_attentions: tuple[torch.Tensor] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L136)

**Parâmetros:**

loss (`*optional*`, retornado quando `labels` é fornecido, `torch.Tensor` de forma `(1,)`) : Perda total como a soma da perda de modelagem de linguagem mascarada e da perda de previsão da próxima sequência (classificação).

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

cross_relationship_score (`torch.Tensor` de forma `(batch_size, 2)`) : Pontuações de previsão do objetivo de correspondência textual (cabeça de classificação) (pontuações de continuação Verdadeiro/Falso antes do SoftMax).

question_answering_score (`torch.Tensor` de forma `(batch_size, n_qa_answers)`) : Pontuações de previsão do objetivo de question answering (classificação).

language_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.

vision_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.

language_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

vision_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

cross_encoder_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Tipo de saída de [LxmertForPreTraining](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertForPreTraining).

#### transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput[[transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput]]

```python
transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, question_answering_score: typing.Optional[torch.Tensor] = None, language_hidden_states: tuple[torch.Tensor] | None = None, vision_hidden_states: tuple[torch.Tensor] | None = None, language_attentions: tuple[torch.Tensor] | None = None, vision_attentions: tuple[torch.Tensor] | None = None, cross_encoder_attentions: tuple[torch.Tensor] | None = None)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L94)

**Parâmetros:**

loss (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) : Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss.k.

question_answering_score (`torch.Tensor` de forma `(batch_size, n_qa_answers)`, *opcional*) : Pontuações de previsão do objetivo de resposta a perguntas (classificação).

language_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.

vision_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.

language_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

vision_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

cross_encoder_attentions (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) : Tupla de `torch.Tensor` (um para cada camada) com a forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos das atenções após o softmax de atenção, usados para calcular a média ponderada nos cabeçalhos de autoatenção.

Tipo de saída de [LxmertForQuestionAnswering](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertForQuestionAnswering).

## LxmertModel[[transformers.LxmertModel]]

#### transformers.LxmertModel[[transformers.LxmertModel]]

```python
transformers.LxmertModel(config: LxmertConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L675)

**Parâmetros:**

config ([LxmertConfig](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertConfig)) : 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 Lxmert 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.LxmertModel.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, visual_feats: typing.Optional[torch.Tensor] = None, visual_pos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, visual_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L690)

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

visual_feats (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_feat_dim)`) : Esta entrada representa recursos visuais. São recursos de objetos obtidos por ROI pooling a partir de caixas delimitadoras, usando um modelo faster-RCNN) Atualmente, a biblioteca transformers não fornece esses recursos.

visual_pos (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_pos_dim)`) : Esta entrada representa recursos espaciais correspondentes aos seus recursos visuais relativos (via índice). O modelo LXMERT pré-treinado espera que esses recursos espaciais sejam caixas delimitadoras normalizadas em uma escala de 0 a 1. Atualmente, a biblioteca transformers não fornece esses recursos.

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)

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

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.

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [LxmertModelOutput](/docs/transformers/main/pt/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) ou `tuple(torch.Tensor)`

Um [LxmertModelOutput](/docs/transformers/main/pt/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) 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 ([LxmertConfig](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertConfig)) e das entradas.

O método forward do [LxmertModel](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertModel) 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.

- **language_output** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de hidden-states na saída da última camada do codificador de linguagem.
- **vision_output** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Sequência de hidden-states na saída da última camada do codificador visual.
- **pooled_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto da última camada do primeiro token da sequência (token de classificação, CLS) processado adicionalmente por uma camada Linear e uma função de ativação Tanh. A camada Linear
- **language_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.
- **vision_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.
- **language_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 nos cabeçalhos de autoatenção.
- **vision_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 nos cabeçalhos de autoatenção.
- **cross_encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com 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 nos cabeçalhos de autoatenção.

## LxmertForPreTraining[[transformers.LxmertForPreTraining]]

#### transformers.LxmertForPreTraining[[transformers.LxmertForPreTraining]]

```python
transformers.LxmertForPreTraining(config: LxmertConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L826)

**Parâmetros:**

config ([LxmertConfig](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertConfig)) : 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 Lxmert com uma cabeça de pré-treino especificada 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.LxmertForPreTraining.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, visual_feats: typing.Optional[torch.Tensor] = None, visual_pos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, visual_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.LongTensor] = None, obj_labels: dict[str, tuple[torch.Tensor, torch.Tensor]] | None = None, matched_label: typing.Optional[torch.LongTensor] = None, ans: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L976)

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

visual_feats (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_feat_dim)`) : Esta entrada representa recursos visuais. São recursos de objetos obtidos por ROI pooling a partir de caixas delimitadoras, usando um modelo faster-RCNN) Atualmente, a biblioteca transformers não fornece esses recursos.

visual_pos (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_pos_dim)`) : Esta entrada representa recursos espaciais correspondentes aos seus recursos visuais relativos (via índice). O modelo LXMERT pré-treinado espera que esses recursos espaciais sejam caixas delimitadoras normalizadas em uma escala de 0 a 1. Atualmente, a biblioteca transformers não fornece esses recursos.

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)

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

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, em vez de passar `input_ids`, você pode escolher passar diretamente uma representação incorporada. Isso é útil se você quiser ter mais controle sobre como converter os índices de `input_ids` nos vetores associados do que a matriz de busca de incorporação interna do modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Rótulos para calcular a perda de modelagem de linguagem mascarada. Os índices devem estar em `[-100, 0, ..., config.vocab_size]` (veja a docstring de `input_ids`). Tokens com índices definidos como `-100` são ignorados (mascarados); a perda é calculada apenas para os tokens com rótulos em `[0, ..., config.vocab_size]`

obj_labels (`dict[Str : tuple[torch.Tensor, torch.Tensor]]`, *opcional*): cada chave é nomeada de acordo com cada uma das perdas visuais e cada elemento da tupla tem a forma `(batch_size, num_features)` e `(batch_size, num_features, visual_feature_dim)` para o id do rótulo e a pontuação do rótulo, respectivamente

matched_label (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Rótulos para calcular a perda de classificação de correspondência entre o texto de entrada e a imagem. A entrada deve ser um par de sequências (veja a docstring de `input_ids`). Os índices devem estar em `[0, 1]`: - 0 indica que a frase não corresponde à imagem, - 1 indica que a frase corresponde à imagem.

ans (`Torch.Tensor` de forma `(batch_size)`, *opcional*) : uma representação one hot da resposta correta *opcional*

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [LxmertForPreTrainingOutput](/docs/transformers/main/pt/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) ou `tuple(torch.Tensor)`

Um [LxmertForPreTrainingOutput](/docs/transformers/main/pt/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) 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 ([LxmertConfig](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertConfig)) e das entradas.

O método forward de [LxmertForPreTraining](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertForPreTraining) 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** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Perda total como a soma da perda de modelagem de linguagem mascarada e da perda de previsão da próxima sequência (classificação).
- **prediction_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Pontuações de previsão da cabeça de modelagem de linguagem (pontuações para cada token do vocabulário antes do SoftMax).
- **cross_relationship_score** (`torch.Tensor` de forma `(batch_size, 2)`) -- Pontuações de previsão do objetivo de correspondência textual (cabeça de classificação) (pontuações de continuação Verdadeiro/Falso antes do SoftMax).
- **question_answering_score** (`torch.Tensor` de forma `(batch_size, n_qa_answers)`) -- Pontuações de previsão do objetivo de question answering (classificação).
- **language_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.
- **vision_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.
- **language_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 nos cabeçalhos de autoatenção.
- **vision_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 nos cabeçalhos de autoatenção.
- **cross_encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com 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 nos cabeçalhos de autoatenção.

Exemplo:

```python
```

## LxmertForQuestionAnswering[[transformers.LxmertForQuestionAnswering]]

#### transformers.LxmertForQuestionAnswering[[transformers.LxmertForQuestionAnswering]]

```python
transformers.LxmertForQuestionAnswering(config: LxmertConfig)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L1123)

**Parâmetros:**

config ([LxmertConfig](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertConfig)) : 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 Lxmert com uma cabeça de resposta visual no topo para tarefas de QA de nível inferior

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.LxmertForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.LongTensor] = None, visual_feats: typing.Optional[torch.Tensor] = None, visual_pos: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, visual_attention_mask: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.LongTensor] = None, inputs_embeds: typing.Optional[torch.Tensor] = None, labels: typing.Optional[torch.Tensor] = None, output_attentions: bool | None = None, output_hidden_states: bool | None = None, return_dict: bool | None = None, **kwargs)
```

[Origem](https://github.com/huggingface/transformers/blob/main/src/transformers/models/lxmert/modeling_lxmert.py#L1215)

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

visual_feats (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_feat_dim)`) : Esta entrada representa recursos visuais. São recursos de objetos obtidos por ROI pooling a partir de caixas delimitadoras, usando um modelo faster-RCNN) Atualmente, a biblioteca transformers não fornece esses recursos.

visual_pos (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_pos_dim)`) : Esta entrada representa recursos espaciais correspondentes aos seus recursos visuais relativos (via índice). O modelo LXMERT pré-treinado espera que esses recursos espaciais sejam caixas delimitadoras normalizadas em uma escala de 0 a 1. Atualmente, a biblioteca transformers não fornece esses recursos.

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)

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

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.Tensor` de forma `(batch_size)`, *opcional*) : Uma representação one-hot da resposta correta

output_attentions (`bool`, *opcional*) : Indica se os tensores de atenção de todas as camadas de atenção devem ser retornados. Consulte `attentions` nos tensores retornados para mais detalhes.

output_hidden_states (`bool`, *opcional*) : Indica se os estados ocultos de todas as camadas devem ser retornados. Consulte `hidden_states` em tensores retornados para mais detalhes.

return_dict (`bool`, *opcional*) : Se deve ou não retornar um [ModelOutput](/docs/transformers/main/pt/main_classes/output#transformers.utils.ModelOutput) em vez de uma tupla simples.

**Retorna:** [LxmertForQuestionAnsweringOutput](/docs/transformers/main/pt/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) ou `tuple(torch.Tensor)`

Um [LxmertForQuestionAnsweringOutput](/docs/transformers/main/pt/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) 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 ([LxmertConfig](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertConfig)) e das entradas.

O método forward de [LxmertForQuestionAnswering](/docs/transformers/main/pt/model_doc/lxmert#transformers.LxmertForQuestionAnswering) 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** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Total loss as the sum of the masked language modeling loss and the next sequence prediction (classification) loss.k.
- **question_answering_score** (`torch.Tensor` de forma `(batch_size, n_qa_answers)`, *opcional*) -- Pontuações de previsão do objetivo de question answering (classificação).
- **language_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.
- **vision_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 os recursos de entrada + um para a saída de cada camada de multimodalidade cruzada) com forma `(batch_size, sequence_length, hidden_size)`.
- **language_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 nos cabeçalhos de autoatenção.
- **vision_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 nos cabeçalhos de autoatenção.
- **cross_encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, retornado quando `output_attentions=True` é passado ou quando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (um para cada camada) com 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 nos cabeçalhos de autoatenção.

Exemplo:

```python
>>> from transformers import AutoTokenizer, LxmertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("unc-nlp/lxmert-base-uncased")
>>> model = LxmertForQuestionAnswering.from_pretrained("unc-nlp/lxmert-base-uncased")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
...
```