Transformers 4.37 中文文档（六十一）（4）

Transformers 4.37 中文文档（六十一）（3）https://developer.aliyun.com/article/1564139

XLM

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/xlm

概述

XLM 模型是由 Guillaume Lample、Alexis Conneau 在跨语言语言模型预训练中提出的。它是一个使用以下目标之一进行预训练的变压器：

• 一个因果语言建模（CLM）目标（下一个令牌预测），
  
• 一个遮蔽语言建模（MLM）目标（类似于 BERT），或
  
• 一个翻译语言建模（TLM）对象（BERT 的 MLM 扩展到多语言输入）
  

这篇论文的摘要如下：

最近的研究表明了对英语自然语言理解的生成式预训练的有效性。在这项工作中，我们将这种方法扩展到多种语言，并展示了跨语言预训练的有效性。我们提出了两种学习跨语言语言模型（XLM）的方法：一种无监督的方法，只依赖于单语数据，另一种是有监督的方法，利用具有新的跨语言语言模型目标的平行数据。我们在跨语言分类、无监督和有监督机器翻译方面取得了最新的结果。在  XNLI 上，我们的方法将准确率绝对提高了 4.9%。在无监督机器翻译上，我们在 WMT’16 德语-英语上获得了 34.3  BLEU，比之前的最新技术提高了超过 9 BLEU。在有监督机器翻译上，我们在 WMT’16 罗马尼亚语-英语上获得了 38.5 BLEU  的最新技术，超过之前最佳方法超过 4 BLEU。我们的代码和预训练模型将公开发布。

这个模型是由thomwolf贡献的。原始代码可以在这里找到。

使用提示

• XLM 有许多不同的检查点，它们是使用不同目标进行训练的：CLM、MLM 或 TLM。确保为您的任务选择正确的目标（例如，MLM 检查点不适合生成）。
  
• XLM 有多语言检查点，利用特定的lang参数。查看多语言页面获取更多信息。
  
• 一个在多种语言上训练的变压器模型。这个模型有三种不同类型的训练，库提供了所有这些训练的检查点：

• 因果语言建模（CLM）是传统的自回归训练（因此这个模型也可以在前一节中）。每个训练样本选择一种语言，模型输入是一个 256 个令牌的句子，可能跨越一个或多个文档中的某种语言。
  
• 遮蔽语言建模（MLM），类似于 RoBERTa。每个训练样本选择一种语言，模型输入是一个 256 个令牌的句子，可能跨越一个或多个文档中的某种语言，并动态遮蔽令牌。
  
• MLM 和翻译语言建模（TLM）的组合。这包括将两种不同语言的句子连接起来，进行随机遮蔽。为了预测其中一个被遮蔽的令牌，模型可以同时使用语言 1 中的周围上下文和语言 2 给出的上下文。
  

资源

• 文本分类任务指南
  
• 令牌分类任务指南
  
• 问答任务指南
  
• 因果语言建模任务指南
  
• 遮蔽语言建模任务指南
  
• 多选任务指南
  

XLMConfig

class transformers.XLMConfig

<来源>

( vocab_size = 30145 emb_dim = 2048 n_layers = 12 n_heads = 16 dropout = 0.1 attention_dropout = 0.1 gelu_activation = True sinusoidal_embeddings = False causal = False asm = False n_langs = 1 use_lang_emb = True max_position_embeddings = 512 embed_init_std = 0.02209708691207961 layer_norm_eps = 1e-12 init_std = 0.02 bos_index = 0 eos_index = 1 pad_index = 2 unk_index = 3 mask_index = 5 is_encoder = True summary_type = 'first' summary_use_proj = True summary_activation = None summary_proj_to_labels = True summary_first_dropout = 0.1 start_n_top = 5 end_n_top = 5 mask_token_id = 0 lang_id = 0 pad_token_id = 2 bos_token_id = 0 **kwargs )

参数

• vocab_size (int, optional, 默认为 30145) — BERT 模型的词汇表大小。定义在调用 XLMModel 或 TFXLMModel 时可以由inputs_ids表示的不同标记数量。
  
• emb_dim (int, optional, 默认为 2048) — 编码器层和池化器层的维度。
  
