Hugging Face's logo

Transformers documentation

XLM

You are viewing main version, which requires installation from source. If you'd like regular pip install, checkout the latest stable version (v5.22.1).
Hugging Face's logo
Join the Hugging Face community

and get access to the augmented documentation experience

to get started

该模型于 2019-01-22 在 HF papers 上发布，并于 2020-11-16 贡献至 Hugging Face Transformers。

XLM

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

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

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

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

Pipeline
AutoModel
from transformers import pipeline


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

XLMConfig

class transformers.XLMConfig

< >

( transformers_version: str | None = Nonearchitectures: list[str] | None = Noneoutput_hidden_states: bool | None = Falsereturn_dict: bool | None = Truedtype: str | torch.dtype | None = Nonechunk_size_feed_forward: int = 0is_encoder_decoder: bool = Falseid2label: dict[int, str] | dict[str, str] | None = Nonelabel2id: dict[str, int] | dict[str, str] | None = Noneproblem_type: Literal['regression', 'single_label_classification', 'multi_label_classification'] | None = Nonevocab_size: int = 30145emb_dim: int = 2048n_layers: int = 12n_heads: int = 16dropout: float | int = 0.1attention_dropout: float | int = 0.1gelu_activation: bool = Truesinusoidal_embeddings: bool = Falsecausal: bool = Falseasm: bool = Falsen_langs: int = 1use_lang_emb: bool = Truemax_position_embeddings: int = 512embed_init_std: float = 0.02209708691207961layer_norm_eps: float = 1e-12init_std: float = 0.02unk_index: int = 3mask_index: int = 5is_encoder: bool = Truesummary_type: str = 'first'summary_use_proj: bool = Truesummary_activation: str | None = Nonesummary_proj_to_labels: bool = Truesummary_first_dropout: float | int = 0.1start_n_top: int = 5end_n_top: int = 5mask_token_id: int | None = 0lang_id: int = 0pad_token_id: int | None = 2bos_token_id: int | None = 0eos_token_id: int | list[int] | None = 1tie_word_embeddings: bool = True )

参数

  • 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) — 是否使用语言嵌入。某些模型会使用额外的语言嵌入，有关如何使用它们的信息，请参阅 多语言模型页面。
  • 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"：提供一个张量，指定分类标记的位置（类似于 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 类似的配置。

配置对象继承自 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_filemerges_fileunk_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 = Noneid2lang = Nonedo_lowercase_and_remove_accent = True**kwargs )

参数

  • vocab_file (str) — 词汇表文件。
  • merges_file (str) — 合并文件。
  • unk_token (str，可选，默认为 "<unk>") — 未知标记。不在词汇表中的标记无法转换为 ID，因此会被设置为该标记。
  • bos_token (str, 可选, 默认为 "<s>") — 预训练期间使用的序列起始标记。也可用作序列分类标记。

    在构建序列时，如果使用了特殊标记，序列开头使用的并不是这个标记。实际使用的标记是 cls_token。

  • sep_token (str，可选，默认为 "</s>") — 分隔符 token，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。
  • 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，其中包含了大部分主要方法。用户应参考该父类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → List[int]

参数

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

返回值

List[int]

包含相应特殊标记的输入 ID列表。

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

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

get_special_tokens_mask

< >

( token_ids_0: listtoken_ids_1: list[int] | None = Nonealready_has_special_tokens: bool = False ) → List[int]

参数

  • token_ids_0 (List[int]) — ID 列表。
  • token_ids_1 (List[int], 可选) — 用于序列对的可选第二组 ID 列表。
  • already_has_special_tokens (bool，可选，默认为 False) — 指示 token 列表是否已针对该模型格式化为包含特殊 token 的形式。

返回值

List[int]

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

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

create_token_type_ids_from_sequences

< >

( token_ids_0: listtoken_ids_1: list[int] | None = None ) → list[int]

参数

  • 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：在长度计算中是否考虑特殊标记

示例：

# 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

< >

( save_directory: strfilename_prefix: str | None = None )

XLM 特定输出

class transformers.models.xlm.modeling_xlm.XLMForQuestionAnsweringOutput

< >

( loss: typing.Optional[torch.Tensor] = Nonestart_top_log_probs: typing.Optional[torch.Tensor] = Nonestart_top_index: typing.Optional[torch.LongTensor] = Noneend_top_log_probs: typing.Optional[torch.Tensor] = Noneend_top_index: typing.Optional[torch.LongTensor] = Nonecls_logits: typing.Optional[torch.Tensor] = Nonehidden_states: tuple[torch.Tensor, ...] | None = Noneattentions: tuple[torch.Tensor, ...] | None = None )

