# XLM

[XLM](https://huggingface.co/papers/1901.07291) 通过两种方法展示了跨语言预训练：在单一语言上进行无监督训练，以及在多种语言上结合跨语言语言模型目标进行有监督训练。XLM 模型支持因果语言建模目标、掩码语言建模，以及翻译语言建模（将 [BERT](./bert) 的掩码语言建模目标扩展至多语言输入）。

您可以在 [Facebook AI 社区](https://huggingface.co/FacebookAI?search_models=xlm-mlm) 组织下找到所有原始的 XLM 检查点。

> [!TIP]
> 点击右侧边栏中的 XLM 模型，以查看更多将 XLM 应用于不同跨语言任务（如分类、翻译和问答）的示例。

以下示例演示了如何使用 [Pipeline](/docs/transformers/main/zh/main_classes/pipelines#transformers.Pipeline)、[AutoModel](/docs/transformers/main/zh/model_doc/auto#transformers.AutoModel) 以及命令行来预测 `<mask>` 标记。

```python
from transformers import pipeline

pipeline = pipeline(
    task="fill-mask",
    model="facebook/xlm-roberta-xl",
    device=0
)
pipeline("Bonjour, je suis un modèle <mask>.")
```

```python
import torch

from transformers import AutoModelForMaskedLM, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained(
    "FacebookAI/xlm-mlm-en-2048",
)
model = AutoModelForMaskedLM.from_pretrained(
    "FacebookAI/xlm-mlm-en-2048",
    device_map="auto",
)
inputs = tokenizer("Hello, I'm a <mask> model.", return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model(**inputs)
    predictions = outputs.logits.argmax(dim=-1)

predicted_token = tokenizer.decode(predictions[0][inputs["input_ids"][0] == tokenizer.mask_token_id])
print(f"Predicted token: {predicted_token}")
```

## XLMConfig[[transformers.XLMConfig]]

#### transformers.XLMConfig[[transformers.XLMConfig]]

```python
transformers.XLMConfig(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 = 30145, emb_dim: int = 2048, n_layers: int = 12, n_heads: int = 16, dropout: float | int = 0.1, attention_dropout: float | int = 0.1, gelu_activation: bool = True, sinusoidal_embeddings: bool = False, causal: bool = False, asm: bool = False, n_langs: int = 1, use_lang_emb: bool = True, max_position_embeddings: int = 512, embed_init_std: float = 0.02209708691207961, layer_norm_eps: float = 1e-12, init_std: float = 0.02, unk_index: int = 3, mask_index: int = 5, is_encoder: bool = True, summary_type: str = 'first', summary_use_proj: bool = True, summary_activation: str | None = None, summary_proj_to_labels: bool = True, summary_first_dropout: float | int = 0.1, start_n_top: int = 5, end_n_top: int = 5, mask_token_id: int | None = 0, lang_id: int = 0, pad_token_id: int | None = 2, bos_token_id: int | None = 0, eos_token_id: int | list[int] | None = 1, tie_word_embeddings: bool = True)
```

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

**参数：**

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

emb_dim (`int`，*可选*，默认为 `2048`)：嵌入和隐藏状态的维度。

n_layers (`int`，*可选*，默认为 `12`)：Transformer 解码器中的隐藏层数。

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

dropout (`Union[float, int]`，*可选*，默认为 `0.1`)：所有 dropout 层的比率。

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

gelu_activation (`bool`, *可选*, 默认为 `True`) : 是否使用 *gelu* 而非 *relu* 作为激活函数。

sinusoidal_embeddings (`bool`，*可选*，默认为 `False`)：是否使用正弦位置嵌入代替绝对位置嵌入。

causal (`bool`，*可选*，默认为 `False`)：模型是否应以因果方式运行。因果模型使用三角形注意力掩码，以便仅关注左侧上下文，而非双向上下文。

asm (`bool`，*可选*，默认为 `False`)：是否使用自适应对数 Softmax 投影层而非线性层作为预测层。

n_langs (`int`，*可选*，默认为 1)：模型处理的语言数量。对于单语模型，请设置为 1。

use_lang_emb (`bool`，*可选*，默认为 `True`)：是否使用语言嵌入。某些模型会使用额外的语言嵌入，有关如何使用它们的信息，请参阅[多语言模型页面](http://huggingface.co/transformers/multilingual.html#xlm-language-embeddings)。

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

embed_init_std (`float`, *可选*，默认为 2048^-0.5) : 用于初始化嵌入矩阵的 truncated_normal_initializer 的标准差。

layer_norm_eps (`float`, *可选*，默认为 `1e-12`)：层归一化层所使用的 epsilon。

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

unk_index (`int`，*可选*，默认为 3)：词汇表中未知令牌的索引。

mask_index (`int`，*可选*，默认为 5)：词汇表中掩码标记的索引。

is_encoder (`bool`, *可选*, 默认为 `True`) : 是否将初始化的模型设置为 Vaswani 等人中所述的 Transformer 编码器或解码器。

summary_type (`string`，*可选*，默认为 "first")：用于执行序列摘要时的参数。在序列分类和多选模型中使用。必须是以下选项之一： - `"last"`：取最后一个 token 的隐藏状态（如 XLNet）。 - `"first"`：取第一个 token 的隐藏状态（如 BERT）。 - `"mean"`：取所有 token 隐藏状态的均值。 - `"cls_index"`：提供一个分类 token 位置的 Tensor（如 GPT/GPT-2）。 - `"attn"`：目前未实现，使用多头注意力。

summary_use_proj (`bool`，*可选*，默认为 `True`)：用于执行序列摘要时的参数。在序列分类和多选模型中使用。是否在向量提取后添加投影层。

summary_activation (`str`, *可选*) : 执行序列摘要时使用的参数。用于序列分类和多选模型。传入 `"tanh"` 可对输出应用 tanh 激活函数，传入其他任何值则不应用激活函数。

summary_proj_to_labels (`bool`，*可选*，默认为 `True`)：用于序列分类和多选模型。指定投影输出应包含 `config.num_labels` 还是 `config.hidden_size` 个类别。

summary_first_dropout (`float`，*可选*，默认值为 0.1)：用于序列分类和多选模型。在投影和激活之后使用的 dropout 比率。

start_n_top (`int`，*可选*，默认值为 5)：用于 SQuAD 评估脚本。

end_n_top (`int`，*可选*，默认值为 5)：用于 SQuAD 评估脚本。

mask_token_id (`int`，*可选*，默认为 0)：一个与模型无关的参数，用于在 MLM 上下文中生成文本时识别被掩码的 token。

lang_id (`int`，*可选*，默认为 1)：模型所使用的语言 ID。此参数用于以指定语言生成文本。

pad_token_id (`int`，*可选*，默认为 `2`)：词表中用于填充的 Token id。

bos_token_id (`int`，*可选*，默认为 `0`)：词汇表中用于表示流开始的 token id。

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

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

这是用于存储 XLMModel 配置的类。它根据指定的参数实例化 Xlm 模型，并定义模型架构。使用默认值实例化配置将生成与 [FacebookAI/xlm-mlm-en-2048](https://huggingface.co/FacebookAI/xlm-mlm-en-2048) 类似的配置。

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

示例：

```python
>>> from transformers import XLMConfig, XLMModel

>>> # Initializing a XLM configuration
>>> configuration = XLMConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = XLMModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config
```

## XLMTokenizer[[transformers.XLMTokenizer]]

#### transformers.XLMTokenizer[[transformers.XLMTokenizer]]

```python
transformers.XLMTokenizer(vocab_file, merges_file, unk_token = '<unk>', bos_token = '<s>', sep_token = '</s>', pad_token = '<pad>', cls_token = '</s>', mask_token = '<special1>', additional_special_tokens = ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>'], lang2id = None, id2lang = None, do_lowercase_and_remove_accent = True, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/tokenization_xlm.py#L134)

**参数：**

vocab_file (`str`) : 词汇表文件。

merges_file (`str`) : 合并文件。

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

bos_token (`str`, *可选*, 默认为 `"<s>"`) : 预训练期间使用的序列起始标记。可用作序列分类标记。 在使用特殊标记构建序列时，序列起始处使用的并非此标记，而是 `cls_token`。

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

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

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

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

additional_special_tokens (`List[str]`，*可选*，默认为 `['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']`)：额外的特殊标记列表。

lang2id (`Dict[str, int]`，*可选*)：将语言字符串标识符映射到其 ID 的字典。

id2lang (`Dict[int, str]`，*可选*)：将语言 ID 映射到其字符串标识符的字典。

do_lowercase_and_remove_accent (`bool`，*可选*，默认为 `True`)：分词时是否将文本转换为小写并去除重音符号。

构建 XLM 分词器。基于字节对编码（Byte-Pair Encoding）。分词过程如下：

- 针对大多数受支持语言的 Moses 预处理和分词。
- 针对中文（Jieba）、日语（KyTea）和泰语（PyThaiNLP）的语言特定分词。
- 可选地对所有输入文本进行小写化和规范化处理。
- 参数 `special_tokens` 和函数 `set_special_tokens` 可用于向词汇表中添加额外的符号（例如 "__classify__"）。
- `lang2id` 属性将模型支持的语言与其 ID 进行映射（如果提供了 ID，则会自动为预训练词汇表设置）。
- 如果提供了 `id2lang` 属性，则执行反向映射（对于预训练词汇表会自动设置）。

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

#### build_inputs_with_special_tokens[[transformers.XLMTokenizer.build_inputs_with_special_tokens]]

```python
build_inputs_with_special_tokens(token_ids_0: list, token_ids_1: list[int] | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/tokenization_xlm.py#L475)

**参数：**

token_ids_0 (`List[int]`) : 将添加特殊标记的 ID 列表。

token_ids_1 (`List[int]`, *可选*) : 用于序列对的可选第二个 ID 列表。

**返回：** `List[int]`

包含相应特殊标记的[输入 ID](../glossary#input-ids)列表。

通过拼接并添加特殊标记，从单个序列或序列对构建用于序列分类任务的模型输入。XLM 序列的格式如下：

- 单条序列：`<s> X </s>`
- 序列对：`<s> A </s> B </s>`

#### get_special_tokens_mask[[transformers.XLMTokenizer.get_special_tokens_mask]]

```python
get_special_tokens_mask(token_ids_0: list, token_ids_1: list[int] | None = None, already_has_special_tokens: bool = False)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/tokenization_xlm.py#L502)

**参数：**

token_ids_0 (`List[int]`) : ID 列表。

token_ids_1 (`List[int]`, *可选*) : 用于序列对的可选第二个 ID 列表。

already_has_special_tokens (`bool`，*可选*，默认为 `False`)：标记列表是否已使用模型的特殊标记进行格式化。

**返回：** `List[int]`

一个整数列表，取值范围为 [0, 1]：1 表示特殊标记，0 表示序列标记。

从未添加特殊标记的标记列表中获取序列 ID。当使用分词器的 `prepare_for_model` 方法添加特殊标记时，会调用此方法。

#### create_token_type_ids_from_sequences[[transformers.XLMTokenizer.create_token_type_ids_from_sequences]]

```python
create_token_type_ids_from_sequences(token_ids_0: list, token_ids_1: list[int] | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/tokenization_python.py#L1298)

**参数：**

token_ids_0 (`list[int]`) : ID 列表。

token_ids_1 (`list[int]`, *可选*) : 用于序列对的可选第二个 ID 列表。

**返回：** `list[int]`

根据配置的模式生成的 Token 类型 ID。

创建一个掩码，该掩码由传入的两个序列生成，用于序列对分类任务。

此方法根据分词器的配置属性动态构建 token 类型 ID：
- `token_type_ids_pattern`：要使用的模式（"all_zeros" 或 "bert_style"）
- `token_type_ids_include_special_tokens`：在长度计算中是否考虑特殊标记

示例：
```python
# All zeros pattern (default, used by RoBERTa, BART, etc.)
tokenizer.token_type_ids_pattern = "all_zeros"
# Returns: [0, 0, 0, ...] for both sequences

# BERT-style pattern (first sequence gets 0s, second gets 1s)
tokenizer.token_type_ids_pattern = "bert_style"
# Returns: [0, 0, 0, ..., 1, 1, 1, ...] for sequence pairs
```

#### save_vocabulary[[transformers.XLMTokenizer.save_vocabulary]]

```python
save_vocabulary(save_directory: str, filename_prefix: str | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/tokenization_xlm.py#L530)

## XLM 特定输出[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]]

#### transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput[[transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput]]

```python
transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput(loss: typing.Optional[torch.Tensor] = None, start_top_log_probs: typing.Optional[torch.Tensor] = None, start_top_index: typing.Optional[torch.LongTensor] = None, end_top_log_probs: typing.Optional[torch.Tensor] = None, end_top_index: typing.Optional[torch.LongTensor] = None, cls_logits: typing.Optional[torch.Tensor] = None, hidden_states: tuple[torch.Tensor, ...] | None = None, attentions: tuple[torch.Tensor, ...] | None = None)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L638)

**参数：**

loss (`torch.Tensor`，形状为 `(1,)`，*可选*，当同时提供 `start_positions` 和 `end_positions` 时返回)：分类损失，为起始 token、结束 token（以及如果提供了 is_impossible 则包含其）分类损失的总和。

start_top_log_probs (`torch.Tensor`，形状为 `(batch_size, config.start_n_top)`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回)：前 config.start_n_top 个起始 token 可能性的对数概率（束搜索）。

start_top_index (`torch.LongTensor`，形状为 `(batch_size, config.start_n_top)`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回)：前 config.start_n_top 个起始 token 候选项的索引（束搜索）。

end_top_log_probs (`torch.Tensor`，形状为 `(batch_size, config.start_n_top * config.end_n_top)`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回)：前 `config.start_n_top * config.end_n_top` 个结束 token 可能性的对数概率（束搜索）。

end_top_index (`torch.LongTensor`，形状为 `(batch_size, config.start_n_top * config.end_n_top)`，*可选*，在 `start_positions` 或 `end_positions` 未提供时返回)：前 `config.start_n_top * config.end_n_top` 个结束 token 可能性（束搜索）的索引。

cls_logits (`torch.Tensor`，形状为 `(batch_size,)`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回)：答案的 `is_impossible` 标签的对数概率。

hidden_states (`tuple[torch.Tensor, ...]`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回)：`torch.Tensor` 的元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。

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

使用 `XLMSQuADHead` 的问答模型输出的基类。

## XLMModel[[transformers.XLMModel]]

#### transformers.XLMModel[[transformers.XLMModel]]

```python
transformers.XLMModel(config: XLMConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L667)

**参数：**

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

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

该模型继承自 [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.XLMModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L735)

**参数：**

input_ids (`torch.Tensor`，形状为 `(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)

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

langs (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射，从语言名称获得（仅适用于多语言模型）。更具体地说，*语言名称到语言 ID* 的映射位于 `model.config.lang2id`（一个从字符串到整数的字典），而 *语言 ID 到语言名称* 的映射位于 `model.config.id2lang`（一个从整数到字符串的字典）。有关详细的使用示例，请参阅 [多语言文档](../multilingual)。

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

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

lengths (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：每个句子的长度，可用于避免对填充标记索引执行注意力计算。您也可以使用 *attention_mask* 获得相同的结果（见上文），此处保留以兼容旧版本。所选索引位于 `[0, ..., input_ids.size(-1)]` 范围内。

cache (`dict[str, torch.Tensor]`, *可选*) : `EncoderDecoderCache` 的实例，包含预计算的 KV 状态。可用于加速顺序解码。

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) 而不是普通元组。

**返回：** [BaseModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.BaseModelOutput) 或 `tuple(torch.Tensor)`

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

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

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

- **last_hidden_state**（形状为 `(batch_size, sequence_length, hidden_size)` 的 `torch.Tensor`）-- 模型最后一层输出的隐藏状态序列。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

## XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]]

#### transformers.XLMWithLMHeadModel[[transformers.XLMWithLMHeadModel]]

```python
transformers.XLMWithLMHeadModel(config: XLMConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L913)

**参数：**

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

带有语言建模头（线性层，其权重与输入嵌入绑定）的 XLM 模型 Transformer。

该模型继承自 [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.XLMWithLMHeadModel.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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, logits_to_keep: typing.Union[int, torch.Tensor] = 0, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L957)

**参数：**

input_ids (`torch.Tensor`，形状为 `(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)

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

langs (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射，从语言名称获得（仅适用于多语言模型）。更具体地说，*语言名称到语言 ID* 的映射位于 `model.config.lang2id`（一个从字符串到整数的字典），而 *语言 ID 到语言名称* 的映射位于 `model.config.id2lang`（一个从整数到字符串的字典）。有关详细的使用示例，请参阅 [多语言文档](../multilingual)。

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

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

lengths (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：每个句子的长度，可用于避免对填充标记索引执行注意力计算。您也可以使用 *attention_mask* 获得相同的结果（见上文），此处保留以兼容旧版本。所选索引位于 `[0, ..., input_ids.size(-1)]` 范围内。

cache (`dict[str, torch.Tensor]`, *可选*) : `EncoderDecoderCache` 的实例，包含预计算的 KV 状态。可用于加速顺序解码。

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

labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*) : 用于语言建模的标签。请注意，模型内部会对标签进行**移位**，因此您可以设置 `labels = input_ids`。索引选自 `[-100, 0, ..., config.vocab_size]`。所有设置为 `-100` 的标签都会被忽略（被掩码），损失仅针对 `[0, ..., config.vocab_size]` 范围内的标签进行计算。

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

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

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

logits_to_keep (`Union[int, torch.Tensor]`，*可选*，默认为 `0`)：如果为 `int`，则计算最后 `logits_to_keep` 个 token 的 logits。如果为 `0`，则计算所有 `input_ids` 的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当可观。如果为 `torch.Tensor`，则必须是一维张量，对应于序列长度维度中需要保留的索引。这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。

**返回：** [MaskedLMOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.MaskedLMOutput) 或 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 掩码语言建模（MLM）损失。
- **logits**（形状为 `(batch_size, sequence_length, config.vocab_size)` 的 `torch.Tensor`）-- 语言建模头的预测分数（SoftMax 之前每个词汇表 token 的分数）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMWithLMHeadModel.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## XLMForSequenceClassification[[transformers.XLMForSequenceClassification]]

#### transformers.XLMForSequenceClassification[[transformers.XLMForSequenceClassification]]

```python
transformers.XLMForSequenceClassification(config: XLMConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1038)

**参数：**

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

在 XLM 模型顶部添加序列分类/回归头（即在池化输出之上添加一个线性层），例如用于 GLUE 任务。

该模型继承自 [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.XLMForSequenceClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L1050)

**参数：**

input_ids (`torch.Tensor`，形状为 `(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)

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

langs (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射，从语言名称获得（仅适用于多语言模型）。更具体地说，*语言名称到语言 ID* 的映射位于 `model.config.lang2id`（一个从字符串到整数的字典），而 *语言 ID 到语言名称* 的映射位于 `model.config.id2lang`（一个从整数到字符串的字典）。有关详细的使用示例，请参阅 [多语言文档](../multilingual)。

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

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

lengths (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：每个句子的长度，可用于避免对填充标记索引执行注意力计算。您也可以使用 *attention_mask* 获得相同的结果（见上文），此处保留以兼容旧版本。所选索引位于 `[0, ..., input_ids.size(-1)]` 范围内。

cache (`dict[str, torch.Tensor]`, *可选*) : `EncoderDecoderCache` 的实例，包含预计算的 KV 状态。可用于加速顺序解码。

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

labels (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：用于计算序列分类/回归损失的标签。索引应在 `[0, ..., config.num_labels - 1]` 范围内。如果 `config.num_labels == 1`，则计算回归损失（均方损失）；如果 `config.num_labels > 1`，则计算分类损失（交叉熵）。

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

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

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

**返回：** [SequenceClassifierOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.SequenceClassifierOutput) 或 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 分类损失（如果 config.num_labels==1，则为回归损失）。
- **logits**（形状为 `(batch_size, config.num_labels)` 的 `torch.Tensor`）-- 分类（或当 config.num_labels==1 时为回归）得分（SoftMax 之前）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **attentions** (`tuple(torch.Tensor)`，*可选*，当传入 `output_attentions=True` 或 `config.output_attentions=True` 时返回) -- 一个 `torch.Tensor` 元组（每层一个），形状为 `(batch_size, num_heads, sequence_length, sequence_length)`。

  经过注意力 softmax 后的注意力权重，用于在自注意力头中计算加权平均值。

单标签分类示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
...

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

多标签分类示例：

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = XLMForSequenceClassification.from_pretrained(
...     "FacebookAI/xlm-mlm-en-2048", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss
```

## XLMForMultipleChoice[[transformers.XLMForMultipleChoice]]

#### transformers.XLMForMultipleChoice[[transformers.XLMForMultipleChoice]]

```python
transformers.XLMForMultipleChoice(config: XLMConfig, *inputs, **kwargs)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1446)

**参数：**

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

在 Xlm 模型顶部添加多项选择分类头（在池化输出之上添加一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。

该模型继承自 [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.XLMForMultipleChoice.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L1457)

**参数：**

input_ids (`torch.LongTensor`，形状为 `(batch_size, num_choices, sequence_length)`)：输入序列标记在词汇表中的索引。可以使用 [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)

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

langs (`torch.LongTensor`，形状为 `(batch_size, num_choices, sequence_length)`，*可选*)：一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射，从语言名称获得（仅适用于多语言模型）。更具体地说，*语言名称到语言 ID* 的映射位于 `model.config.lang2id`（一个从字符串到整数的字典），而 *语言 ID 到语言名称* 的映射位于 `model.config.id2lang`（一个从整数到字符串的字典）。有关详细的使用示例，请参阅 [多语言文档](../multilingual)。

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

position_ids (`torch.LongTensor`，形状为 `(batch_size, num_choices, sequence_length)`，*可选*)：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.max_position_embeddings - 1]`。[什么是位置 ID？](../glossary#position-ids)

lengths (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：每个句子的长度，可用于避免对填充标记索引执行注意力计算。您也可以使用 *attention_mask* 获得相同的结果（见上文），此处保留以兼容旧版本。所选索引位于 `[0, ..., input_ids.size(-1)]` 范围内。

cache (`dict[str, torch.Tensor]`, *可选*) : `EncoderDecoderCache` 的实例，包含预计算的 KV 状态。可用于加速顺序解码。

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

labels (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：用于计算多项选择分类损失的标签。索引应在 `[0, ..., num_choices-1]` 范围内，其中 `num_choices` 是输入张量第二维的大小。（参见上文中的 `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) 而不是普通元组。

**返回：** [MultipleChoiceModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.MultipleChoiceModelOutput) 或 `tuple(torch.Tensor)`

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

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

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

- **loss**（形状为 *(1,)* 的 `torch.Tensor`，*可选*，在提供 `labels` 时返回）-- 分类损失。
- **logits**（形状为 `(batch_size, num_choices)` 的 `torch.Tensor`）-- *num_choices* 是输入张量的第二维（参见上方的 *input_ids*）。

  分类分数（SoftMax 之前）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **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, XLMForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForMultipleChoice.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits
```

## XLMForTokenClassification[[transformers.XLMForTokenClassification]]

#### transformers.XLMForTokenClassification[[transformers.XLMForTokenClassification]]

```python
transformers.XLMForTokenClassification(config: XLMConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1361)

**参数：**

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

在 Xlm transformer 之上添加一个用于 token 分类的头部（即在隐藏状态输出之上添加一个线性层），例如用于命名实体识别（NER）任务。

该模型继承自 [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.XLMForTokenClassification.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = 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/xlm/modeling_xlm.py#L1373)

**参数：**

input_ids (`torch.Tensor`，形状为 `(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)

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

langs (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射，从语言名称获得（仅适用于多语言模型）。更具体地说，*语言名称到语言 ID* 的映射位于 `model.config.lang2id`（一个从字符串到整数的字典），而 *语言 ID 到语言名称* 的映射位于 `model.config.id2lang`（一个从整数到字符串的字典）。有关详细的使用示例，请参阅 [多语言文档](../multilingual)。

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

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

lengths (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：每个句子的长度，可用于避免对填充标记索引执行注意力计算。您也可以使用 *attention_mask* 获得相同的结果（见上文），此处保留以兼容旧版本。所选索引位于 `[0, ..., input_ids.size(-1)]` 范围内。

cache (`dict[str, torch.Tensor]`, *可选*) : `EncoderDecoderCache` 的实例，包含预计算的 KV 状态。可用于加速顺序解码。

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

labels (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：用于计算 token 分类损失的标签。索引应在 `[0, ..., config.num_labels - 1]` 范围内。

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

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

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

**返回：** [TokenClassifierOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.TokenClassifierOutput) 或 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，在提供 `labels` 时返回) -- 分类损失。
- **logits**（形状为 `(batch_size, sequence_length, config.num_labels)` 的 `torch.Tensor`）-- 分类分数（SoftMax 之前）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **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, XLMForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForTokenClassification.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes
...

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
...
```

## XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]]

#### transformers.XLMForQuestionAnsweringSimple[[transformers.XLMForQuestionAnsweringSimple]]

```python
transformers.XLMForQuestionAnsweringSimple(config: XLMConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1144)

**参数：**

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

XLM 模型，顶部带有用于 SQuAD 等抽取式问答任务的跨度分类头（在隐藏状态输出之上添加一个线性层，用于计算`span start logits`和`span end logits`）。

该模型继承自 [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.XLMForQuestionAnsweringSimple.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: 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/xlm/modeling_xlm.py#L1154)

**参数：**

input_ids (`torch.Tensor`，形状为 `(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)

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

langs (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射，从语言名称获得（仅适用于多语言模型）。更具体地说，*语言名称到语言 ID* 的映射位于 `model.config.lang2id`（一个从字符串到整数的字典），而 *语言 ID 到语言名称* 的映射位于 `model.config.id2lang`（一个从整数到字符串的字典）。有关详细的使用示例，请参阅 [多语言文档](../multilingual)。

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

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

lengths (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：每个句子的长度，可用于避免对填充标记索引执行注意力计算。您也可以使用 *attention_mask* 获得相同的结果（见上文），此处保留以兼容旧版本。所选索引位于 `[0, ..., input_ids.size(-1)]` 范围内。

cache (`dict[str, torch.Tensor]`, *可选*) : `EncoderDecoderCache` 的实例，包含预计算的 KV 状态。可用于加速顺序解码。

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

start_positions (`torch.Tensor`，形状为 `(batch_size,)`，*可选*)：用于计算 token 分类损失的标注跨度起始位置（索引）的标签。位置会被截断至序列长度（`sequence_length`）。序列之外的位置在计算损失时不予考虑。

end_positions (`torch.Tensor`，形状为 `(batch_size,)`，*可选*)：用于计算 token 分类损失的标注跨度结束位置（索引）的标签。位置会被截断至序列长度（`sequence_length`）。序列之外的位置在计算损失时不予考虑。

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

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

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

**返回：** [QuestionAnsweringModelOutput](/docs/transformers/main/zh/main_classes/output#transformers.modeling_outputs.QuestionAnsweringModelOutput) 或 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当提供 `labels` 时返回) -- 总跨度提取损失是起始位置和结束位置的交叉熵之和。
- **start_logits**（形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`）-- 跨度起始分数（SoftMax 之前）。
- **end_logits**（形状为 `(batch_size, sequence_length)` 的 `torch.Tensor`）-- 跨度结束分数（SoftMax 之前）。
- **hidden_states** (`tuple(torch.Tensor)`，*可选*，在传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层的输出，以及每一层的输出），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **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, XLMForQuestionAnsweringSimple
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForQuestionAnsweringSimple.from_pretrained("FacebookAI/xlm-mlm-en-2048")

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

## XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]]

#### transformers.XLMForQuestionAnswering[[transformers.XLMForQuestionAnswering]]

```python
transformers.XLMForQuestionAnswering(config: XLMConfig)
```

[来源](https://github.com/huggingface/transformers/blob/main/src/transformers/models/xlm/modeling_xlm.py#L1243)

**参数：**

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

带有用于抽取式问答任务（如 SQuAD）的跨度分类头的 Xlm transformer（在隐藏状态输出之上添加一个线性层，用于计算 `span start logits` 和 `span end logits`）。

该模型继承自 [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.XLMForQuestionAnswering.forward]]

```python
forward(input_ids: typing.Optional[torch.Tensor] = None, attention_mask: typing.Optional[torch.Tensor] = None, langs: typing.Optional[torch.Tensor] = None, token_type_ids: typing.Optional[torch.Tensor] = None, position_ids: typing.Optional[torch.Tensor] = None, lengths: typing.Optional[torch.Tensor] = None, cache: dict[str, torch.Tensor] | None = None, inputs_embeds: typing.Optional[torch.Tensor] = None, start_positions: typing.Optional[torch.Tensor] = None, end_positions: typing.Optional[torch.Tensor] = None, is_impossible: typing.Optional[torch.Tensor] = None, cls_index: typing.Optional[torch.Tensor] = None, p_mask: 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/xlm/modeling_xlm.py#L1253)

**参数：**

input_ids (`torch.Tensor`，形状为 `(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)

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

langs (`torch.LongTensor`，形状为 `(batch_size, sequence_length)`，*可选*)：一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射，从语言名称获得（仅适用于多语言模型）。更具体地说，*语言名称到语言 ID* 的映射位于 `model.config.lang2id`（一个从字符串到整数的字典），而 *语言 ID 到语言名称* 的映射位于 `model.config.id2lang`（一个从整数到字符串的字典）。有关详细的使用示例，请参阅 [多语言文档](../multilingual)。

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

position_ids （`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*）：输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 `[0, config.n_positions - 1]`。[什么是位置 ID？](../glossary#position-ids)

lengths (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：每个句子的长度，可用于避免对填充标记索引执行注意力计算。您也可以使用 *attention_mask* 获得相同的结果（见上文），此处保留以兼容旧版本。所选索引位于 `[0, ..., input_ids.size(-1)]` 范围内。

cache (`dict[str, torch.Tensor]`, *可选*) : `EncoderDecoderCache` 的实例，包含预计算的 KV 状态。可用于加速顺序解码。

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

start_positions (`torch.Tensor`，形状为 `(batch_size,)`，*可选*)：用于计算 token 分类损失的标注跨度起始位置（索引）的标签。位置会被截断至序列长度（`sequence_length`）。序列之外的位置在计算损失时不予考虑。

end_positions (`torch.Tensor`，形状为 `(batch_size,)`，*可选*)：用于计算 token 分类损失的标注跨度结束位置（索引）的标签。位置会被截断至序列长度（`sequence_length`）。序列之外的位置在计算损失时不予考虑。

is_impossible (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：标签，指示问题是否有答案（SQuAD 2.0）

cls_index (`torch.LongTensor`，形状为 `(batch_size,)`，*可选*)：用于计算答案合理性的分类标记的位置（索引）标签。

p_mask (`torch.Tensor`，形状为 `(batch_size, sequence_length)`，*可选*)：可选的标记掩码，用于指示哪些标记不能出现在答案中（例如 [CLS]、[PAD] 等）。1.0 表示该标记应被掩码，0.0 表示该标记未被掩码。

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

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

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

**返回：** [XLMForQuestionAnsweringOutput](/docs/transformers/main/zh/model_doc/xlm#transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput) 或 `tuple(torch.Tensor)`

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

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

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

- **loss** (`torch.Tensor`，形状为 `(1,)`，*可选*，当同时提供 `start_positions` 和 `end_positions` 时返回) -- 分类损失，为起始 token、结束 token（以及如果提供了 is_impossible 则包含其）分类损失的总和。
- **start_top_log_probs** (`torch.Tensor`，形状为 `(batch_size, config.start_n_top)`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回) -- 前 config.start_n_top 个起始 token 可能性的对数概率（束搜索）。
- **start_top_index** (`torch.LongTensor`，形状为 `(batch_size, config.start_n_top)`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回) -- 前 config.start_n_top 个起始 token 候选项的索引（束搜索）。
- **end_top_log_probs**（形状为 `(batch_size, config.start_n_top * config.end_n_top)` 的 `torch.Tensor`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回）-- 前 `config.start_n_top * config.end_n_top` 个结束 token 可能性的对数概率（束搜索）。
- **end_top_index**（形状为 `(batch_size, config.start_n_top * config.end_n_top)` 的 `torch.LongTensor`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回）-- 前 `config.start_n_top * config.end_n_top` 个结束 token 候选项的索引（束搜索）。
- **cls_logits**（形状为 `(batch_size,)` 的 `torch.Tensor`，*可选*，当未提供 `start_positions` 或 `end_positions` 时返回）-- 答案的 `is_impossible` 标签的对数概率。
- **hidden_states** (`tuple[torch.Tensor, ...]`，*可选*，当传入 `output_hidden_states=True` 或 `config.output_hidden_states=True` 时返回) -- 一个 `torch.Tensor` 元组（如果模型具有嵌入层，则包含嵌入层输出的一个张量，以及每个层输出的一个张量），形状为 `(batch_size, sequence_length, hidden_size)`。

  模型在每一层输出处的隐藏状态，以及可选的初始嵌入输出。
- **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, XLMForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/xlm-mlm-en-2048")
>>> model = XLMForQuestionAnswering.from_pretrained("FacebookAI/xlm-mlm-en-2048")

>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
...     0
... )  # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])

>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss
```