# LXMERT

## Resumen

El modelo LXMERT fue propuesto en [LXMERT: Learning Cross-Modality Encoder Representations from Transformers](https://huggingface.co/papers/1908.07490) por Hao Tan & Mohit Bansal. Se trata de una serie de codificadores transformer bidireccionales (uno para la modalidad visual, uno para la modalidad lingüística y luego uno para fusionar ambas modalidades) preentrenados mediante una combinación de objetivos de modelado de lenguaje enmascarado, alineación de texto visual-lingüístico, regresión de características ROI, modelado de atributos visuales enmascarados, modelado de objetos visuales enmascarados y respuesta a preguntas visuales. El preentrenamiento consta de varios conjuntos de datos multimodales: MSCOCO, Visual-Genome + Visual-Genome Question Answering, VQA 2.0 y GQA.

El resumen del artículo es el siguiente:

*El razonamiento visual-lingüístico requiere comprender los conceptos visuales, la semántica del lenguaje y, lo más importante, la alineación y las relaciones entre estas dos modalidades. Por lo tanto, proponemos el marco LXMERT (Learning Cross-Modality Encoder Representations from Transformers) para aprender estas conexiones visuales y lingüísticas. En LXMERT, construimos un modelo Transformer a gran escala que consta de tres codificadores: un codificador de relaciones de objetos, un codificador de lenguaje y un codificador de multimodalidad. A continuación, para dotar a nuestro modelo de la capacidad de conectar la semántica visual y lingüística, preentrenamos el modelo con grandes cantidades de pares de imagen y oración, mediante cinco tareas de preentrenamiento diversas y representativas: modelado de lenguaje enmascarado, predicción de objetos enmascarados (regresión de características y clasificación de etiquetas), correspondencia entre modalidades y respuesta a preguntas sobre imágenes. Estas tareas ayudan a aprender tanto las relaciones intra-modalidad como las intermodalidad. Después de ajustar a partir de nuestros parámetros preentrenados, nuestro modelo logra resultados de última generación en dos conjuntos de datos de respuesta a preguntas visuales (es decir, VQA y GQA). También demostramos la generalizabilidad de nuestro modelo de multimodalidad preentrenado adaptándolo a una tarea de razonamiento visual desafiante, NLVR, y mejoramos el mejor resultado anterior en un 22% absoluto (del 54% al 76%). Por último, presentamos estudios de ablación detallados para demostrar que tanto nuestros nuevos componentes del modelo como las estrategias de preentrenación contribuyen significativamente a nuestros sólidos resultados; y también mostramos varias visualizaciones de atención para los diferentes codificadores*

Este modelo fue aportado por [eltoto1219](https://huggingface.co/eltoto1219). El código original se puede encontrar [aquí](https://github.com/airsplay/lxmert).

## Consejos de uso

- Las cajas delimitantes no son necesarias para usar en las representaciones de características visuales; cualquier tipo de características visuales espaciales funcionará.
- Tanto los estados ocultos del lenguaje como los estados ocultos visuales que LXMERT genera se procesan a través de la capa de multimodalidad, por lo que contienen información de ambas modalidades. Para acceder a una modalidad que solo atiende a sí misma, seleccione los estados ocultos de visión/lenguaje de la primera entrada de la tupla.
- La atención del codificador bidireccional de multimodalidad cruzada solo devuelve valores de atención cuando la modalidad de lenguaje se utiliza como entrada y la modalidad de visión se utiliza como vector de contexto. Además, aunque el codificador de multimodalidad cruzada contiene autoatención para cada modalidad respectiva y atención cruzada, solo se devuelve la atención cruzada y se descartan ambas salidas de autoatención.

## Recursos

- [Guía de la tarea de respuesta a preguntas](../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)
```

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

**Parámetros:**

vocab_size (`int`, *opcional*, valor predeterminado `30522`) : Tamaño del vocabulario del modelo. Define el número de tokens diferentes que pueden representarse mediante `input_ids`.

hidden_size (`int`, *opcional*, valor predeterminado `768`) : Dimensión de las representaciones ocultas.

num_attention_heads (`int`, *opcional*, valor predeterminado `12`) : Número de cabezas de atención para cada capa de atención en el decodificador Transformer.

num_qa_labels (`int`, *opcional*, valor predeterminado 9500) : Representa el número total de etiquetas diferentes de respuesta a preguntas (QA) que existen. Si se utiliza más de un conjunto de datos con QA, el usuario deberá tener en cuenta el número total de etiquetas que tienen todos los conjuntos de datos en conjunto.

num_object_labels (`int`, *opcional*, valor predeterminado 1600) : Representa el número total de objetos semánticamente únicos en los que lxmert podrá clasificar una característica de objeto agrupado.

num_attr_labels (`int`, *opcional*, valor predeterminado 400) : Representa el número total de atributos semánticamente únicos que lxmert podrá clasificar como poseídos por una característica de objeto agrupado.

intermediate_size (`int`, *opcional*, valor predeterminado `3072`) : Dimensión de las representaciones MLP.

hidden_act (`str`, *opcional*, valor predeterminado `gelu`) : La función de activación no lineal (función o cadena) en el decodificador. Por ejemplo, `"gelu"`, `"relu"`, `"silu"`, etc.

hidden_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La probabilidad de dropout para todas las capas totalmente conectadas en los embeddings, el codificador y el pooler.

attention_probs_dropout_prob (`Union[float, int]`, *opcional*, valor predeterminado `0.1`) : La proporción de dropout para las probabilidades de atención.

max_position_embeddings (`int`, *opcional*, valor predeterminado `512`) : La longitud máxima de secuencia con la que se podría utilizar este modelo.

type_vocab_size (`int`, *opcional*, valor predeterminado `2`) : El tamaño del vocabulario de `token_type_ids`.

initializer_range (`float`, *opcional*, valor predeterminado `0.02`) : La desviación estándar de truncated_normal_initializer para inicializar todas las matrices de pesos.

l_layers (`int`, *opcional*, valor predeterminado 9) : Número de capas ocultas en el codificador de lenguaje Transformer.

x_layers (`int`, *opcional*, valor predeterminado: 5) : Número de capas ocultas en el codificador de Transformer de multimodalidad cruzada.

r_layers (`int`, *opcional*, valor predeterminado 5) : Número de capas ocultas en el codificador visual Transformer.

visual_feat_dim (`int`, *opcional*, valor predeterminado 2048) : Representa la última dimensión de las características de objetos agrupados que se utilizan como entrada para el modelo, lo que representa el tamaño de cada característica de objeto en sí.

visual_pos_dim (`int`, *opcional*, valor predeterminado 4) : Representa el número de características espaciales que se combinan con las características visuales. El valor predeterminado es 4 porque, en la mayoría de los casos, esto representa la ubicación de un cuadro delimitador, es decir, (x, y, ancho, alto).

visual_loss_normalizer (`float`, *opcional*, valor predeterminado: 6.67) : Representa el factor de escalado por el cual se multiplica cada pérdida visual si, durante el preentrenamiento, se decidió entrenar con múltiples objetivos de pérdida basados en visión.

task_matched (`bool`, *opcional*, valor predeterminado `True`) : Esta tarea se utiliza para el emparejamiento de oraciones e imágenes. Si la oración describe correctamente la imagen, la etiqueta será 1. Si la oración no describe correctamente la imagen, la etiqueta será 0.

task_mask_lm (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir el modelado de lenguaje enmascarado (tal como se utiliza en modelos de preentrenamiento como BERT) al objetivo de pérdida.

task_obj_predict (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe añadir la predicción de objetos, la predicción de atributos y la regresión de características al objetivo de pérdida.

task_qa (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe o no añadir la pérdida de respuesta a preguntas al objetivo

visual_obj_loss (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe calcular o no la función de pérdida de predicción de objetos

visual_attr_loss (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe calcular o no la función de pérdida de predicción de atributos

visual_feat_loss (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe calcular o no la función de pérdida de regresión de características

pad_token_id (`int`, *opcional*) : Id de token utilizado para el relleno en el vocabulario.

bos_token_id (`int`, *opcional*) : Id de token utilizado para el inicio de la secuencia en el vocabulario.

eos_token_id (`Union[int, list[int]]`, *opcional*) : Id de token utilizado para el fin de la secuencia en el vocabulario.

tie_word_embeddings (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben vincular las incrustaciones de pesos según el mapeo `tied_weights_keys` del modelo.

Esta es la clase de configuración para almacenar la configuración de un LxmertModel. Se utiliza para instanciar un modelo Lxmert según los argumentos especificados, definiendo la arquitectura del modelo. Instanciar una configuración con los valores predeterminados producirá una configuración similar a la de [unc-nlp/lxmert-base-uncased](https://huggingface.co/unc-nlp/lxmert-base-uncased)

Los objetos de configuración heredan de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) y se pueden utilizar para controlar las salidas del modelo. Consulte la documentación de [PreTrainedConfig](/docs/transformers/main/es/main_classes/configuration#transformers.PreTrainedConfig) para obtener más información.

## 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)
```

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

**Parámetros:**

vocab (`str` o `dict[str, int]`, *opcional*) : Diccionario de vocabulario personalizado. Si no se proporciona, el vocabulario se carga desde `vocab_file`.

do_lower_case (`bool`, *opcional*, valor predeterminado `True`) : Indica si se debe convertir la entrada en minúsculas al tokenizar.

unk_token (`str`, *opcional*, valor predeterminado `"[UNK]"`) : El token desconocido. Un token que no está en el vocabulario no se puede convertir en un ID y se establece como este token en su lugar.

sep_token (`str`, *opcional*, valor predeterminado `"[SEP]"`) : El token separador, que se utiliza al construir una secuencia a partir de varias secuencias, por ejemplo, dos secuencias para la clasificación de secuencias o un texto y una pregunta para la respuesta a preguntas. También se utiliza como el último token de una secuencia construida con tokens especiales.

pad_token (`str`, *opcional*, valor predeterminado `"[PAD]"`) : El token utilizado para el relleno, por ejemplo, al agrupar secuencias de diferentes longitudes.

cls_token (`str`, *opcional*, valor predeterminado `"[CLS]"`) : El token clasificador que se utiliza al realizar clasificación de secuencias (clasificación de la secuencia completa en lugar de clasificación por token). Es el primer token de la secuencia cuando se construye con tokens especiales.

mask_token (`str`, *opcional*, valor predeterminado `"[MASK]"`) : El token utilizado para enmascarar valores. Este es el token que se emplea al entrenar este modelo con modelado de lenguaje enmascarado. Es el token que el modelo intentará predecir.

tokenize_chinese_chars (`bool`, *opcional*, valor predeterminado `True`) : Indica si se deben tokenizar los caracteres chinos.

strip_accents (`bool`, *opcional*) : Indica si se deben eliminar todas las tildes. Si no se especifica esta opción, se determinará en función del valor de `lowercase` (como en BERT original).

Construye un tokenizador BERT (respaldado por la biblioteca tokenizers de HuggingFace). Basado en WordPiece.

Este tokenizador hereda de [TokenizersBackend](/docs/transformers/main/es/main_classes/tokenizer#transformers.TokenizersBackend), que contiene la mayoría de los métodos principales. Los usuarios deben consultar esta superclase para obtener más información sobre dichos métodos.

## Salidas específicas de 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)
```

[Fuente](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)`) : Secuencia de estados ocultos en la salida de la última capa del codificador de lenguaje.

vision_output (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) : Secuencia de estados ocultos en la salida de la última capa del codificador visual.

pooled_output (`torch.Tensor` de forma `(batch_size, hidden_size)`) : Estado oculto de la última capa del primer token de la secuencia (clasificación, CLS, token) procesado adicionalmente por una capa Lineal y una función de activación Tanh. La capa Lineal

language_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.

vision_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.

language_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

vision_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Las salidas de Lxmert que contienen los últimos estados ocultos, las salidas agrupadas y las probabilidades de atención para los codificadores de lenguaje, visual y de multimodalidad cruzada. (Nota: el codificador visual en Lxmert se denomina codificador de "relación")

#### 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)
```

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

**Parámetros:**

loss (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) : Pérdida total como la suma de la pérdida de modelado de lenguaje enmascarado y la pérdida de predicción de la siguiente secuencia (clasificación).

prediction_logits (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) : Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes del SoftMax).

cross_relationship_score (`torch.Tensor` de forma `(batch_size, 2)`) : Puntuaciones de predicción de la cabeza de objetivo de coincidencia textual (clasificación) (puntuaciones de continuación True/False antes de SoftMax).

question_answering_score (`torch.Tensor` de forma `(batch_size, n_qa_answers)`) : Puntuaciones de predicción del objetivo de respuesta a preguntas (clasificación).

language_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.

vision_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.

language_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

vision_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Tipo de salida de [LxmertForPreTraining](/docs/transformers/main/es/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)
```

[Fuente](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*) : Puntuaciones de predicción del objetivo de respuesta a preguntas (clasificación).

language_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.

vision_hidden_states (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) : Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.

language_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

vision_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

cross_encoder_attentions (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) : Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Tipo de salida de [LxmertForQuestionAnswering](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertForQuestionAnswering).

## LxmertModel[[transformers.LxmertModel]]

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

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

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

**Parámetros:**

config ([LxmertConfig](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Lxmert básico que genera estados ocultos sin ninguna cabeza específica en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### 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)
```

[Fuente](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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

visual_feats (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_feat_dim)`) : Esta entrada representa características visuales. Son características de objetos obtenidas mediante ROI pooling a partir de cajas delimitadoras, utilizando un modelo faster-RCNN) Actualmente, la biblioteca transformers no las proporciona.

visual_pos (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_pos_dim)`) : Esta entrada representa características espaciales correspondientes a sus características visuales relativas (mediante índice). El modelo LXMERT preentrenado espera que estas características espaciales sean cajas delimitadoras normalizadas en una escala de 0 a 1. Actualmente, la biblioteca transformers no las proporciona.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`:  - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [LxmertModelOutput](/docs/transformers/main/es/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) o `tuple(torch.Tensor)`

Un [LxmertModelOutput](/docs/transformers/main/es/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([LxmertConfig](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertConfig)) y las entradas.

El método forward de [LxmertModel](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertModel) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **language_output** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del codificador de lenguaje.
- **vision_output** (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`) -- Secuencia de estados ocultos en la salida de la última capa del codificador visual.
- **pooled_output** (`torch.Tensor` de forma `(batch_size, hidden_size)`) -- Estado oculto de la última capa del primer token de la secuencia (clasificación, CLS, token), procesado adicionalmente por una capa Linear y una función de activación Tanh. La capa Linear
- **language_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.
- **vision_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.
- **language_attentions** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **vision_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

## LxmertForPreTraining[[transformers.LxmertForPreTraining]]

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

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

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

**Parámetros:**

config ([LxmertConfig](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

El modelo Lxmert con una cabeza de preentrenamiento especificada en la parte superior.

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### 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)
```

[Fuente](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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

visual_feats (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_feat_dim)`) : Esta entrada representa características visuales. Son características de objetos obtenidas mediante ROI pooling a partir de cajas delimitadoras, utilizando un modelo faster-RCNN) Actualmente, la biblioteca transformers no las proporciona.

visual_pos (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_pos_dim)`) : Esta entrada representa características espaciales correspondientes a sus características visuales relativas (mediante índice). El modelo LXMERT preentrenado espera que estas características espaciales sean cajas delimitadoras normalizadas en una escala de 0 a 1. Actualmente, la biblioteca transformers no las proporciona.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`:  - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

labels (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Etiquetas para calcular la pérdida de modelado de lenguaje enmascarado. Los índices deben estar en `[-100, 0, ..., config.vocab_size]` (ver la docstring de `input_ids`). Los tokens con índices establecidos en `-100` se ignoran (se enmascaran); la pérdida solo se calcula para los tokens con etiquetas en `[0, ..., config.vocab_size]`.

obj_labels (`dict[Str : tuple[torch.Tensor, torch.Tensor]]`, *opcional*): cada clave lleva el nombre de una de las pérdidas visuales y cada elemento de la tupla tiene la forma `(batch_size, num_features)` y `(batch_size, num_features, visual_feature_dim)` para el id de la etiqueta y la puntuación de la etiqueta, respectivamente

matched_label (`torch.LongTensor` de forma `(batch_size,)`, *opcional*) : Etiquetas para calcular la pérdida de clasificación sobre si la entrada de texto coincide con la imagen o no. La entrada debe ser un par de secuencias (ver la docstring de `input_ids`). Los índices deben estar en `[0, 1]`: - 0 indica que la oración no coincide con la imagen, - 1 indica que la oración sí coincide con la imagen.

ans (`Torch.Tensor` de forma `(batch_size)`, *opcional*) : una representación one hot de la respuesta correcta *opcional*

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [LxmertForPreTrainingOutput](/docs/transformers/main/es/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) o `tuple(torch.Tensor)`

Un [LxmertForPreTrainingOutput](/docs/transformers/main/es/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([LxmertConfig](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertConfig)) y las entradas.

El método forward de [LxmertForPreTraining](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertForPreTraining) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`*optional*`, se devuelve cuando se proporciona `labels`, `torch.Tensor` de forma `(1,)`) -- Pérdida total como la suma de la pérdida de modelado de lenguaje enmascarado y la pérdida de predicción de la siguiente secuencia (clasificación).
- **prediction_logits** (`torch.Tensor` de forma `(batch_size, sequence_length, config.vocab_size)`) -- Puntuaciones de predicción de la cabeza de modelado de lenguaje (puntuaciones para cada token del vocabulario antes de SoftMax).
- **cross_relationship_score** (`torch.Tensor` de forma `(batch_size, 2)`) -- Puntuaciones de predicción de la cabeza de objetivo de coincidencia textual (clasificación) (puntuaciones de continuación True/False antes del SoftMax).
- **question_answering_score** (`torch.Tensor` de forma `(batch_size, n_qa_answers)`) -- Puntuaciones de predicción del objetivo de respuesta a preguntas (clasificación).
- **language_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.
- **vision_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.
- **language_attentions** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **vision_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

```python
```

## LxmertForQuestionAnswering[[transformers.LxmertForQuestionAnswering]]

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

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

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

**Parámetros:**

config ([LxmertConfig](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertConfig)) : Clase de configuración del modelo con todos los parámetros del modelo. Inicializar con un archivo de configuración no carga los pesos asociados con el modelo, solo la configuración. Consulte el método [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained) para cargar los pesos del modelo.

Modelo Lxmert con una cabeza de respuesta visual en la parte superior para tareas de QA de nivel inferior

Este modelo hereda de [PreTrainedModel](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel). Consulte la documentación de la clase superior para los métodos genéricos que la biblioteca implementa para todos sus modelos (como la descarga o el guardado, el redimensionamiento de las incrustaciones de entrada, la poda de cabezas, etc.).

Este modelo también es una subclase de [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) de PyTorch. Úsalo como un módulo de PyTorch regular y consulta la documentación de PyTorch para todo lo relacionado con el uso y el comportamiento generales.

#### 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)
```

[Fuente](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 de los tokens de la secuencia de entrada en el vocabulario. El relleno se ignorará de forma predeterminada. Los índices se pueden obtener mediante [AutoTokenizer](/docs/transformers/main/es/model_doc/auto#transformers.AutoTokenizer). Consulte [PreTrainedTokenizer.encode()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) y [PreTrainedTokenizer.__call__()](/docs/transformers/main/es/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__) para obtener más detalles. [¿Qué son los IDs de entrada?](../glossary#input-ids)

visual_feats (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_feat_dim)`) : Esta entrada representa características visuales. Son características de objetos obtenidas mediante ROI pooling a partir de cajas delimitadoras, utilizando un modelo faster-RCNN) Actualmente, la biblioteca transformers no las proporciona.

visual_pos (`torch.Tensor` de forma `(batch_size, num_visual_features, visual_pos_dim)`) : Esta entrada representa características espaciales correspondientes a sus características visuales relativas (mediante índice). El modelo LXMERT preentrenado espera que estas características espaciales sean cajas delimitadoras normalizadas en una escala de 0 a 1. Actualmente, la biblioteca transformers no las proporciona.

attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor` de forma `(batch_size, sequence_length)`, *opcional*) : Máscara para evitar realizar atención en los índices de tokens de relleno. Valores de la máscara seleccionados en `[0, 1]`:  - 1 para tokens que **no están enmascarados**, - 0 para tokens que **están enmascarados**.  [¿Qué son las máscaras de atención?](../glossary#attention-mask)

token_type_ids (`torch.LongTensor` de forma `(batch_size, sequence_length)`, *opcional*) : Índices de tokens de segmento para indicar las primeras y segundas partes de las entradas. Los índices se seleccionan en `[0, 1]`:  - 0 corresponde a un token de *oración A*, - 1 corresponde a un token de *oración B*.  [¿Qué son los IDs de tipo de token?](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor` de forma `(batch_size, sequence_length, hidden_size)`, *opcional*) : Opcionalmente, en lugar de pasar `input_ids`, puedes elegir pasar directamente una representación incrustada. Esto es útil si deseas tener más control sobre cómo convertir los índices de `input_ids` en los vectores asociados que en la matriz de búsqueda de incrustaciones interna del modelo.

labels (`Torch.Tensor` de forma `(batch_size)`, *opcional*) : Una representación one-hot de la respuesta correcta

output_attentions (`bool`, *opcional*) : Indica si se deben devolver los tensores de atención de todas las capas de atención. Consulte `attentions` en los tensores devueltos para obtener más detalles.

output_hidden_states (`bool`, *opcional*) : Indica si se deben devolver los estados ocultos de todas las capas. Consulte `hidden_states` en los tensores devueltos para obtener más detalles.

return_dict (`bool`, *opcional*) : Indica si se debe devolver un [ModelOutput](/docs/transformers/main/es/main_classes/output#transformers.utils.ModelOutput) en lugar de una tupla simple.

**Devuelve:** [LxmertForQuestionAnsweringOutput](/docs/transformers/main/es/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) o `tuple(torch.Tensor)`

Un [LxmertForQuestionAnsweringOutput](/docs/transformers/main/es/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) o una tupla de `torch.Tensor` (si se pasa `return_dict=False` o cuando `config.return_dict=False`) que comprende varios elementos según la configuración ([LxmertConfig](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertConfig)) y las entradas.

El método forward de [LxmertForQuestionAnswering](/docs/transformers/main/es/model_doc/lxmert#transformers.LxmertForQuestionAnswering) sobrescribe el método especial `__call__`.

Aunque la receta para la pasada hacia adelante debe definirse dentro de esta función, se debe llamar a la instancia de `Module` después, en lugar de a esta, ya que la primera se encarga de ejecutar los pasos de preprocesamiento y posprocesamiento, mientras que la segunda los ignora silenciosamente.

- **loss** (`*optional*`, returned when `labels` is provided, `torch.Tensor` of shape `(1,)`) -- Pérdida total como la suma de la pérdida de modelado de lenguaje enmascarado y la pérdida de predicción de la siguiente secuencia (clasificación).k.
- **question_answering_score** (`torch.Tensor` de forma `(batch_size, n_qa_answers)`, *opcional*) -- Puntuaciones de predicción del objetivo de respuesta a preguntas (clasificación).
- **language_hidden_states** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.
- **vision_hidden_states** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_hidden_states=True` o cuando `config.output_hidden_states=True`) -- Tupla de `torch.Tensor` (una para las características de entrada + una para la salida de cada capa de multimodalidad cruzada) de forma `(batch_size, sequence_length, hidden_size)`.
- **language_attentions** (`tuple(torch.Tensor)`, *opcional*, devuelto cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **vision_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (una por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.
- **cross_encoder_attentions** (`tuple(torch.Tensor)`, *opcional*, se devuelve cuando se pasa `output_attentions=True` o cuando `config.output_attentions=True`) -- Tupla de `torch.Tensor` (uno por cada capa) de forma `(batch_size, num_heads, sequence_length, sequence_length)`. Pesos de atención después del softmax de atención, utilizados para calcular la media ponderada en las cabezas de autoatención.

Ejemplo:

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