参数

  • 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（形状为 (batch_size, config.start_n_top) 的 torch.LongTensor，可选，当未提供 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（形状为 (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 之后的权重，用于在自注意力头中计算加权平均值。

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

XLMModel

class transformers.XLMModel

< >

( config: XLMConfig )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → BaseModelOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • langs (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射从语言名称获得（仅适用于多语言模型）。具体来说， 语言名称到语言 ID 的映射位于 model.config.lang2id (（一个字符串到整数的字典），而 语言 ID 到语言名称 的映射位于 model.config.id2lang (（一个整数到字符串的字典）。

    有关详细用法示例，请参阅多语言文档。

  • token_type_ids (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自 [0, 1]:
    • 0 对应 sentence A 标记，
    • 1 对应于 sentence B 标记。

    什么是 token type ID？

  • position_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID？

  • lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充 token 索引执行注意力计算。您也可以使用 attention_mask 达到相同效果（见上文），此处保留以兼容旧版本。所选索引位于 [0, ..., input_ids.size(-1)] 范围内。
  • cache (dict[str, torch.Tensor], 可选) — EncoderDecoderCache 的实例，包含预计算的 KV 状态。可用于加速顺序解码。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

BaseModelOutput 或 tuple(torch.Tensor)

一个 BaseModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（XLMConfig）和输入。

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

class transformers.XLMWithLMHeadModel

< >

( config: XLMConfig )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = Nonelogits_to_keep: typing.Union[int, torch.Tensor] = 0**kwargs ) → MaskedLMOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • langs (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射从语言名称获得（仅适用于多语言模型）。具体来说， 语言名称到语言 ID 的映射位于 model.config.lang2id (（一个字符串到整数的字典），而 语言 ID 到语言名称 的映射位于 model.config.id2lang (（一个整数到字符串的字典）。

    有关详细用法示例，请参阅多语言文档。

  • token_type_ids (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自 [0, 1]:
    • 0 对应 sentence A 标记，
    • 1 对应于 sentence B 标记。

    什么是 token type ID？

  • position_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID？

  • lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充 token 索引执行注意力计算。您也可以使用 attention_mask 达到相同效果（见上文），此处保留以兼容旧版本。所选索引位于 [0, ..., input_ids.size(-1)] 范围内。
  • cache (dict[str, torch.Tensor], 可选) — EncoderDecoderCache 的实例，包含预计算的 KV 状态。可用于加速顺序解码。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 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 而不是普通元组。
  • logits_to_keep (Union[int, torch.Tensor], 可选，默认为 0) — 如果为 int，则计算最后 logits_to_keep 个 token 的 logits。如果为 0，则计算所有 input_ids 的 logits（特殊情况）。生成过程只需要最后一个 token 的 logits，仅针对该 token 进行计算可以节省内存，对于长序列或大词汇量而言，这种节省相当显著。 如果为 torch.Tensor，则必须是一维张量，对应于序列长度维度中需要保留的索引。 这在使用打包张量格式（将批次和序列长度合并为单一维度）时非常有用。

返回值

MaskedLMOutput 或 tuple(torch.Tensor)

一个 MaskedLMOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（XLMConfig）和输入。

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

示例：

>>> 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: XLMConfig )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → SequenceClassifierOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • langs (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射从语言名称获得（仅适用于多语言模型）。具体来说， 语言名称到语言 ID 的映射位于 model.config.lang2id (（一个字符串到整数的字典），而 语言 ID 到语言名称 的映射位于 model.config.id2lang (（一个整数到字符串的字典）。

    有关详细用法示例，请参阅多语言文档。

  • token_type_ids (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自 [0, 1]:
    • 0 对应 sentence A 标记，
    • 1 对应于 sentence B 标记。

    什么是 token type ID？

  • position_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID？

  • lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充 token 索引执行注意力计算。您也可以使用 attention_mask 达到相同效果（见上文），此处保留以兼容旧版本。所选索引位于 [0, ..., input_ids.size(-1)] 范围内。
  • cache (dict[str, torch.Tensor], 可选) — EncoderDecoderCache 的实例，包含预计算的 KV 状态。可用于加速顺序解码。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 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 而不是普通元组。

返回值

SequenceClassifierOutput 或 tuple(torch.Tensor)

一个 SequenceClassifierOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（XLMConfig）和输入。

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

单标签分类示例：

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

XLMForMultipleChoice

class transformers.XLMForMultipleChoice

< >

( config: XLMConfig*inputs**kwargs )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → MultipleChoiceModelOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.LongTensor 形状为 (batch_size, num_choices, sequence_length)) — 输入序列 token 在词汇表中的索引。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • langs (torch.LongTensor 形状为 (batch_size, num_choices, sequence_length), 可选) — 一个与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引是语言 ID，可通过模型配置中提供的两个转换映射从语言名称获得（仅适用于多语言模型）。更具体地说， 语言名称到语言 ID 的映射位于 model.config.lang2id (（这是一个从字符串到整数的字典），而 语言 ID 到语言名称 的映射位于 model.config.id2lang (（从整数到字符串的字典）。

    有关详细用法示例，请参阅多语言文档。

  • token_type_ids (torch.LongTensor 形状为 (batch_size, num_choices, sequence_length), 可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取值范围为 [0, 1]:
    • 0 对应 sentence A 标记，
    • 1 对应于 sentence B 标记。

    什么是 token type ID？

  • position_ids (torch.LongTensor 形状为 (batch_size, num_choices, sequence_length), ，可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.max_position_embeddings - 1].

    什么是位置 ID？

  • lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充 token 索引执行注意力计算。您也可以使用 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（形状为 (batch_size,) 的 torch.LongTensor，可选） — 用于计算多项选择分类损失的标签。索引应在 [0, ..., num_choices-1] 范围内，其中 num_choices 是输入张量第二维的大小。（参见上文中的 input_ids）
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

MultipleChoiceModelOutput 或 tuple(torch.Tensor)

一个 MultipleChoiceModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（XLMConfig）和输入。

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

示例：

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

class transformers.XLMForTokenClassification

< >

( config: XLMConfig )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonelabels: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → TokenClassifierOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • langs (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射从语言名称获得（仅适用于多语言模型）。具体来说， 语言名称到语言 ID 的映射位于 model.config.lang2id (（一个字符串到整数的字典），而 语言 ID 到语言名称 的映射位于 model.config.id2lang (（一个整数到字符串的字典）。

    有关详细用法示例，请参阅多语言文档。

  • token_type_ids (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自 [0, 1]:
    • 0 对应 sentence A 标记，
    • 1 对应于 sentence B 标记。

    什么是 token type ID？

  • position_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID？

  • lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充 token 索引执行注意力计算。您也可以使用 attention_mask 达到相同效果（见上文），此处保留以兼容旧版本。所选索引位于 [0, ..., input_ids.size(-1)] 范围内。
  • cache (dict[str, torch.Tensor], 可选) — EncoderDecoderCache 的实例，包含预计算的 KV 状态。可用于加速顺序解码。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 input_ids。如果您希望对 input_ids 索引如何转换为相应向量拥有比模型内部嵌入查找矩阵更多的控制权，这将非常有用。
  • labels（形状为 (batch_size, sequence_length) 的 torch.LongTensor，可选） — 用于计算 token 分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

TokenClassifierOutput 或 tuple(torch.Tensor)

一个 TokenClassifierOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（XLMConfig）和输入。

XLMForTokenClassification 的 forward 方法重写了 __call__ 特殊方法。

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

  • loss（形状为 (1,) 的 torch.Tensor，可选，在提供 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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

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

class transformers.XLMForQuestionAnsweringSimple

< >

( config: XLMConfig )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → QuestionAnsweringModelOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • langs (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射从语言名称获得（仅适用于多语言模型）。具体来说， 语言名称到语言 ID 的映射位于 model.config.lang2id (（一个字符串到整数的字典），而 语言 ID 到语言名称 的映射位于 model.config.id2lang (（一个整数到字符串的字典）。

    有关详细用法示例，请参阅多语言文档。

  • token_type_ids (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自 [0, 1]:
    • 0 对应 sentence A 标记，
    • 1 对应于 sentence B 标记。

    什么是 token type ID？

  • position_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID？

  • lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充 token 索引执行注意力计算。您也可以使用 attention_mask 达到相同效果（见上文），此处保留以兼容旧版本。所选索引位于 [0, ..., input_ids.size(-1)] 范围内。
  • cache (dict[str, torch.Tensor], 可选) — EncoderDecoderCache 的实例，包含预计算的 KV 状态。可用于加速顺序解码。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 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 而不是普通元组。

返回值

QuestionAnsweringModelOutput 或 tuple(torch.Tensor)

一个 QuestionAnsweringModelOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（XLMConfig）和输入。

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

示例：

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

< >

( config: XLMConfig )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。 请将其作为常规的 PyTorch Module 使用，有关通用用法和行为的所有事项，请参阅 PyTorch 文档。

forward

< >

( input_ids: typing.Optional[torch.Tensor] = Noneattention_mask: typing.Optional[torch.Tensor] = Nonelangs: typing.Optional[torch.Tensor] = Nonetoken_type_ids: typing.Optional[torch.Tensor] = Noneposition_ids: typing.Optional[torch.Tensor] = Nonelengths: typing.Optional[torch.Tensor] = Nonecache: dict[str, torch.Tensor] | None = Noneinputs_embeds: typing.Optional[torch.Tensor] = Nonestart_positions: typing.Optional[torch.Tensor] = Noneend_positions: typing.Optional[torch.Tensor] = Noneis_impossible: typing.Optional[torch.Tensor] = Nonecls_index: typing.Optional[torch.Tensor] = Nonep_mask: typing.Optional[torch.Tensor] = Noneoutput_attentions: bool | None = Noneoutput_hidden_states: bool | None = Nonereturn_dict: bool | None = None**kwargs ) → XLMForQuestionAnsweringOutput or tuple(torch.Tensor)

参数

  • input_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中各 token 在词表中的索引。默认情况下，填充（padding）将被忽略。

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

    什么是输入 ID？

  • attention_mask (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于避免对填充 token 索引执行注意力机制的掩码。掩码值取自 [0, 1]:
    • 1 表示未被屏蔽的 token，
    • 对于被掩码的 token，值为 0。

    什么是注意力掩码？

  • langs (torch.LongTensor 形状为 (batch_size, sequence_length), ，可选) — 与输入平行的 token 序列，用于指示输入中每个 token 的语言。索引为语言 ID，可通过模型配置中提供的两个转换映射从语言名称获得（仅适用于多语言模型）。具体来说， 语言名称到语言 ID 的映射位于 model.config.lang2id (（一个字符串到整数的字典），而 语言 ID 到语言名称 的映射位于 model.config.id2lang (（一个整数到字符串的字典）。

    有关详细用法示例，请参阅多语言文档。

  • token_type_ids (torch.Tensor 形状为 (batch_size, sequence_length), ，可选) — 用于指示输入中第一和第二部分的片段标记索引。索引取自 [0, 1]:
    • 0 对应 sentence A 标记，
    • 1 对应于 sentence B 标记。

    什么是 token type ID？

  • position_ids (torch.Tensor 形状为 (batch_size, sequence_length), 可选) — 输入序列中每个 token 在位置嵌入中的位置索引。取值范围为 [0, config.n_positions - 1].

    什么是位置 ID？

  • lengths (torch.LongTensor，形状为 (batch_size,)，可选) — 每个句子的长度，可用于避免对填充 token 索引执行注意力计算。您也可以使用 attention_mask 达到相同效果（见上文），此处保留以兼容旧版本。所选索引位于 [0, ..., input_ids.size(-1)] 范围内。
  • cache (dict[str, torch.Tensor], 可选) — EncoderDecoderCache 的实例，包含预计算的 KV 状态。可用于加速顺序解码。
  • inputs_embeds（形状为 (batch_size, sequence_length, hidden_size) 的 torch.Tensor，可选） — 可选地，您可以选择直接传入嵌入表示，而不是传入 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,)，可选) — 用于指定分类 token 位置（索引）的标签，作为计算答案合理性的输入。
  • p_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 可选的掩码，用于标记不能出现在答案中的 token（例如 [CLS]、[PAD] 等）。1.0 表示该 token 应被掩码，0.0 表示该 token 未被掩码。
  • output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关详细信息，请参阅返回张量中的 attentions。
  • output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的 hidden_states。
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通元组。

返回值

XLMForQuestionAnsweringOutput 或 tuple(torch.Tensor)

一个 XLMForQuestionAnsweringOutput 或 torch.Tensor 元组（如果传入了 return_dict=False 或 config.return_dict=False），其包含的元素取决于配置（XLMConfig）和输入。

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（形状为 (batch_size, config.start_n_top) 的 torch.LongTensor，可选，当未提供 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 可能性的对数概率 (beam-search)。

  • 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 之后的权重，用于在自注意力头中计算加权平均值。

示例：

>>> 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
Update on GitHub

←XGLM XLM-RoBERTa→