Transformers 文档

XLM

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

在模型、数据集和 Spaces 上进行协作

通过加速推理获得更快的示例

切换文档主题

开始使用

XLM

XLM 通过两种方法展示了跨语言预训练：对单一语言进行无监督训练，以及使用跨语言语言模型目标对多种语言进行有监督训练。XLM 模型支持因果语言建模目标、掩码语言建模和翻译语言建模（这是 BERT 掩码语言建模目标对多语言输入的扩展）。

你可以在 Facebook AI 社区组织下找到所有原始的 XLM 检查点。

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

以下示例演示了如何使用 Pipeline、AutoModel 以及从命令行预测 <mask> 标记。

流水线

自动模型

Transformers CLI

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，可选，默认为 30145) — BERT 模型的词汇表大小。定义在调用 XLMModel 或 TFXLMModel 时，可以通过 inputs_ids 表示的不同标记的数量。
emb_dim (int，可选，默认为 2048) — 编码器层和池化层的维度。
n_layer (int，可选，默认为 12) — Transformer 编码器中的隐藏层数。
n_head (int，可选，默认为 16) — Transformer 编码器中每个注意力层的注意力头数量。
dropout (float，可选，默认为 0.1) — 嵌入层、编码器和池化层中所有全连接层的丢弃概率。
attention_dropout (float，可选，默认为 0.1) — 注意力机制的丢弃概率。
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) — 是否使用语言嵌入。一些模型使用额外的语言嵌入，请参阅多语言模型页面了解如何使用它们。
max_position_embeddings (int，可选，默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以备不时之需（例如，512、1024 或 2048）。
embed_init_std (float，可选，默认为 2048^-0.5) — 用于初始化嵌入矩阵的 truncated_normal_initializer 的标准差。
init_std (int，可选，默认为 50257) — 用于初始化除嵌入矩阵外的所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float，可选，默认为 1e-12) — 层归一化层使用的 epsilon 值。
bos_index (int，可选，默认为 0) — 词汇表中句子开头标记的索引。
eos_index (int，可选，默认为 1) — 词汇表中句子结束标记的索引。
pad_index (int，可选，默认为 2) — 词汇表中填充标记的索引。
unk_index (int，可选，默认为 3) — 词汇表中未知标记的索引。
mask_index (int，可选，默认为 5) — 词汇表中掩码标记的索引。
is_encoder(bool， 可选，默认为 True) — 初始化的模型是否应为 Transformer 编码器或解码器，如 Vaswani 等人论文中所见。
summary_type (string, optional, 默认为 “first”) — 用于序列摘要的参数。在序列分类和多项选择模型中使用。

必须是以下选项之一：
- "last": 取最后一个词元的隐藏状态（如 XLNet）。
- "first": 取第一个词元的隐藏状态（如 BERT）。
- "mean": 取所有词元隐藏状态的平均值。
- "cls_index": 提供一个分类词元位置的张量（如 GPT/GPT-2）。
- "attn": 目前未实现，使用多头注意力。
summary_use_proj (bool, optional, 默认为 True) — 用于序列摘要的参数。在序列分类和多项选择模型中使用。

是否在向量提取后添加一个投影层。
summary_activation (str, optional) — 用于序列摘要的参数。在序列分类和多项选择模型中使用。

传递 "tanh" 以对输出应用 tanh 激活函数，任何其他值都将不使用激活函数。
summary_proj_to_labels (bool, optional, 默认为 True) — 在序列分类和多项选择模型中使用。

投影输出的类别数是 config.num_labels 还是 config.hidden_size。
summary_first_dropout (float, optional, 默认为 0.1) — 在序列分类和多项选择模型中使用。

在投影和激活后使用的 dropout 比率。
start_n_top (int, optional, 默认为 5) — 在 SQuAD 评估脚本中使用。
end_n_top (int, optional, 默认为 5) — 在 SQuAD 评估脚本中使用。
mask_token_id (int, optional, 默认为 0) — 模型无关的参数，用于在 MLM 上下文中生成文本时识别被掩码的词元。
lang_id (int, optional, 默认为 1) — 模型使用的语言 ID。此参数在以给定语言生成文本时使用。

这是一个配置类，用于存储 XLMModel 或 TFXLMModel 的配置。它用于根据指定的参数实例化一个 XLM 模型，定义了模型的架构。使用默认值实例化一个配置将产生一个与 FacebookAI/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

