# LXMERT

## 概述

LXMERT 模型由 Hao Tan 和 Mohit Bansal 在 [LXMERT: Learning Cross-Modality Encoder Representations from Transformers](https://huggingface.co/papers/1908.07490) 中提出。它是一系列双向 transformer 编码器（一个用于视觉模态，一个用于语言模态，然后一个用于融合这两种模态），通过结合掩码语言建模、视觉-语言文本对齐、ROI 特征回归、掩码视觉属性建模、掩码视觉对象建模以及视觉问答目标进行预训练。预训练使用了多个多模态数据集：MSCOCO、Visual-Genome + Visual-Genome Question Answering、VQA 2.0 和 GQA。

该论文的摘要如下：

*视觉与语言推理需要对视觉概念、语言语义以及（最重要的是）这两种模态之间的对齐和关系进行理解。因此，我们提出了 LXMERT（Learning Cross-Modality Encoder Representations from Transformers）框架来学习这些视觉与语言之间的连接。在 LXMERT 中，我们构建了一个大规模 Transformer 模型，它由三个编码器组成：对象关系编码器、语言编码器和跨模态编码器。接下来，为了使我们的模型具备连接视觉和语言语义的能力，我们通过五个多样化的代表性预训练任务，利用大量的图像-句子对来预训练模型：掩码语言建模、掩码对象预测（特征回归和标签分类）、跨模态匹配以及图像问答。这些任务有助于学习模态内和跨模态的关系。从我们的预训练参数进行微调后，我们的模型在两个视觉问答数据集（即 VQA 和 GQA）上达到了最先进的结果。我们还通过将我们的预训练跨模态模型适配到具有挑战性的视觉推理任务 NLVR 上，展示了其泛化能力，并将之前的最佳结果绝对提升了 22%（从 54% 到 76%）。最后，我们展示了详细的消融研究，以证明我们新颖的模型组件和预训练策略对我们的优异结果做出了重大贡献；并展示了不同编码器的若干注意力可视化*

该模型由 [eltoto1219](https://huggingface.co/eltoto1219) 贡献。原始代码可在[此处](https://github.com/airsplay/lxmert)找到。

## 使用技巧

- 边界框并非必须用于视觉特征嵌入，任何类型的视觉空间特征都可以使用。
- LXMERT 输出的语言隐藏状态和视觉隐藏状态都会经过跨模态层，因此它们都包含来自两种模态的信息。若要访问仅关注自身的模态，请从元组的第一个输入中选择视觉/语言隐藏状态。
- 双向跨模态编码器注意力仅在语言模态用作输入且视觉模态用作上下文向量时返回注意力值。此外，尽管跨模态编码器包含针对各自模态的自注意力以及交叉注意力，但仅返回交叉注意力，两个自注意力输出均被忽略。

## 资源

- [问答任务指南](../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)
```

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

**参数：**

vocab_size (`int`，*可选*，默认值为 `30522`)：模型的词汇表大小。定义了 `input_ids` 可以表示的不同 token 数量。

hidden_size (`int`，*可选*，默认为 `768`)：隐藏表示的维度。

num_attention_heads (`int`，*可选*，默认为 `12`)：Transformer 解码器中每个注意力层的注意力头数量。

num_qa_labels (`int`，*可选*，默认值为 9500)：表示问答（QA）标签的总数。如果使用多个包含 QA 的数据集，用户需要考虑所有数据集的标签总数。

num_object_labels (`int`，*可选*，默认值为 1600)：这表示 lxmert 能够将一个池化对象特征分类为属于的语义唯一对象的总数。

num_attr_labels (`int`，*可选*，默认值为 400)：这表示 lxmert 能够识别的池化对象特征所具备的语义唯一属性的总数。

intermediate_size (`int`，*可选*，默认值为 `3072`)：MLP 表示的维度。

hidden_act (`str`，*可选*，默认为 `gelu`)：解码器中的非线性激活函数（函数或字符串）。例如，`"gelu"`、`"relu"`、`"silu"` 等。

hidden_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：嵌入层、编码器和池化器中所有全连接层的 dropout 概率。

attention_probs_dropout_prob (`Union[float, int]`，*可选*，默认值为 `0.1`)：注意力概率的 dropout 比率。

max_position_embeddings (`int`，*可选*，默认值为 `512`)：该模型可能使用的最大序列长度。

type_vocab_size (`int`，*可选*，默认为 `2`)：`token_type_ids` 的词汇表大小。

initializer_range (`float`，*可选*，默认值为 `0.02`)：用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。

l_layers (`int`，*可选*，默认为 9)：Transformer 语言编码器中的隐藏层数。

x_layers (`int`，*可选*，默认为 5)：Transformer 跨模态编码器中的隐藏层数。

r_layers (`int`，*可选*，默认为 5)：Transformer 视觉编码器中的隐藏层数。

visual_feat_dim (`int`，*可选*，默认为 2048)：这表示用作模型输入的池化对象特征的最后一个维度，即每个对象特征本身的大小。

visual_pos_dim (`int`, *可选*，默认为 4)：这表示混合到视觉特征中的空间特征数量。默认值设为 4，因为通常这代表边界框的位置，即 (x, y, width, height)。

visual_loss_normalizer (`float`, *可选*，默认值为 6.67)：如果在预训练过程中决定使用多个基于视觉的损失目标进行训练，此参数表示每个视觉损失被乘上的缩放因子。

task_matched (`bool`，*可选*，默认为 `True`)：此任务用于句子-图像匹配。如果句子正确描述了图像，标签为 1。如果句子未正确描述图像，标签为 0。

task_mask_lm (`bool`，*可选*，默认为 `True`)：是否将掩码语言建模（如 BERT 等预训练模型所使用的技术）添加到损失目标中。

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`, *可选*) : 词表中用于填充的 Token id。

bos_token_id (`int`, *可选*) : 词表中用于表示流开始的 Token id。

eos_token_id (`Union[int, list[int]]`，*可选*)：词汇表中用于表示流结束（end-of-stream）的 Token ID。

tie_word_embeddings (`bool`，*可选*，默认为 `True`)：是否根据模型的 `tied_weights_keys` 映射来绑定权重嵌入。

这是用于存储 LxmertModel 配置的类。它根据指定的参数实例化 Lxmert 模型，并定义模型架构。使用默认值实例化配置将生成与 [unc-nlp/lxmert-base-uncased](https://huggingface.co/unc-nlp/lxmert-base-uncased) 类似的配置。

配置对象继承自 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig)，可用于控制模型输出。有关更多信息，请参阅 [PreTrainedConfig](/docs/transformers/main/zh/main_classes/configuration#transformers.PreTrainedConfig) 的文档。

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

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

**参数：**

vocab (`str` 或 `dict[str, int]`，*可选*) : 自定义词汇表。如果未提供，则从 `vocab_file` 加载词汇表。

do_lower_case (`bool`，*可选*，默认为 `True`)：分词时是否将输入转换为小写。

unk_token (`str`，*可选*，默认为 `"[UNK]"`)：未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。

sep_token (`str`，*可选*，默认为 `"[SEP]"`)：分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。

pad_token (`str`，*可选*，默认为 `"[PAD]"`)：用于填充的标记，例如在对长度不同的序列进行批处理时。

cls_token (`str`，*可选*，默认为 `"[CLS]"`)：用于序列分类（对整个序列进行分类，而非逐 token 分类）的分类器 token。当使用特殊 token 构建序列时，它是序列的第一个 token。

mask_token (`str`，*可选*，默认为 `"[MASK]"`)：用于掩码值的标记。这是在通过掩码语言建模训练该模型时所使用的标记，也是模型将尝试预测的标记。

tokenize_chinese_chars (`bool`，*可选*，默认为 `True`)：是否对汉字进行分词。

strip_accents (`bool`, *可选*) : 是否去除所有重音符号。如果未指定此选项，则将根据 `lowercase` 的值来确定（与原始 BERT 相同）。

构建一个 BERT 分词器（由 HuggingFace 的 tokenizers 库提供支持）。基于 WordPiece。

该分词器继承自 [TokenizersBackend](/docs/transformers/main/zh/main_classes/tokenizer#transformers.TokenizersBackend)，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。

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

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

**参数：**

language_output (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`)：语言编码器最后一层输出的隐藏状态序列。

vision_output (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`)：视觉编码器最后一层输出的隐藏状态序列。

pooled_output (`torch.Tensor`，形状为 `(batch_size, hidden_size)`)：序列中第一个 token（分类、CLS、token）的最后一层隐藏状态，经过一个 Linear 层和 Tanh 激活函数进一步处理。该 Linear

language_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（包含一个用于输入特征，以及每个跨模态层输出的一个），形状为 `(batch_size, sequence_length, hidden_size)`。

vision_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（包含一个用于输入特征，以及每个跨模态层输出的一个），形状为 `(batch_size, sequence_length, hidden_size)`。

language_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

vision_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

cross_encoder_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

Lxmert 的输出，包含语言、视觉以及跨模态编码器的最后隐藏状态、池化输出和注意力概率。（注意：Lxmert 中的视觉编码器被称为“关系”编码器）

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

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

**参数：**

loss (`*optional*`，当提供 `labels` 时返回，形状为 `(1,)` 的 `torch.Tensor`) : 总损失，为掩码语言建模损失与下一句预测（分类）损失的总和。

prediction_logits (`torch.Tensor`，形状为 `(batch_size, sequence_length, config.vocab_size)`)：语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。

cross_relationship_score (`torch.Tensor`，形状为 `(batch_size, 2)`)：文本匹配目标（分类）头的预测分数（SoftMax 之前 True/False 延续的分数）。

question_answering_score (`torch.Tensor`，形状为 `(batch_size, n_qa_answers)`)：问答目标（分类）的预测分数。

language_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（包含一个用于输入特征，以及每个跨模态层输出的一个），形状为 `(batch_size, sequence_length, hidden_size)`。

vision_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（包含一个用于输入特征，以及每个跨模态层输出的一个），形状为 `(batch_size, sequence_length, hidden_size)`。

language_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

vision_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

cross_encoder_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

[LxmertForPreTraining](/docs/transformers/main/zh/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)
```

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

**参数：**

loss (`*optional*`，当提供 `labels` 时返回，形状为 `(1,)` 的 `torch.Tensor`) : 总损失，为掩码语言建模损失与下一句预测（分类）损失之和。

question_answering_score (`torch.Tensor`，形状为 `(batch_size, n_qa_answers)`，*可选*)：问答目标（分类）的预测分数。

language_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（包含一个用于输入特征，以及每个跨模态层输出的一个），形状为 `(batch_size, sequence_length, hidden_size)`。

vision_hidden_states (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：一个 `torch.Tensor` 元组（包含一个用于输入特征，以及每个跨模态层输出的一个），形状为 `(batch_size, sequence_length, hidden_size)`。

language_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

vision_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

cross_encoder_attentions (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回)：一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

[LxmertForQuestionAnswering](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertForQuestionAnswering) 的输出类型。

## LxmertModel[[transformers.LxmertModel]]

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

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

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

**参数：**

config ([LxmertConfig](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

未添加任何特定头部的裸 Lxmert 模型，直接输出原始隐藏状态。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

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

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

visual_feats (`torch.Tensor`，形状为 `(batch_size, num_visual_features, visual_feat_dim)`)：此输入表示视觉特征。它们是使用 faster-RCNN 模型从边界框中通过 ROI 池化得到的目标特征）目前 transformers 库尚未提供这些特征。

visual_pos (`torch.Tensor`，形状为 `(batch_size, num_visual_features, visual_pos_dim)`)：此输入表示与其相对（通过索引）视觉特征相对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到 1 范围内归一化的边界框。目前 transformers 库尚未提供这些特征。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [LxmertModelOutput](/docs/transformers/main/zh/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) 或 `tuple(torch.Tensor)`

一个 [LxmertModelOutput](/docs/transformers/main/zh/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertModelOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[LxmertConfig](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertConfig)）和输入。

[LxmertModel](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertModel) 的 forward 方法会重写 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **language_output**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 语言编码器最后一层输出的隐藏状态序列。
- **vision_output**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 视觉编码器最后一层输出的隐藏状态序列。
- **pooled_output**（形状为 `(batch_size, hidden_size)` 的 `torch.Tensor`）-- 序列中第一个 token（分类、CLS、token）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性
- **language_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（包含一个输入特征张量以及每个跨模态层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。
- **vision_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（包含一个输入特征张量以及每个跨模态层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。
- **language_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **vision_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **cross_encoder_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

## LxmertForPreTraining[[transformers.LxmertForPreTraining]]

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

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

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

**参数：**

config ([LxmertConfig](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

在顶部指定了预训练头的 Lxmert 模型。

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

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

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

visual_feats (`torch.Tensor`，形状为 `(batch_size, num_visual_features, visual_feat_dim)`)：此输入表示视觉特征。它们是使用 faster-RCNN 模型从边界框中通过 ROI 池化得到的目标特征）目前 transformers 库尚未提供这些特征。

visual_pos (`torch.Tensor`，形状为 `(batch_size, num_visual_features, visual_pos_dim)`)：此输入表示与其相对（通过索引）视觉特征相对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到 1 范围内归一化的边界框。目前 transformers 库尚未提供这些特征。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于计算掩码语言建模损失的标签。索引应在 `[-100, 0, ..., config.vocab_size]` 范围内（参见 `input_ids` 的文档字符串）。索引设置为 `-100` 的令牌将被忽略（掩码），损失仅针对标签在 `[0, ..., config.vocab_size]` 范围内的令牌进行计算。

obj_labels (`dict[Str : tuple[torch.Tensor, torch.Tensor]]`，*可选*)：每个键以各个视觉损失命名，元组中的每个元素分别对应标签 ID 和标签分数，其形状分别为 `(batch_size, num_features)` 和 `(batch_size, num_features, visual_feature_dim)`

matched_label (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：用于计算文本输入是否与图像匹配（分类）损失的标签。输入应为序列对（参见 `input_ids` 的文档字符串）。索引应在 `[0, 1]` 范围内： - 0 表示句子与图像不匹配， - 1 表示句子与图像匹配。

ans (`Torch.Tensor`，形状为 `(batch_size)`，*可选*)：正确答案的 one-hot 表示 *可选*

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [LxmertForPreTrainingOutput](/docs/transformers/main/zh/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) 或 `tuple(torch.Tensor)`

一个 [LxmertForPreTrainingOutput](/docs/transformers/main/zh/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForPreTrainingOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[LxmertConfig](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertConfig)）和输入。

[LxmertForPreTraining](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertForPreTraining) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`*optional*`，当提供 `labels` 时返回，形状为 `(1,)` 的 `torch.Tensor`) -- 总损失，为掩码语言建模损失与下一句预测（分类）损失之和。
- **prediction_logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **cross_relationship_score**（形状为 `(batch_size, 2)` 的 `torch.Tensor`）-- 文本匹配目标（分类）头的预测分数（SoftMax 之前 True/False 延续的分数）。
- **question_answering_score**（形状为 `(batch_size, n_qa_answers)` 的 `torch.Tensor`）-- 问答目标（分类）的预测分数。
- **language_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（包含一个输入特征张量以及每个跨模态层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。
- **vision_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（包含一个输入特征张量以及每个跨模态层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。
- **language_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **vision_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **cross_encoder_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

```python
```

## LxmertForQuestionAnswering[[transformers.LxmertForQuestionAnswering]]

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

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

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

**参数：**

config ([LxmertConfig](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertConfig))：模型配置类，包含模型的所有参数。使用配置文件进行初始化时，不会加载与模型关联的权重，仅加载配置。请查看 [from_pretrained()](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel.from_pretrained) 方法以加载模型权重。

Lxmert 模型，顶部带有视觉问答头，用于下游问答任务

该模型继承自 [PreTrainedModel](/docs/transformers/main/zh/main_classes/model#transformers.PreTrainedModel)。请查阅父类文档，了解该库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。

该模型也是 PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) 的子类。请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

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

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

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：输入序列中 token 在词汇表中的索引。默认情况下，填充（padding）将被忽略。可以使用 [AutoTokenizer](/docs/transformers/main/zh/model_doc/auto#transformers.AutoTokenizer) 获取索引。有关详细信息，请参阅 [PreTrainedTokenizer.encode()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.encode) 和 [PreTrainedTokenizer.__call__()](/docs/transformers/main/zh/internal/tokenization_utils#transformers.PreTrainedTokenizerBase.__call__)。[什么是输入 ID？](../glossary#input-ids)

visual_feats (`torch.Tensor`，形状为 `(batch_size, num_visual_features, visual_feat_dim)`)：此输入表示视觉特征。它们是使用 faster-RCNN 模型从边界框中通过 ROI 池化得到的目标特征）目前 transformers 库尚未提供这些特征。

visual_pos (`torch.Tensor`，形状为 `(batch_size, num_visual_features, visual_pos_dim)`)：此输入表示与其相对（通过索引）视觉特征相对应的空间特征。预训练的 LXMERT 模型期望这些空间特征是在 0 到 1 范围内归一化的边界框。目前 transformers 库尚未提供这些特征。

attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

visual_attention_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于避免对填充（padding）标记索引执行注意力机制的掩码。掩码值取自 `[0, 1]`： - 1 表示**未掩码**的标记， - 0 表示**已掩码**的标记。 [什么是注意力掩码？](../glossary#attention-mask)

token_type_ids (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于指示输入中第一和第二部分的段标记索引。索引选自 `[0, 1]`： - 0 对应 *句子 A* 的标记， - 1 对应 *句子 B* 的标记。 [什么是标记类型 ID？](../glossary#token-type-ids)

inputs_embeds (`torch.Tensor`，形状为 `(batch_size, sequence_length, hidden_size)`，*可选*)：可选地，你可以选择直接传入嵌入表示，而不是传入 `input_ids`。如果你希望比模型内部的嵌入查找矩阵更精细地控制如何将 `input_ids` 索引转换为对应的向量，这将非常有用。

labels (`Torch.Tensor`，形状为 `(batch_size)`，*可选*)：正确答案的 one-hot 表示

output_attentions (`bool`, *可选*) : 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的 `attentions`。

output_hidden_states (`bool`, *可选*) : 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 `hidden_states`。

return_dict (`bool`, *可选*) : 是否返回 [ModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.utils.ModelOutput) 而不是普通元组。

**返回：** [LxmertForQuestionAnsweringOutput](/docs/transformers/main/zh/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) 或 `tuple(torch.Tensor)`

一个 [LxmertForQuestionAnsweringOutput](/docs/transformers/main/zh/model_doc/lxmert#transformers.models.lxmert.modeling_lxmert.LxmertForQuestionAnsweringOutput) 或 `torch.Tensor` 元组（如果传入了 `return_dict=False` 或 `config.return_dict=False`），其包含的元素取决于配置（[LxmertConfig](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertConfig)）和输入。

[LxmertForQuestionAnswering](/docs/transformers/main/zh/model_doc/lxmert#transformers.LxmertForQuestionAnswering) 的 forward 方法重写了 `__call__` 特殊方法。

尽管前向传播的实现需要在此函数中定义，但之后应调用 `Module` 实例，而不是直接调用此函数，因为前者会负责执行预处理和后处理步骤，而后者会静默地忽略这些步骤。

- **loss** (`*optional*`，当提供 `labels` 时返回，形状为 `(1,)` 的 `torch.Tensor`) -- 总损失，为掩码语言建模损失与下一句预测（分类）损失之和。
- **question_answering_score** (`torch.Tensor`，形状为 `(batch_size, n_qa_answers)`，*可选*) -- 问答目标（分类）的预测分数。
- **language_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（包含一个输入特征张量以及每个跨模态层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。
- **vision_hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（包含一个输入特征张量以及每个跨模态层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。
- **language_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **vision_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。
- **cross_encoder_attentions** (`tuple(torch.Tensor)`，*可选*，在传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。注意力 softmax 之后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

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