• n_layer (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数量。
  
• n_head (int, optional, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数量。
  
• dropout (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
  
• attention_dropout (float, optional, 默认为 0.1) — 注意机制的丢失概率。
  
• gelu_activation (bool, optional, 默认为True) — 是否使用gelu作为激活函数，而不是relu。
  
• sinusoidal_embeddings (bool, optional, 默认为False) — 是否使用正弦位置嵌入而不是绝对位置嵌入。
  
• causal (bool, optional, 默认为False) — 模型是否应该以因果方式运行。因果模型使用三角形注意力掩码，以便只关注左侧上下文而不是双向上下文。
  
• asm (bool, optional, 默认为False) — 是否使用自适应对数 softmax 投影层，而不是线性层进行预测。
  
• n_langs (int, optional, 默认为 1) — 模型处理的语言数量。对于单语模型，设置为 1。
  
• use_lang_emb (bool, optional, 默认为True) — 是否使用语言嵌入。一些模型使用额外的语言嵌入，请参阅多语言模型页面了解如何使用它们。
  
• max_position_embeddings (int, optional, 默认为 512) — 该模型可能使用的最大序列长度。通常设置为较大的值以防万一（例如 512 或 1024 或 2048）。
  
• embed_init_std (float, optional, 默认为 2048^-0.5) — 用于初始化嵌入矩阵的截断正态初始化器的标准差。
  
• init_std (int, optional, 默认为 50257) — 用于初始化除嵌入矩阵之外的所有权重矩阵的截断正态初始化器的标准差。
  
• layer_norm_eps (float, optional, 默认为 1e-12) — 层归一化层使用的 epsilon。
  
• bos_index (int, optional, 默认为 0) — 词汇表中句子开头标记的索引。
  
• eos_index (int, optional, 默认为 1) — 词汇表中句子结束标记的索引。
  
• pad_index (int, optional, 默认为 2) — 词汇表中填充标记的索引。
  
• unk_index (int, optional, 默认为 3) — 词汇表中未知标记的索引。
  
• mask_index (int, optional, 默认为 5) — 词汇表中掩码标记的索引。
  
• is_encoder(bool, optional, 默认为True) — 初始化模型是否应该是 Transformer 编码器或解码器，如 Vaswani 等人所见。
  
• summary_type (string, optional, 默认为“first”) — 在进行序列摘要时使用的参数。用于序列分类和多选模型。必须是以下选项之一：

• "last": 获取最后一个标记的隐藏状态（类似于 XLNet）。
  
• "first": 获取第一个标记的隐藏状态（类似于 BERT）。
  
• "mean": 获取所有标记的隐藏状态的平均值。
  
• "cls_index": 提供一个分类标记位置的张量（如 GPT/GPT-2）。
  
• "attn": 目前未实现，使用多头注意力。
  

• summary_use_proj (bool, optional, defaults to True) — 在进行序列摘要时使用的参数。用于序列分类和多选模型。
  是否在向量提取后添加投影。
  
• summary_activation (str, optional) — 在进行序列摘要时使用的参数。用于序列分类和多选模型。
  将 "tanh" 传递给输出以获得 tanh 激活，任何其他值将导致无激活。
  
• summary_proj_to_labels (bool, optional, defaults to True) — 用于序列分类和多选模型。
  投影输出应具有 config.num_labels 或 config.hidden_size 类。
  
• summary_first_dropout (float, optional, defaults to 0.1) — 用于序列分类和多选模型。
  在投影和激活后使用的丢弃比率。
  
• start_n_top (int, optional, defaults to 5) — 在 SQuAD 评估脚本中使用。
  
• end_n_top (int, optional, defaults to 5) — 在 SQuAD 评估脚本中使用。
  
• mask_token_id (int, optional, defaults to 0) — 用于在 MLM 上下文中生成文本时识别掩码标记的模型不可知参数。
  
• lang_id (int, optional, defaults to 1) — 模型使用的语言的 ID。在生成给定语言的文本时使用此参数。
  

这是用于存储 XLMModel 或 TFXLMModel 配置的配置类。根据指定的参数实例化 XLM 模型，定义模型架构。使用默认值实例化配置将产生类似于 xlm-mlm-en-2048 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

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

class transformers.XLMTokenizer

< source >

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

参数

• vocab_file (str) — 词汇文件。
  
• merges_file (str) — 合并文件。
  
• unk_token (str, optional, defaults to "") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
  
• bos_token (str, optional, defaults to "") — 在预训练期间使用的序列开始标记。可以用作序列分类器标记。
  在使用特殊标记构建序列时，这不是用于序列开头的标记。使用的标记是 cls_token。
  
• sep_token (str, optional, defaults to "") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于问题回答的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。
  
• pad_token (str, optional, defaults to "") — 用于填充的标记，例如在批处理不同长度的序列时。
  
• cls_token (str, optional, defaults to "") — 在进行序列分类时使用的分类器标记（对整个序列进行分类而不是每个标记的分类）。在使用特殊标记构建时，它是序列的第一个标记。
  
• mask_token (str, optional, 默认为 "") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
  
• additional_special_tokens (List[str], optional, 默认为 ['',  '', '', '',  '', '', '',  '', '', '']) — 附加特殊标记的列表。
  
• lang2id (Dict[str, int], optional) — 将语言字符串标识符映射到它们的 ID 的字典。
  
• id2lang (Dict[int, str], optional) — 将语言 ID 映射到它们的字符串标识符的字典。
  
• do_lowercase_and_remove_accent (bool, optional, 默认为 True) — 在标记化时是否小写并去除重音。
  

构建 XLM 分词器。基于字节对编码。分词过程如下：

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

此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
  
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。
  

返回

List[int]

具有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。XLM 序列具有以下格式：

• 单个序列： X
  
• 序列对： A B
  

get_special_tokens_mask

<来源>

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
  
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。
  
• already_has_special_tokens (bool, optional, 默认为 False) — 标记列表是否已经为模型格式化了特殊标记。
  

返回

List[int]

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

从没有添加特殊标记的标记列表中检索序列 ID。在使用 tokenizer prepare_for_model方法添加特殊标记时调用此方法。

create_token_type_ids_from_sequences

<来源>

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

• token_ids_0 (List[int]) — ID 列表。
  
• token_ids_1 (List[int], optional) — 可选的第二个 ID 列表，用于序列对。
  

返回

List[int]

根据给定序列的 token type IDs 列表。

创建用于序列对分类任务的两个序列的掩码。一个 XLM 序列

对偶掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 为 None，则此方法仅返回掩码的第一部分（0s）。

save_vocabulary

<来源>

( save_directory: str filename_prefix: Optional = None )

XLM 特定输出

class transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput

<来源>

( loss: Optional = None start_top_log_probs: Optional = None start_top_index: Optional = None end_top_log_probs: Optional = None end_top_index: Optional = None cls_logits: Optional = None hidden_states: Optional = None attentions: Optional = None )

参数

• loss (torch.FloatTensor，形状为(1,)，可选，如果提供了start_positions和end_positions则返回) — 分类损失，作为开始标记、结束标记（如果提供了 is_impossible 则包括）分类损失的总和。
  
• start_top_log_probs (torch.FloatTensor，形状为(batch_size, config.start_n_top)，可选，如果未提供start_positions或end_positions则返回) — 顶部 config.start_n_top 开始标记可能性的对数概率（波束搜索）。
  
• start_top_index (torch.LongTensor，形状为(batch_size, config.start_n_top)，可选，如果未提供start_positions或end_positions则返回) — 顶部 config.start_n_top 开始标记可能性的索引（波束搜索）。
  
• end_top_log_probs (torch.FloatTensor，形状为(batch_size, config.start_n_top * config.end_n_top)，可选，如果未提供start_positions或end_positions则返回) — 顶部config.start_n_top * config.end_n_top结束标记可能性的对数概率（波束搜索）。
  
• 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结束标记可能性的索引（波束搜索）。
  
• cls_logits (torch.FloatTensor，形状为(batch_size,)，可选，如果未提供start_positions或end_positions则返回) — 答案的is_impossible标签的对数概率。
  
• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（一个用于嵌入的输出 + 一个用于每层的输出）。
  模型在每层输出的隐藏状态以及初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
  

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

Pytorch 隐藏了 Pytorch 内容

XLMModel

class transformers.XLMModel

<来源>

( config )

参数

• config (XLMConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

裸 XLM 模型变压器输出原始隐藏状态，没有特定的头部。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch torch.nn.Module的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般使用和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None langs: Optional = None token_type_ids: Optional = None position_ids: Optional = None lengths: Optional = None cache: Optional = None head_mask: Optional = None inputs_embeds: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：

• 1 表示未被遮蔽的标记，
  
• 0 表示被遮蔽的标记。
  

• 什么是注意力掩码？
  
• langs (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于指示输入中每个标记的语言的并行标记序列。索引是语言 ID，可以通过模型配置中提供的两个转换映射从语言名称中获取（仅适用于多语言模型）。更准确地说，语言名称到语言 ID 映射在 model.config.lang2id 中（这是一个字符串到整数的字典），语言 ID 到语言名称 映射在 model.config.id2lang 中（整数到字符串的字典）。
  详细使用示例请参见多语言文档。
  
• token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

• 0 对应于 句子 A 标记。
  
• 1 对应于 句子 B 标记。
  

• 什么是标记类型 ID？
  
• position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。
  什么是位置 ID？
  
• lengths (torch.LongTensor of shape (batch_size,), optional) — 每个句子的长度，可用于避免在填充标记索引上执行注意力。您也可以使用attention_mask获得相同的结果（见上文），这里保留是为了兼容性。所选索引在 [0, ..., input_ids.size(-1)]。
  
• cache (Dict[str, torch.FloatTensor], optional) — 包含模型计算的预计算隐藏状态（关键和值在注意力块中）的字符串到 torch.FloatTensor 的字典。可用于加速顺序解码。
  字典对象将在前向传递期间就地修改以添加新计算的隐藏状态。
  
• head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在 [0, 1]：

• 1 表示头部未被遮蔽，
  
• 0 表示头部被遮蔽。
  

• inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
  
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多细节，请查看返回张量下的attentions。
  
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多细节，请查看返回张量下的hidden_states。
  
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
  

返回

transformers.modeling_outputs.BaseModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（XLMConfig）和输入。

• last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
  
• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出的一个+每一层的输出的一个）。
  模型在每一层的隐藏状态以及可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。
  

XLMModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在之后调用Module实例，而不是这个，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, XLMModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlm-mlm-en-2048")
>>> model = XLMModel.from_pretrained("xlm-mlm-en-2048")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

XLMWithLMHeadModel

class transformers.XLMWithLMHeadModel

<来源>

( config )

参数

• config（XLMConfig） — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

XLM 模型变压器，顶部带有语言建模头（线性层，其权重与输入嵌入绑定）。

此模型继承自 PreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法（如下载或保存、调整输入嵌入、修剪头等）。

此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None langs: Optional = None token_type_ids: Optional = None position_ids: Optional = None lengths: Optional = None cache: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput or tuple(torch.FloatTensor)

参数

• input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 输入序列标记在词汇表中的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
  什么是输入 ID？
  
• attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：

• 1 表示未被masked的标记，
  
• 0 表示被masked的标记。
  

• 什么是注意力掩码？
  
• langs（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 用于指示输入中每个标记的语言的并行标记序列。索引是语言 ID，可以通过模型配置中提供的两个转换映射从语言名称中获取（仅适用于多语言模型）。更准确地说，语言名称到语言 ID映射在model.config.lang2id中（这是一个字符串到整数的字典），语言 ID 到语言名称映射在model.config.id2lang中（整数到字符串的字典）。
  请参阅多语言文档中详细的用法示例。
  
• token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

• 0 对应于句子 A标记，
  
• 1 对应于句子 B标记。
  

• 什么是标记类型 ID？
  
• position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
  什么是位置 ID？
  
• lengths（形状为(batch_size,)的torch.LongTensor，可选）— 每个句子的长度，可用于避免在填充标记索引上执行注意力。您也可以使用attention_mask获得相同的结果（请参见上文），这里保留是为了兼容性。在[0, ..., input_ids.size(-1)]中选择的索引。
  
• cache（Dict[str, torch.FloatTensor]，可选）— 包含由模型计算的预计算隐藏状态（键和值在注意力块中）的字符串到torch.FloatTensor的字典。可用于加速顺序解码。
  在前向传递期间，字典对象将被就地修改以添加新计算的隐藏状态。
  
• head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块中的选定头部失效的掩码。掩码值在[0, 1]中选择：

• 1 表示头部未被masked，
  
• 0 表示头部被masked。
  

• inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
  
• output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
  
• output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
  
• return_dict (bool, 可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
  
• labels (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 用于语言建模的标签。注意，模型内部移动标签，即可以设置labels = input_ids。在[-100, 0, ..., config.vocab_size]中选择索引。所有设置为-100的标签都被忽略（掩码），损失仅计算标签在[0, ..., config.vocab_size]中的标签。
  

返回

transformers.modeling_outputs.MaskedLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（XLMConfig）和输入。

• loss (torch.FloatTensor of shape (1,), 可选, 当提供labels时返回) — 掩码语言建模（MLM）损失。
  
• logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。
  
• hidden_states (tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — torch.FloatTensor元组（一个用于嵌入层的输出，如果模型有嵌入层，+ 一个用于每个层的输出）的形状为(batch_size, sequence_length, hidden_size)。
  模型在每个层的输出的隐藏状态加上可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或config.output_attentions=True时返回) — torch.FloatTensor元组（每个层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。
  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
  

XLMWithLMHeadModel 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此处调用，因为前者会负责运行前处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, XLMWithLMHeadModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlm-mlm-en-2048")
>>> model = XLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048")
>>> inputs = tokenizer("The capital of France is <special1>.", return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> # retrieve index of <special1>
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]
>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<special1> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)

XLMForSequenceClassification

class transformers.XLMForSequenceClassification

<来源>

( config )

参数

• config (XLMConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，只加载配置。查看 from_pretrained()方法以加载模型权重。

XLM 模型，顶部带有一个序列分类/回归头部（在汇总输出的顶部有一个线性层），例如用于 GLUE 任务。

此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法（例如下载或保存、调整输入嵌入、修剪头等）。

这个模型也是一个 PyTorch torch.nn.Module子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。

forward

<来源>

( input_ids: Optional = None attention_mask: Optional = None langs: Optional = None token_type_ids: Optional = None position_ids: Optional = None lengths: Optional = None cache: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput or tuple(torch.FloatTensor)

参数

• input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
  可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
  什么是 input IDs？
  
• attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

• 1 对应于 未被 masked 的标记，
  
• 0 代表被 masked 的标记。
  

• 什么是 attention masks？
  
• langs (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于指示输入中每个标记的语言的并行标记序列。索引是语言 id，可以通过模型配置中提供的两个转换映射从语言名称中获取（仅适用于多语言模型）。更准确地说，语言名称到语言 id 映射在 model.config.lang2id 中（这是一个字符串到整数的字典），语言 id 到语言名称 映射在 model.config.id2lang 中（整数到字符串的字典）。
  查看详细的用法示例，详见多语言文档。
  
• token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：

• 0 对应于 句子 A 标记，
  
• 1 对应于 句子 B 标记。
  

• 什么是 token type IDs？
  
• position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  什么是 position IDs？
  
• lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免在填充标记索引上执行注意力。您也可以使用 attention_mask 获得相同的结果（见上文），这里保留以保持兼容性。索引在 [0, ..., input_ids.size(-1)] 中选择。
  
• cache (Dict[str, torch.FloatTensor]，可选) — 包含由模型计算得出的预计算隐藏状态（注意力块中的键和值）的字符串到 torch.FloatTensor 的字典。可用于加速顺序解码。
  在前向传递期间，字典对象将被就地修改以添加新计算的隐藏状态。
  
• head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1] 中选择：

• 1 表示头部未被 masked，
  
• 0 表示头部被 masked。
  

• inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
  
• output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请查看返回张量下的attentions。
  
• output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
  
• return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
  
• labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。
  

返回

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(XLMConfig)和输入的各种元素。

• loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
  
• logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）得分（SoftMax 之前）。
  
• hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层的输出，则为嵌入层输出的一个+每层输出的一个）。
  模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  
• attentions (tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
  注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。
  

XLMForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

虽然前向传递的方法需要在此函数内定义，但应该在此之后调用Module实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默忽略它们。

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, XLMForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("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()
>>> # 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("xlm-mlm-en-2048", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, XLMForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlm-mlm-en-2048")
>>> model = XLMForSequenceClassification.from_pretrained("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(
...     "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

Transformers 4.37 中文文档（六十一）（5）https://developer.aliyun.com/article/1564141