< 来源 >

( 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, 默认为 "<unk>") — 未知词元。词汇表中不存在的词元无法转换为 ID，将被设置为此词元。
bos_token (str, optional, 默认为 "<s>") — 在预训练期间使用的序列开始词元。可以用作序列分类器词元。

当使用特殊词元构建序列时，这不是用于序列开始的词元。使用的词元是 cls_token。
sep_token (str, optional, 默认为 "</s>") — 分隔符词元，用于从多个序列构建一个序列时使用，例如用于序列分类的两个序列，或用于问答任务的文本和问题。它也用作使用特殊词元构建的序列的最后一个词元。
pad_token (str, optional, 默认为 "<pad>") — 用于填充的词元，例如当批处理不同长度的序列时使用。
cls_token (str, optional, 默认为 "</s>") — 分类器词元，用于进行序列分类（对整个序列进行分类，而不是逐词元分类）。当使用特殊词元构建序列时，它是序列的第一个词元。
mask_token (str, optional, 默认为 "<special1>") — 用于掩码值的词元。这是使用掩码语言建模训练此模型时使用的词元。模型将尝试预测此词元。
additional_special_tokens (List[str], optional, 默认为 ['<special0>', '<special1>', '<special2>', '<special3>', '<special4>', '<special5>', '<special6>', '<special7>', '<special8>', '<special9>']) — 附加特殊词元列表。
lang2id (Dict[str, int], optional) — 将语言字符串标识符映射到其 ID 的字典。
id2lang (Dict[int, str], optional) — 将语言 ID 映射到其字符串标识符的字典。
do_lowercase_and_remove_accent (bool, optional, 默认为 True) — 分词时是否转换为小写并移除重音符号。

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

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

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

build_inputs_with_special_tokens

< 来源 >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → List[int]

参数

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

List[int]

带有适当特殊标记的输入ID列表。

通过连接和添加特殊词元，为序列分类任务从一个序列或一对序列构建模型输入。XLM 序列具有以下格式

单个序列：<s> X </s>
序列对：<s> A </s> B </s>

get_special_tokens_mask

< 来源 >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None already_has_special_tokens: bool = False ) → 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。此方法在使用分词器prepare_for_model方法添加特殊标记时调用。

create_token_type_ids_from_sequences

< 来源 >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]

参数

token_ids_0 (list[int]) — 第一个分词后的序列。
token_ids_1 (list[int], optional) — 第二个分词后的序列。

list[int]

标记类型 ID。

创建与传入序列对应的标记类型 ID。什么是标记类型 ID？

如果模型有特殊的构建方式，应在子类中重写此方法。

save_vocabulary

< 来源 >

( save_directory: str filename_prefix: typing.Optional[str] = None )

XLM 特定输出

class transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput

< 来源 >

( loss: typing.Optional[torch.FloatTensor] = None start_top_log_probs: typing.Optional[torch.FloatTensor] = None start_top_index: typing.Optional[torch.LongTensor] = None end_top_log_probs: typing.Optional[torch.FloatTensor] = None end_top_index: typing.Optional[torch.LongTensor] = None cls_logits: typing.Optional[torch.FloatTensor] = None hidden_states: typing.Optional[tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[tuple[torch.FloatTensor, ...]] = None )

参数

loss (torch.FloatTensor，形状为 (1,), optional, 如果同时提供了 start_positions 和 end_positions，则返回) — 分类损失，是开始词元、结束词元（以及如果提供了 is_impossible）分类损失的总和。
start_top_log_probs (torch.FloatTensor，形状为 (batch_size, config.start_n_top), optional, 如果未提供 start_positions 或 end_positions，则返回) — top config.start_n_top 个开始词元可能性的对数概率（束搜索）。
start_top_index (torch.LongTensor，形状为 (batch_size, config.start_n_top), optional, 如果未提供 start_positions 或 end_positions，则返回) — top config.start_n_top 个开始词元可能性的索引（束搜索）。
end_top_log_probs (torch.FloatTensor，形状为 (batch_size, config.start_n_top * config.end_n_top), optional, 如果未提供 start_positions 或 end_positions，则返回) — top config.start_n_top * config.end_n_top 个结束词元可能性的对数概率（束搜索）。
end_top_index (torch.LongTensor，形状为 (batch_size, config.start_n_top * config.end_n_top), optional, 如果未提供 start_positions 或 end_positions，则返回) — top config.start_n_top * config.end_n_top 个结束词元可能性的索引（束搜索）。
cls_logits (torch.FloatTensor，形状为 (batch_size,), optional, 如果未提供 start_positions 或 end_positions，则返回) — 答案的 is_impossible 标签的对数概率。
hidden_states (tuple[torch.FloatTensor, ...], optional, 当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — torch.FloatTensor 的元组（如果模型有嵌入层，则第一个是嵌入层的输出，然后是每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

Pytorch

隐藏 Pytorch 内容

XLMModel

class transformers.XLMModel

< 来源 >

( config )

参数

config (XLMModel) — 模型配置类，包含模型的所有参数。使用配置文件进行初始化不会加载与模型相关的权重，只会加载配置。请查看 from_pretrained() 方法来加载模型权重。

裸的 Xlm 模型，输出原始的隐藏状态，顶部没有任何特定的头。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

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: typing.Optional[dict[str, torch.Tensor]] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length), optional) — 输入序列在词汇表中的词元索引。默认情况下会忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length), optional) — 掩码，用于避免对填充词元索引执行注意力。掩码值选自 [0, 1]：
- 1 表示**未被掩码**的词元，
- 0 表示**被掩码**的词元。
什么是注意力掩码？
langs (torch.LongTensor，形状为 (batch_size, sequence_length), optional) — 一个并行的词元序列，用于指示输入中每个词元的语言。索引是语言 ID，可以通过使用模型配置中提供的两个转换映射从语言名称中获得（仅为多语言模型提供）。更确切地说，“语言名称到语言 ID” 的映射在 `model.config.lang2id` 中（这是一个字符串到整数的字典），而 “语言 ID 到语言名称” 的映射在 `model.config.id2lang` 中（整数到字符串的字典）。

详细用法示例请参见多语言文档。
token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 片段词元（token）索引，用于表示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 *句子 A* 的词元，
- 1 对应于 *句子 B* 的词元。
什么是词元类型 ID？
position_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列词元的位置索引。在 [0, config.n_positions - 1] 范围内选择。

什么是位置 ID？
lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充词元索引执行注意力计算。您也可以使用 *attention_mask* 达到相同的结果（见上文），此处保留是为了兼容性。索引在 [0, ..., input_ids.size(-1)] 中选择。
cache (dict[str, torch.FloatTensor]，可选) — 字符串到 torch.FloatTensor 的字典，包含模型计算的预计算隐藏状态（注意力块中的键和值）（见下文 cache 输出）。可用于加速序列解码。

该字典对象将在前向传播期间被原地修改，以添加新计算的隐藏状态。
head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
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 而不是一个普通的元组。

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 时返回) — 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 后的注意力权重，用于计算自注意力头中的加权平均值。

XLMModel 的前向方法，重写了 __call__ 特殊方法。

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

XLMWithLMHeadModel

class transformers.XLMWithLMHeadModel

< 来源 >

( config )

参数

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

带有语言模型头的 XLM 模型 Transformer（在顶部是一个线性层，其权重与输入嵌入绑定）。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

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: typing.Optional[dict[str, torch.Tensor]] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列词元的索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充词元索引执行注意力计算的掩码。掩码值在 [0, 1] 中选择：
- 1 表示词元未被屏蔽，
- 0 表示词元已被屏蔽。
什么是注意力掩码？
langs (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 一个并行的词元序列，用于指示输入中每个词元的语言。索引是语言 ID，可以通过使用模型配置中提供的两个转换映射从语言名称中获取（仅为多语言模型提供）。更准确地说，语言名称到语言 ID 的映射在 model.config.lang2id（一个字符串到整数的字典）中，而 语言 ID 到语言名称 的映射在 model.config.id2lang（一个整数到字符串的字典）中。

请参阅多语言文档中详细的用法示例。
token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 片段词元（token）索引，用于表示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 *句子 A* 的词元，
- 1 对应于 *句子 B* 的词元。
什么是词元类型 ID？
position_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列词元的位置索引。在 [0, config.n_positions - 1] 范围内选择。

什么是位置 ID？
lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充词元索引执行注意力计算。您也可以使用 *attention_mask* 达到相同的结果（见上文），此处保留是为了兼容性。索引在 [0, ..., input_ids.size(-1)] 中选择。
cache (dict[str, torch.FloatTensor]，可选) — 字符串到 torch.FloatTensor 的字典，包含模型计算的预计算隐藏状态（注意力块中的键和值）（见下文 cache 输出）。可用于加速序列解码。

该字典对象将在前向传播期间被原地修改，以添加新计算的隐藏状态。
head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
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 而不是一个普通的元组。

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

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

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。
logits (形状为 (batch_size, sequence_length, config.vocab_size) 的 torch.FloatTensor) — 语言建模头部的预测分数（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__ 特殊方法。

示例

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

class transformers.XLMForSequenceClassification

< 来源 >

( config )

参数

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

带有序列分类/回归头的 XLM 模型（在池化输出之上是一个线性层），例如用于 GLUE 任务。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch 模块一样使用它，并参考 PyTorch 文档了解所有与通用用法和行为相关的事项。

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: typing.Optional[dict[str, torch.Tensor]] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列词元的索引。默认情况下将忽略填充。

可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充词元索引执行注意力计算的掩码。掩码值在 [0, 1] 中选择：
- 1 表示词元未被屏蔽，
- 0 表示词元已被屏蔽。
什么是注意力掩码？
langs (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 一个并行的词元序列，用于指示输入中每个词元的语言。索引是语言 ID，可以通过使用模型配置中提供的两个转换映射从语言名称中获取（仅为多语言模型提供）。更准确地说，语言名称到语言 ID 的映射在 model.config.lang2id（一个字符串到整数的字典）中，而 语言 ID 到语言名称 的映射在 model.config.id2lang（一个整数到字符串的字典）中。

请参阅多语言文档中详细的用法示例。
token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 片段词元（token）索引，用于表示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 *句子 A* 的词元，
- 1 对应于 *句子 B* 的词元。
什么是词元类型 ID？
position_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列词元的位置索引。在 [0, config.n_positions - 1] 范围内选择。

什么是位置 ID？
lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充词元索引执行注意力计算。您也可以使用 *attention_mask* 达到相同的结果（见上文），此处保留是为了兼容性。索引在 [0, ..., input_ids.size(-1)] 中选择。
cache (dict[str, torch.FloatTensor]，可选) — 字符串到 torch.FloatTensor 的字典，包含模型计算的预计算隐藏状态（注意力块中的键和值）（见下文 cache 输出）。可用于加速序列解码。

该字典对象将在前向传播期间被原地修改，以添加新计算的隐藏状态。
head_mask (torch.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中选定的头无效的掩码。掩码值在 [0, 1] 中选择：
- 1 表示头未被屏蔽，
- 0 表示头已被屏蔽。
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 而不是一个普通的元组。

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

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

loss (形状为 (1,) 的 torch.FloatTensor，可选，当提供 labels 时返回) — 分类损失（如果 config.num_labels==1，则为回归损失）。
logits (形状为 (batch_size, config.num_labels) 的 torch.FloatTensor) — 分类（如果 config.num_labels==1，则为回归）分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

XLMForSequenceClassification 的前向方法，重写了 __call__ 特殊方法。

单标签分类示例

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

多标签分类示例

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

Transformers

XLM

XLMConfig

class transformers.XLMConfig

XLMTokenizer

class transformers.XLMTokenizer

build_inputs_with_special_tokens

get_special_tokens_mask

create_token_type_ids_from_sequences

save_vocabulary

XLM 特定输出

class transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput

XLMModel

class transformers.XLMModel

forward

XLMWithLMHeadModel

class transformers.XLMWithLMHeadModel

forward

XLMForSequenceClassification

class transformers.XLMForSequenceClassification

forward

XLMForMultipleChoice

class transformers.XLMForMultipleChoice

forward

XLMForTokenClassification

class transformers.XLMForTokenClassification

forward

XLMForQuestionAnsweringSimple

class transformers.XLMForQuestionAnsweringSimple

forward

XLMForQuestionAnswering

class transformers.XLMForQuestionAnswering

forward

TFXLMModel

class transformers.TFXLMModel

调用

TFXLMWithLMHeadModel

class transformers.TFXLMWithLMHeadModel

调用

TFXLMForSequenceClassification

class transformers.TFXLMForSequenceClassification

调用

TFXLMForMultipleChoice

class transformers.TFXLMForMultipleChoice

调用

TFXLMForTokenClassification

class transformers.TFXLMForTokenClassification

调用

TFXLMForQuestionAnsweringSimple

class transformers.TFXLMForQuestionAnsweringSimple

调用