Transformers 文档
XLNet
并获得增强的文档体验
开始使用
XLNet
概述
XLNet 模型由 Zhilin Yang、Zihang Dai、Yiming Yang、Jaime Carbonell、Ruslan Salakhutdinov 和 Quoc V. Le 在 XLNet: Generalized Autoregressive Pretraining for Language Understanding 中提出。XLNet 是 Transformer-XL 模型的扩展，它使用自回归方法进行预训练，通过最大化输入序列所有排列分解顺序的期望似然来学习双向上下文。
以下是论文的摘要
由于能够对双向上下文进行建模，像 BERT 这样基于去噪自编码器的预训练方法比基于自回归语言模型的预训练方法取得了更好的性能。然而，BERT 依赖于使用掩码来破坏输入，忽略了被掩盖位置之间的依赖关系，并存在预训练-微调差异的问题。 鉴于这些优点和缺点，我们提出了 XLNet，这是一种广义的自回归预训练方法，它 (1) 通过最大化分解顺序所有排列的期望似然来学习双向上下文，并且 (2) 由于其自回归公式，克服了 BERT 的局限性。 此外，XLNet 将来自 Transformer-XL（最先进的自回归模型）的思想融入到预训练中。 经验表明，在可比较的实验设置下，XLNet 在 20 个任务上优于 BERT，通常优势很大，包括问答、自然语言推理、情感分析和文档排序。
此模型由 thomwolf 贡献。 原始代码可以在这里找到。
使用技巧
- 可以使用
perm_mask输入在训练和测试时控制特定的注意力模式。 - 由于在各种分解顺序上训练完全自回归模型的难度，XLNet 仅使用输出 tokens 的子集作为目标进行预训练，这些子集通过
target_mapping输入进行选择。 - 要将 XLNet 用于顺序解码（即不在完全双向设置中），请使用
perm_mask和target_mapping输入来控制注意力跨度和输出（请参阅 examples/pytorch/text-generation/run_generation.py 中的示例） - XLNet 是少数几个没有序列长度限制的模型之一。
- XLNet 不是传统的自回归模型，而是使用建立在其基础上的训练策略。 它置换句子中的 tokens，然后允许模型使用最后 n 个 tokens 来预测 token n+1。 由于这一切都是通过掩码完成的，因此句子实际上是以正确的顺序输入到模型中的，但 XLNet 不是为 n+1 掩盖前 n 个 tokens，而是使用掩码来隐藏 1,…, 序列长度的给定排列中的先前 tokens。
- XLNet 还使用了与 Transformer-XL 相同的循环机制来构建长期依赖关系。
资源
XLNetConfig
class transformers.XLNetConfig
< source >( vocab_size = 32000 d_model = 1024 n_layer = 24 n_head = 16 d_inner = 4096 ff_activation = 'gelu' untie_r = True attn_type = 'bi' initializer_range = 0.02 layer_norm_eps = 1e-12 dropout = 0.1 mem_len = 512 reuse_len = None use_mems_eval = True use_mems_train = False bi_data = False clamp_len = -1 same_length = False summary_type = 'last' summary_use_proj = True summary_activation = 'tanh' summary_last_dropout = 0.1 start_n_top = 5 end_n_top = 5 pad_token_id = 5 bos_token_id = 1 eos_token_id = 2 **kwargs )
参数
- vocab_size (
int, 可选, 默认为 32000) — XLNet 模型的词汇表大小。 定义了调用 XLNetModel 或 TFXLNetModel 时可以由inputs_ids表示的不同 tokens 的数量。 - d_model (
int, 可选, 默认为 1024) — 编码器层和池化器层的维度。 - n_layer (
int, 可选, 默认为 24) — Transformer 编码器中隐藏层的数量。 - n_head (
int, 可选, 默认为 16) — Transformer 编码器中每个注意力层的注意力头的数量。 - d_inner (
int, 可选, 默认为 4096) — Transformer 编码器中“中间”层（通常称为前馈层）的维度。 - ff_activation (
str或Callable, 可选, 默认为"gelu") — If string,"gelu","relu","silu"and"gelu_new"are supported. 中的非线性激活函数（函数或字符串）。 如果是字符串，则支持"gelu"、"relu"、"silu"和"gelu_new"。 - untie_r (
bool, 可选, 默认为True) — 是否解开相对位置偏差 - attn_type (
str, 可选, 默认为"bi") — 模型使用的注意力类型。 为 XLNet 设置"bi"，为 Transformer-XL 设置"uni"。 - initializer_range (
float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。 - layer_norm_eps (
float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。 - dropout (
float, 可选, 默认为 0.1) — embeddings、编码器和池化器中所有全连接层的 dropout 概率。 - mem_len (
int或None, 可选) — 要缓存的 tokens 数量。 在先前的正向传递中已预先计算的键/值对将不会被重新计算。 有关更多信息，请参阅 快速入门。 - reuse_len (
int, 可选) — 当前批次中要缓存并在未来重用的 tokens 数量。 - bi_data (
bool, 可选, 默认为False) — 是否使用双向输入管道。 通常在预训练期间设置为True，在微调期间设置为False。 - clamp_len (
int, 可选, 默认为 -1) — Clamp 所有大于 clamp_len 的相对距离。 将此属性设置为 -1 表示不进行 clamping。 - same_length (
bool, 可选, 默认为False) — 是否对每个 token 使用相同的注意力长度。 - summary_type (
str, 可选, 默认为 “last”) — 进行序列摘要时使用的参数。 在序列分类和多项选择模型中使用。必须是以下选项之一：
"last"：采用最后一个 token 的隐藏状态（如 XLNet）。"first"：采用第一个 token 的隐藏状态（如 BERT）。"mean"：采用所有 tokens 隐藏状态的平均值。"cls_index"：提供分类 token 位置的张量（如 GPT/GPT-2）。"attn"：目前未实现，请使用多头注意力。
- summary_use_proj (
bool, optional, defaults toTrue) — 序列摘要时使用的参数。在序列分类和多项选择模型中使用。是否在向量提取后添加投影层。
- summary_activation (
str, optional) — 序列摘要时使用的参数。在序列分类和多项选择模型中使用。传递
"tanh"以对输出应用 tanh 激活函数，任何其他值将导致不应用激活函数。 - summary_proj_to_labels (
boo, optional, defaults toTrue) — 在序列分类和多项选择模型中使用。投影输出应具有
config.num_labels还是config.hidden_size类。 - summary_last_dropout (
float, optional, defaults to 0.1) — 在序列分类和多项选择模型中使用。在投影和激活后使用的 dropout 比率。
- start_n_top (
int, optional, defaults to 5) — 在 SQuAD 评估脚本中使用。 - end_n_top (
int, optional, defaults to 5) — 在 SQuAD 评估脚本中使用。 - use_mems_eval (
bool, optional, defaults toTrue) — 模型在评估模式下是否应使用循环记忆机制。 - use_mems_train (
bool, optional, defaults toFalse) — 模型在训练模式下是否应使用循环记忆机制。对于预训练，建议将
use_mems_train设置为True。 对于微调，建议将use_mems_train设置为False，如此处讨论的那样。 如果将use_mems_train设置为True，则必须确保训练批次已正确预处理，例如batch_1 = [[This line is], [This is the]]和batch_2 = [[ the first line], [ second line]]，并且所有批次的大小均相等。
这是配置类，用于存储 XLNetModel 或 TFXLNetModel 的配置。 它用于根据指定的参数实例化 XLNet 模型，定义模型架构。 使用默认值实例化配置将产生与 xlnet/xlnet-large-cased 架构类似的配置。
配置对象继承自 PretrainedConfig，可用于控制模型输出。 有关更多信息，请阅读 PretrainedConfig 中的文档。
示例
>>> from transformers import XLNetConfig, XLNetModel
>>> # Initializing a XLNet configuration
>>> configuration = XLNetConfig()
>>> # Initializing a model (with random weights) from the configuration
>>> model = XLNetModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.configXLNetTokenizer
class transformers.XLNetTokenizer
< source >( vocab_file do_lower_case = False remove_space = True keep_accents = False bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' sep_token = '<sep>' pad_token = '<pad>' cls_token = '<cls>' mask_token = '<mask>' additional_special_tokens = ['<eop>', '<eod>'] sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None **kwargs )
参数
- vocab_file (
str) — SentencePiece 文件（通常具有 .spm 扩展名），其中包含实例化分词器所需的词汇表。 - do_lower_case (
bool, optional, defaults toFalse) — 是否在分词时将输入转换为小写。 - remove_space (
bool, optional, defaults toTrue) — 分词时是否去除文本 (删除字符串前后多余的空格)。 - keep_accents (
bool, optional, defaults toFalse) — 分词时是否保留重音符号。 - bos_token (
str, optional, defaults to"<s>") — 序列开始标记，在预训练期间使用。 可以用作序列分类器标记。当使用特殊标记构建序列时，这不是用于序列开始的标记。 使用的标记是
cls_token。 - eos_token (
str, optional, defaults to"</s>") — 序列结束标记。当使用特殊标记构建序列时，这不是用于序列结束的标记。 使用的标记是
sep_token。 - unk_token (
str, optional, defaults to"<unk>") — 未知标记。 词汇表中不存在的标记无法转换为 ID，而是设置为此标记。 - sep_token (
str, optional, defaults to"<sep>") — 分隔符标记，用于从多个序列构建序列时，例如用于序列分类的两个序列，或用于问答的文本和问题。 它也用作使用特殊标记构建的序列的最后一个标记。 - pad_token (
str, optional, defaults to"<pad>") — 用于填充的标记，例如在对不同长度的序列进行批处理时。 - cls_token (
str, optional, defaults to"<cls>") — 分类器标记，用于进行序列分类（整个序列的分类而不是每个标记的分类）。 当使用特殊标记构建时，它是序列的第一个标记。 - mask_token (
str, optional, defaults to"<mask>") — 用于屏蔽值的标记。 这是使用掩码语言建模训练此模型时使用的标记。 这是模型将尝试预测的标记。 - additional_special_tokens (
List[str], optional, defaults to['<eop>', '<eod>']) — 分词器使用的其他特殊标记。 - sp_model_kwargs (
dict, optional) — 将传递给SentencePieceProcessor.__init__()方法。 SentencePiece 的 Python 封装器可用于设置以下内容：-
enable_sampling：启用子词正则化。 -
nbest_size：unigram 的采样参数。 对 BPE-Dropout 无效。nbest_size = {0,1}：不执行采样。nbest_size > 1：从 nbest_size 结果中采样。nbest_size < 0：假设 nbest_size 是无限的，并使用前向过滤和后向采样算法从所有假设（lattice）中采样。
-
alpha：用于 unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的 dropout 概率。
-
- sp_model (
SentencePieceProcessor) — 用于每次转换（字符串、标记和 ID）的 SentencePiece 处理器。
构建 XLNet 分词器。 基于 SentencePiece。
此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。 用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
通过连接并添加特殊标记，从序列或序列对构建模型输入，以用于序列分类任务。 XLNet 序列具有以下格式
- 单个序列：
X <sep> <cls> - 序列对：
A <sep> B <sep> <cls>
get_special_tokens_mask
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None already_has_special_tokens: bool = False ) → List[int]
从没有添加特殊令牌的令牌列表中检索序列 ID。当使用 tokenizer prepare_for_model 方法添加特殊令牌时，将调用此方法。
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
从传递的两个序列创建一个掩码，用于序列对分类任务。一个 XLNet
如果 token_ids_1 为 None，则此方法仅返回掩码的第一部分（0）。
XLNetTokenizerFast
class transformers.XLNetTokenizerFast
< source >( vocab_file = None tokenizer_file = None do_lower_case = False remove_space = True keep_accents = False bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' sep_token = '<sep>' pad_token = '<pad>' cls_token = '<cls>' mask_token = '<mask>' additional_special_tokens = ['<eop>', '<eod>'] **kwargs )
参数
- vocab_file (
str) — SentencePiece 文件（通常具有 .spm 扩展名），其中包含实例化 tokenizer 所需的词汇表。 - do_lower_case (
bool, optional, defaults toTrue) — 是否在分词时将输入转换为小写。 - remove_space (
bool, optional, defaults toTrue) — 在分词时是否去除文本 (删除字符串前后多余的空格)。 - keep_accents (
bool, optional, defaults toFalse) — 在分词时是否保留重音符号。 - bos_token (
str, optional, defaults to"<s>") — 序列开始令牌，在预训练期间使用。可以用作序列分类器令牌。当使用特殊令牌构建序列时，这不是用于序列开头的令牌。使用的令牌是
cls_token。 - eos_token (
str, optional, defaults to"</s>") — 序列结束令牌。当使用特殊令牌构建序列时，这不是用于序列结尾的令牌。使用的令牌是
sep_token。 - unk_token (
str, optional, defaults to"<unk>") — 未知令牌。词汇表中没有的令牌无法转换为 ID，并且会设置为此令牌。 - sep_token (
str, optional, defaults to"<sep>") — 分隔符令牌，用于从多个序列构建序列时，例如用于序列分类的两个序列或用于问答的文本和问题。它也用作使用特殊令牌构建的序列的最后一个令牌。 - pad_token (
str, optional, defaults to"<pad>") — 用于填充的令牌，例如在批量处理不同长度的序列时。 - cls_token (
str, optional, defaults to"<cls>") — 分类器令牌，用于进行序列分类（对整个序列而不是每个令牌进行分类）。当使用特殊令牌构建序列时，它是序列的第一个令牌。 - mask_token (
str, optional, defaults to"<mask>") — 用于屏蔽值的令牌。这是在使用掩码语言建模训练此模型时使用的令牌。这是模型将尝试预测的令牌。 - additional_special_tokens (
List[str], optional, defaults to["<eop>", "<eod>"]) — tokenizer 使用的其他特殊令牌。 - sp_model (
SentencePieceProcessor) — 用于每次转换（字符串、令牌和 ID）的 SentencePiece 处理器。
构建一个“快速” XLNet tokenizer（由 HuggingFace 的 tokenizers 库支持）。基于 Unigram。
此 tokenizer 继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
通过连接并添加特殊标记，从序列或序列对构建模型输入，以用于序列分类任务。 XLNet 序列具有以下格式
- 单个序列：
X <sep> <cls> - 序列对：
A <sep> B <sep> <cls>
create_token_type_ids_from_sequences
< source >( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = None ) → List[int]
从传递的两个序列创建一个掩码，用于序列对分类任务。一个 XLNet
如果 token_ids_1 为 None，则此方法仅返回掩码的第一部分（0）。
XLNet 特定的输出
class transformers.models.xlnet.modeling_xlnet.XLNetModelOutput
< source >( last_hidden_state: FloatTensor mems: typing.Optional[typing.List[torch.FloatTensor]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- last_hidden_state (
torch.FloatTensor，形状为(batch_size, num_predict, hidden_size)) — 模型最后一层的隐藏状态序列。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 - mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。 已经为其提供了过去状态的 token ids 不应作为input_ids传递，因为它们已经被计算过了。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
XLNetModel 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None mems: typing.Optional[typing.List[torch.FloatTensor]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为 (1,), optional, 当提供labels时返回) — 语言建模损失（用于预测下一个 token）。 - logits (
torch.FloatTensor，形状为(batch_size, num_predict, config.vocab_size)) — 语言建模头的预测得分（SoftMax 之前的每个词汇表 token 的得分）。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 - mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。 已经为其提供了过去状态的 token ids 不应作为input_ids传递，因为它们已经被计算过了。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
XLNetLMHeadModel 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None mems: typing.Optional[typing.List[torch.FloatTensor]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为(1,), optional, 当提供label时返回) — 分类损失（如果是 config.num_labels==1，则为回归损失）。 - logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类得分（或回归得分，如果是 config.num_labels==1）（在 SoftMax 之前）。 - mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。 已经为其提供了过去状态的 token ids 不应作为input_ids传递，因为它们已经被计算过了。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
class transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None mems: typing.Optional[typing.List[torch.FloatTensor]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensor，形状为 (1,), optional, 当提供labels时返回) — 分类损失。 - logits (
torch.FloatTensor，形状为(batch_size, num_choices)) — num_choices 是输入张量的第二个维度。（参见上面的 input_ids）。分类得分（在 SoftMax 之前）。
- mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。 已经为其提供了过去状态的 token ids 不应作为input_ids传递，因为它们已经被计算过了。 - 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 之后的注意力权重，用于计算自注意力头中的加权平均值。
XLNetForMultipleChoice 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None logits: FloatTensor = None mems: typing.Optional[typing.List[torch.FloatTensor]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 分类损失。 - logits (
torch.FloatTensorof shape(batch_size, sequence_length, config.num_labels)) — 分类得分 (在 SoftMax 之前)。 - mems (
List[torch.FloatTensor]of lengthconfig.n_layers) — 包含预先计算的隐藏状态。可以用于加速顺序解码 (参见mems输入)。 已经将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 - hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组 (每个嵌入输出层 + 每个层的输出各一个)。模型在每个层输出端的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组 (每层一个)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
XLNetForTokenClassificationOutput 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput
< source >( loss: typing.Optional[torch.FloatTensor] = None start_logits: FloatTensor = None end_logits: FloatTensor = None mems: typing.Optional[typing.List[torch.FloatTensor]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensorof shape(1,), optional, returned whenlabelsis provided) — 总跨度提取损失是起始位置和结束位置交叉熵损失的总和。 - start_logits (
torch.FloatTensorof shape(batch_size, sequence_length,)) — Span-start 得分 (在 SoftMax 之前)。 - end_logits (
torch.FloatTensorof shape(batch_size, sequence_length,)) — Span-end 得分 (在 SoftMax 之前)。 - mems (
List[torch.FloatTensor]of lengthconfig.n_layers) — 包含预先计算的隐藏状态。可以用于加速顺序解码 (参见mems输入)。 已经将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 - hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组 (每个嵌入输出层 + 每个层的输出各一个)。模型在每个层输出端的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组 (每层一个)。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
class transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput
< source >( 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 mems: typing.Optional[typing.List[torch.FloatTensor]] = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor, ...]] = None )
参数
- loss (
torch.FloatTensorof shape(1,), optional, returned if bothstart_positionsandend_positionsare provided) — 分类损失，为起始 token、结束 token（以及如果提供，则为 is_impossible）分类损失的总和。 - start_top_log_probs (
torch.FloatTensorof shape(batch_size, config.start_n_top), optional, returned ifstart_positionsorend_positionsis not provided) — 用于前 config.start_n_top 个起始 token 可能性的 Log 概率 (集束搜索)。 - start_top_index (
torch.LongTensorof shape(batch_size, config.start_n_top), optional, returned ifstart_positionsorend_positionsis not provided) — 用于前 config.start_n_top 个起始 token 可能性的索引 (集束搜索)。 - end_top_log_probs (
torch.FloatTensorof shape(batch_size, config.start_n_top * config.end_n_top), optional, returned ifstart_positionsorend_positionsis not provided) — 用于前config.start_n_top * config.end_n_top个结束 token 可能性的 Log 概率 (集束搜索)。 - end_top_index (
torch.LongTensorof shape(batch_size, config.start_n_top * config.end_n_top), optional, returned ifstart_positionsorend_positionsis not provided) — 用于前config.start_n_top * config.end_n_top个结束 token 可能性的索引 (集束搜索)。 - cls_logits (
torch.FloatTensorof shape(batch_size,), optional, returned ifstart_positionsorend_positionsis not provided) — 答案的is_impossible标签的 Log 概率。 - mems (
List[torch.FloatTensor]of lengthconfig.n_layers) — 包含预先计算的隐藏状态。可以用于加速顺序解码 (参见mems输入)。 已经将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 - hidden_states (
tuple(torch.FloatTensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组 (每个嵌入输出层 + 每个层输出各一个)。模型在每个层输出端的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(torch.FloatTensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor(每个层一个) 的元组，当传递output_attentions=True或config.output_attentions=True时返回。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
XLNetForQuestionAnswering 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput
< source >( last_hidden_state: tf.Tensor = None mems: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor, ...] | None = None attentions: Tuple[tf.Tensor, ...] | None = None )
参数
- last_hidden_state (形状为
(batch_size, num_predict, hidden_size)的tf.Tensor) — 模型最后一层的隐藏状态序列。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 - mems (长度为
config.n_layers的List[tf.Tensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。已经提供给此模型的过去 token id 不应作为input_ids传递，因为它们已被计算。 - hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor(每个层的输出一个，加上嵌入的输出) 的元组，当传递output_hidden_states=True或config.output_hidden_states=True时返回。模型在每一层输出以及初始嵌入输出处的隐藏状态。
- attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor(每个层一个) 的元组，当传递output_attentions=True或config.output_attentions=True时返回。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFXLNetModel 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput
< source >( loss: tf.Tensor | None = None logits: tf.Tensor = None mems: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor, ...] | None = None attentions: Tuple[tf.Tensor, ...] | None = None )
参数
- loss (形状为 (1,) 的
tf.Tensor, optional, 当提供labels时返回) — 语言建模损失（用于预测下一个 token）。 - logits (形状为
(batch_size, num_predict, config.vocab_size)的tf.Tensor) — 语言建模头的预测分数（SoftMax 之前每个词汇 token 的分数）。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 - mems (长度为
config.n_layers的List[tf.Tensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。已经提供给此模型的过去 token id 不应作为input_ids传递，因为它们已被计算。 - hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor(每个层的输出一个，加上嵌入的输出) 的元组，当传递output_hidden_states=True或config.output_hidden_states=True时返回。模型在每一层输出以及初始嵌入输出处的隐藏状态。
- attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor(每个层一个) 的元组，当传递output_attentions=True或config.output_attentions=True时返回。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
TFXLNetLMHeadModel 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput
< source >( loss: tf.Tensor | None = None logits: tf.Tensor = None mems: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor, ...] | None = None attentions: Tuple[tf.Tensor, ...] | None = None )
参数
- loss (形状为
(1,)的tf.Tensor, optional, 当提供label时返回) — 分类（或回归，如果 config.num_labels==1）损失。 - logits (形状为
(batch_size, config.num_labels)的tf.Tensor) — 分类（或回归，如果 config.num_labels==1）分数（SoftMax 之前）。 - mems (长度为
config.n_layers的List[tf.Tensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。已经提供给此模型的过去 token id 不应作为input_ids传递，因为它们已被计算。 - hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor(每个层的输出一个，加上嵌入的输出) 的元组，当传递output_hidden_states=True或config.output_hidden_states=True时返回。模型在每一层输出以及初始嵌入输出处的隐藏状态。
- attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor(每个层一个) 的元组，当传递output_attentions=True或config.output_attentions=True时返回。注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput
< source >( loss: tf.Tensor | None = None logits: tf.Tensor = None mems: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor, ...] | None = None attentions: Tuple[tf.Tensor, ...] | None = None )
参数
- loss (形状为 (1,) 的
tf.Tensor, optional, 当提供labels时返回) — 分类损失。 - logits (形状为
(batch_size, num_choices)的tf.Tensor) — num_choices 是输入张量的第二个维度。（参见上面的 input_ids ）。分类分数（SoftMax 之前）。
- mems (长度为
config.n_layers的List[tf.Tensor]) — 包含预先计算的隐藏状态。可以用于（参见mems输入）加速顺序解码。已经提供给此模型的过去 token id 不应作为input_ids传递，因为它们已被计算。 - hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（每个层的输出 + 嵌入的输出各一个）。模型在每一层输出的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
TFXLNetForMultipleChoice 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput
< source >( loss: tf.Tensor | None = None logits: tf.Tensor = None mems: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor, ...] | None = None attentions: Tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensorof shape(1,), optional, returned whenlabelsis provided) — 分类损失。 - logits (
tf.Tensorof shape(batch_size, sequence_length, config.num_labels)) — 分类得分（SoftMax 之前）。 - mems (长度为
config.n_layers的List[tf.Tensor]) — 包含预计算的隐藏状态。可以用于加速序列解码（参见mems输入）。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 - hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（每个层的输出 + 嵌入的输出各一个）。模型在每一层输出的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
TFXLNetForTokenClassificationOutput 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput
< source >( loss: tf.Tensor | None = None start_logits: tf.Tensor = None end_logits: tf.Tensor = None mems: List[tf.Tensor] | None = None hidden_states: Tuple[tf.Tensor, ...] | None = None attentions: Tuple[tf.Tensor, ...] | None = None )
参数
- loss (
tf.Tensorof shape(1,), optional, returned whenlabelsis provided) — 总跨度提取损失是起始位置和结束位置的交叉熵损失之和。 - start_logits (
tf.Tensorof shape(batch_size, sequence_length,)) — 跨度起始位置得分（SoftMax 之前）。 - end_logits (
tf.Tensorof shape(batch_size, sequence_length,)) — 跨度结束位置得分（SoftMax 之前）。 - mems (长度为
config.n_layers的List[tf.Tensor]) — 包含预计算的隐藏状态。可以用于加速序列解码（参见mems输入）。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 - hidden_states (
tuple(tf.Tensor), optional, returned whenoutput_hidden_states=Trueis passed or whenconfig.output_hidden_states=True) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（每个层的输出 + 嵌入的输出各一个）。模型在每一层输出的隐藏状态，加上初始嵌入输出。
- attentions (
tuple(tf.Tensor), optional, returned whenoutput_attentions=Trueis passed or whenconfig.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。注意力 softmax 后的权重，用于计算自注意力头中的加权平均值。
XLNetModel
class transformers.XLNetModel
< source >( config )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法来加载模型权重。
输出原始隐藏状态且顶部没有任何特定头的裸 XLNet 模型 Transformer。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor, optional) — 掩码，用于避免在 padding token 索引上执行注意力机制。掩码值在[0, 1]中选择：- 1 表示 未被掩码 的 tokens，
- 0 表示 已被掩码 的 tokens。
- mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态 (见下面的mems输出)。可用于加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。必须将
use_mems设置为True才能使用mems。 - perm_mask (形状为
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可选) — 用于指示每个输入 token 的注意力模式的 Mask，值选自[0, 1]:- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 关注 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不关注 j。
如果未设置，则每个 token 都会关注所有其他 token（完全双向注意力）。仅在预训练期间（用于定义因式分解顺序）或顺序解码（生成）时使用。
- 如果
- target_mapping (形状为
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可选) — 用于指示要使用的输出 token 的 Mask。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。仅在预训练期间用于部分预测或顺序解码（生成）。 - token_type_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于指示输入的第一部分和第二部分的片段 token 索引。索引选自[0, 1]:- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- input_mask (形状为
batch_size, sequence_length的torch.FloatTensor, 可选) — 用于避免对 padding token 索引执行注意力的 Mask。attention_mask的负数，即真实 token 为 0，padding 为 1，这与原始代码库保持兼容。Mask 值选自
[0, 1]：- 1 表示 token 被遮蔽，
- 0 表示 token 未被遮蔽。
input_mask和attention_mask只能使用其中一个。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 用于 nullify 自注意力模块中选定 head 的 Mask。Mask 值选自[0, 1]：- 1 表示 head 未被遮蔽，
- 0 表示 head 被遮蔽。
- 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 而不是普通元组。
返回值
transformers.models.xlnet.modeling_xlnet.XLNetModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
last_hidden_state (形状为
(batch_size, num_predict, hidden_size)的torch.FloatTensor) — 模型最后一层的隐藏状态序列。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 -
mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可用于（参见mems输入）加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 的输出一个，加上每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
XLNetModel forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, XLNetModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetModel.from_pretrained("xlnet/xlnet-base-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_stateXLNetLMHeadModel
class transformers.XLNetLMHeadModel
< source >( config )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
XLNet 模型，顶部带有一个语言建模 head（线性层，其权重与输入 embeddings 绑定）。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor, 可选) — 用于避免对 padding token 索引执行注意力的 Mask。Mask 值选自[0, 1]：- 1 表示 token 未被遮蔽，
- 0 表示 token 被遮蔽。
- mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态 (见下面的mems输出)。可用于加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。必须将
use_mems设置为True才能使用mems。 - perm_mask (形状为
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可选) — 用于指示每个输入 token 的注意力模式的 Mask，值选自[0, 1]:- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 关注 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不关注 j。
如果未设置，则每个 token 都会关注所有其他 token（完全双向注意力）。仅在预训练期间（用于定义因式分解顺序）或顺序解码（生成）时使用。
- 如果
- target_mapping (形状为
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可选) — 用于指示要使用的输出 token 的 Mask。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。仅在预训练期间用于部分预测或顺序解码（生成）。 - token_type_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 用于指示输入的第一部分和第二部分的片段 token 索引。索引选自[0, 1]:- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- input_mask (形状为
batch_size, sequence_length的torch.FloatTensor, 可选) — 用于避免对 padding token 索引执行注意力的 Mask。attention_mask的负数，即真实 token 为 0，padding 为 1，这与原始代码库保持兼容。Mask 值选自
[0, 1]：- 1 表示 token 被遮蔽，
- 0 表示 token 未被遮蔽。
input_mask和attention_mask只能使用其中一个。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空自注意力模块中选定 head 的掩码。掩码值应在[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- 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, num_predict)，可选) — 用于掩码语言建模的标签。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。标签应对应于应预测的掩码输入词，并取决于
target_mapping。请注意，为了执行标准的自回归语言建模，必须将标记添加到 input_ids中（请参阅prepare_inputs_for_generation函数和下面的示例）索引在
[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都将被忽略，损失仅针对[0, ..., config.vocab_size]中的标签计算
返回值
transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
torch.FloatTensor，形状为 (1,)，可选，当提供labels时返回) 语言建模损失（用于预测下一个 token）。 -
logits (
torch.FloatTensor，形状为(batch_size, num_predict, config.vocab_size)) — 语言建模 head 的预测分数（SoftMax 之前每个词汇表 token 的分数）。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 -
mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可用于（参见mems输入）加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 的输出一个，加上每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
XLNetLMHeadModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, XLNetLMHeadModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = XLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")
>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping)
>>> next_token_logits = outputs[
... 0
... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]
>>> # The same way can the XLNetLMHeadModel be used to be trained by standard auto-regressive language modeling.
>>> input_ids = torch.tensor(
... tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=False)
... ).unsqueeze(
... 0
... ) # We will predict the masked token
>>> labels = torch.tensor(tokenizer.encode("cute", add_special_tokens=False)).unsqueeze(0)
>>> assert labels.shape[0] == 1, "only one word will be predicted"
>>> perm_mask = torch.zeros((1, input_ids.shape[1], input_ids.shape[1]), dtype=torch.float)
>>> perm_mask[
... :, :, -1
... ] = 1.0 # Previous tokens don't see last token as is done in standard auto-regressive lm training
>>> target_mapping = torch.zeros(
... (1, 1, input_ids.shape[1]), dtype=torch.float
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(input_ids, perm_mask=perm_mask, target_mapping=target_mapping, labels=labels)
>>> loss = outputs.loss
>>> next_token_logits = (
... outputs.logits
... ) # Logits have shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]XLNetForSequenceClassification
class transformers.XLNetForSequenceClassification
< source >( config )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
XLNet 模型，顶部带有一个序列分类/回归 head（pooled 输出顶部的线性层），例如用于 GLUE 任务。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 避免对 padding token 索引执行 attention 的掩码。掩码值应在[0, 1]中选择：- 1 表示 token 未被掩蔽，
- 0 表示 token 被掩蔽。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（请参阅下面的mems输出）。可用于加速顺序解码。已将其过去状态提供给此模型的 token ID 不应作为input_ids传递，因为它们已被计算。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensor，形状为(batch_size, sequence_length, sequence_length)，可选) — 用于指示每个输入 token 的 attention 模式的掩码，值在[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i attend 到 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不 attend 到 j。
如果未设置，则每个 token 都 attend 到所有其他 token（完全双向 attention）。仅在预训练期间（用于定义分解顺序）或顺序解码（生成）时使用。
- 如果
- target_mapping (
torch.FloatTensor，形状为(batch_size, num_predict, sequence_length)，可选) — 用于指示要使用的输出 token 的掩码。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。仅在预训练期间用于部分预测或顺序解码（生成）。 - token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 分段 token 索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
- input_mask (
torch.FloatTensor，形状为batch_size, sequence_length，可选) — 避免对 padding token 索引执行 attention 的掩码。attention_mask的负数，即实际 token 为 0，padding 为 1，这与原始代码库保持兼容。掩码值应在
[0, 1]中选择：- 1 表示 token 被掩蔽，
- 0 表示 token 未被掩蔽。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于置空自注意力模块中选定 head 的掩码。掩码值应在[0, 1]中选择：- 1 表示 head 未被掩蔽，
- 0 表示 head 被掩蔽。
- 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.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或者当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供label时返回) — 分类（或回归，如果 config.num_labels==1）损失。 -
logits (
torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（或回归，如果 config.num_labels==1）分数（在 SoftMax 之前）。 -
mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可用于（参见mems输入）加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 的输出一个，加上每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
XLNetForSequenceClassification 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
单标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-base-cased")
>>> 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 = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-base-cased", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss多标签分类示例
>>> import torch
>>> from transformers import AutoTokenizer, XLNetForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForSequenceClassification.from_pretrained("xlnet/xlnet-base-cased", 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 = XLNetForSequenceClassification.from_pretrained(
... "xlnet/xlnet-base-cased", 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).lossXLNetForMultipleChoice
class transformers.XLNetForMultipleChoice
< source >( config )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
XLNet 模型，顶部带有一个多项选择分类头（池化输出顶部的线性层和一个 softmax），例如用于 RACE/SWAG 任务。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput or tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, num_choices, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, num_choices, sequence_length)的torch.FloatTensor, 可选) — 避免对 padding token 索引执行 attention 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 tokens 未被掩盖，
- 0 表示 tokens 被掩盖。
- mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的 hidden-states（请参阅下面的mems输出）。可用于加速顺序解码。已将其过去状态提供给此模型的 token ids 不应作为input_ids传递，因为它们已被计算。use_mems必须设置为True才能使用mems。 - perm_mask (形状为
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可选) — Mask，指示每个输入 token 的 attention 模式，值在[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i attend to j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不 attend to j。
如果未设置，则每个 token 都会 attend to 所有其他 token（完全双向 attention）。仅在预训练期间（定义分解顺序）或顺序解码（生成）时使用。
- 如果
- target_mapping (形状为
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可选) — Mask，指示要使用的输出 tokens。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。仅在预训练期间用于部分预测或顺序解码（生成）。 - token_type_ids (形状为
(batch_size, num_choices, sequence_length)的torch.LongTensor, 可选) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引在[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- input_mask (形状为
batch_size, num_choices, sequence_length的torch.FloatTensor, 可选) — Mask，用于避免对 padding token 索引执行 attention。attention_mask的负数，即真实 token 为 0，padding 为 1，保留它是为了与原始代码库兼容。Mask 值在
[0, 1]中选择：- 1 表示 tokens 被掩盖，
- 0 表示 tokens 未被掩盖。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 用于 nullify self-attention 模块的选定 head 的 Mask。Mask 值在[0, 1]中选择：- 1 表示 head 未被掩盖，
- 0 表示 head 被掩盖。
- inputs_embeds (形状为
(batch_size, num_choices, sequence_length, hidden_size)的torch.FloatTensor, 可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。 如果您希望比模型的内部嵌入查找矩阵更好地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息，请参阅返回的 tensors 下的attentions。 - output_hidden_states (
bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息，请参阅返回的 tensors 下的hidden_states。 - return_dict (
bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。 - labels (形状为
(batch_size,)的torch.LongTensor, 可选) — 用于计算多项选择分类损失的标签。索引应为[0, ..., num_choices-1]，其中num_choices是输入 tensors 的第二个维度的大小。（请参阅上面的input_ids）
返回值
transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput or tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput 或一个 torch.FloatTensor 的 tuple （如果传递了 return_dict=False 或当 config.return_dict=False 时），包括取决于配置 (XLNetConfig) 和输入的各种元素。
-
loss (形状为 (1,) 的
torch.FloatTensor, 可选, 当提供labels时返回) — 分类损失。 -
logits (形状为
(batch_size, num_choices)的torch.FloatTensor) — num_choices 是输入 tensors 的第二个维度。（请参阅上面的 input_ids）。分类得分（SoftMax 之前）。
-
mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可用于（参见mems输入）加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 的输出一个，加上每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
XLNetForMultipleChoice forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, XLNetForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForMultipleChoice.from_pretrained("xlnet/xlnet-base-cased")
>>> 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.logitsXLNetForTokenClassification
class transformers.XLNetForTokenClassification
< source >( config )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
XLNet 模型，顶部带有一个 token 分类头（hidden-states 输出顶部的线性层），例如用于命名实体识别 (NER) 任务。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput or tuple(torch.FloatTensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列 tokens 的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（参见下面的mems输出）。可用于加速序列解码。已经将过去信息提供给此模型的标记 ID 不应作为input_ids传递，因为它们已被计算。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensor，形状为(batch_size, sequence_length, sequence_length)，可选) — 用于指示每个输入标记的 attention 模式的掩码，值在[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则在批次 k 中，i 关注 j； - 如果
perm_mask[k, i, j] = 1，则在批次 k 中，i 不关注 j。
如果未设置，则每个标记都关注所有其他标记（完全双向 attention）。仅在预训练期间（用于定义因式分解顺序）或用于序列解码（生成）期间使用。
- 如果
- target_mapping (
torch.FloatTensor，形状为(batch_size, num_predict, sequence_length)，可选) — 用于指示要使用的输出标记的掩码。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个标记上。仅在预训练期间用于部分预测或用于序列解码（生成）。 - token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 分段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：- 0 对应于句子 A 标记，
- 1 对应于句子 B 标记。
- input_mask (
torch.FloatTensor，形状为batch_size, sequence_length，可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。attention_mask的负数，即真实标记为 0，padding 为 1，保留它是为了与原始代码库兼容。掩码值在
[0, 1]中选择：- 1 表示被掩码的标记，
- 0 表示未被掩码的标记。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于使自 attention 模块的选定 head 失效的掩码。掩码值在[0, 1]中选择：- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是普通元组。 - labels (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices]中，其中 num_choices 是输入张量的第二个维度的大小。（参见上面的 input_ids）
返回值
transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类损失。 -
logits (
torch.FloatTensor，形状为(batch_size, sequence_length, config.num_labels)) — 分类得分（在 SoftMax 之前）。 -
mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可用于（参见mems输入）加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 的输出一个，加上每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
XLNetForTokenClassification 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, XLNetForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet/xlnet-base-cased")
>>> 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]]
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).lossXLNetForQuestionAnsweringSimple
class transformers.XLNetForQuestionAnsweringSimple
< source >( config )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
用于抽取式问答任务（如 SQuAD）的顶部带有跨度分类 head 的 XLNet 模型（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在[0, 1]中选择：- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（参见下面的mems输出）。可用于加速序列解码。已经将过去信息提供给此模型的标记 ID 不应作为input_ids传递，因为它们已被计算。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensor，形状为(batch_size, sequence_length, sequence_length)，可选) — 用于指示每个输入标记的 attention 模式的掩码，值在[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则在批次 k 中，i 关注 j； - 如果
perm_mask[k, i, j] = 1，则在批次 k 中，i 不关注 j。
如果未设置，则每个标记都关注所有其他标记（完全双向 attention）。仅在预训练期间（用于定义因式分解顺序）或用于序列解码（生成）期间使用。
- 如果
- target_mapping (
torch.FloatTensor，形状为(batch_size, num_predict, sequence_length)，可选) — 用于指示要使用的输出标记的掩码。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个标记上。仅在预训练期间用于部分预测或用于序列解码（生成）。 - token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 分段 token 索引用于指示输入的第一个和第二个部分。索引从[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- input_mask (
torch.FloatTensor，形状为batch_size, sequence_length，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。是attention_mask的负数，即对于真实 token 为 0，对于 padding 为 1，这保持了与原始代码库的兼容性。掩码值从
[0, 1]中选择：- 1 表示 token 是 masked（被掩码），
- 0 表示 token 是 not masked（未被掩码）。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于 nullify （置零） self-attention 模块中选定的 head 的掩码。掩码值从[0, 1]中选择：- 1 表示 head 是 not masked（未被掩码），
- 0 表示 head 是 masked（被掩码）。
- inputs_embeds (
torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为相关的向量，这将非常有用。 - output_attentions (
bool，可选) — 是否返回所有 attention 层的 attention tensors。有关更多详细信息，请参阅返回 tensors 下的attentions。 - output_hidden_states (
bool，可选) — 是否返回所有层的 hidden states。有关更多详细信息，请参阅返回 tensors 下的hidden_states。 - return_dict (
bool，可选) — 是否返回 ModelOutput 而不是纯粹的 tuple。 - start_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的带标签跨度开始位置（索引）的标签。位置被限制在序列的长度 (sequence_length) 内。序列之外的位置不计入损失计算。 - end_positions (
torch.LongTensor，形状为(batch_size,)，可选) — 用于计算 token 分类损失的带标签跨度结束位置（索引）的标签。位置被限制在序列的长度 (sequence_length) 内。序列之外的位置不计入损失计算。
返回值
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或一个 torch.FloatTensor 的 tuple（如果传递了 return_dict=False，或者当 config.return_dict=False 时），包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵损失之和。 -
start_logits (
torch.FloatTensor，形状为(batch_size, sequence_length,)) — 跨度开始得分（在 SoftMax 之前）。 -
end_logits (
torch.FloatTensor，形状为(batch_size, sequence_length,)) — 跨度结束得分（在 SoftMax 之前）。 -
mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可用于（参见mems输入）加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 的输出一个，加上每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
XLNetForQuestionAnsweringSimple 的 forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, XLNetForQuestionAnsweringSimple
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-base-cased")
>>> 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]
>>> # 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.lossXLNetForQuestionAnswering
class transformers.XLNetForQuestionAnswering
< source >( config )
参数
- config (XLNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
用于抽取式问答任务（如 SQuAD）的顶部带有跨度分类 head 的 XLNet 模型（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝头等）。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以了解与一般用法和行为相关的所有事项。
forward
< source >( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None mems: typing.Optional[torch.Tensor] = None perm_mask: typing.Optional[torch.Tensor] = None target_mapping: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None input_mask: typing.Optional[torch.Tensor] = None head_mask: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None is_impossible: typing.Optional[torch.Tensor] = None cls_index: typing.Optional[torch.Tensor] = None p_mask: typing.Optional[torch.Tensor] = None use_mems: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) → transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput 或 tuple(torch.FloatTensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。掩码值从[0, 1]中选择：- 1 表示 token 是 not masked（未被掩码），
- 0 表示 token 是 masked（被掩码）。
- mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的 hidden-states（参见下面的mems输出）。 可以用于加速序列解码。已将其过去状态提供给此模型的 token ids 不应作为input_ids传递，因为它们已被计算。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensor，形状为(batch_size, sequence_length, sequence_length)，可选) — 用于指示每个输入 token 的 attention 模式的掩码，值从[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 关注 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不关注 j。
如果未设置，则每个 token 关注所有其他 token（完全双向 attention）。仅在预训练期间（用于定义分解顺序）或用于序列解码（生成）时使用。
- 如果
- target_mapping (
torch.FloatTensor，形状为(batch_size, num_predict, sequence_length)，可选) — 用于指示要使用的输出 token 的掩码。 如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测在第 j 个 token 上。 仅在预训练期间用于部分预测或用于序列解码（生成）。 - token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 分段 token 索引用于指示输入的第一个和第二个部分。索引从[0, 1]中选择：- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- input_mask (
torch.FloatTensor，形状为batch_size, sequence_length，可选) — 用于避免在 padding token 索引上执行 attention 的掩码。是attention_mask的负数，即对于真实 token 为 0，对于 padding 为 1，这保持了与原始代码库的兼容性。掩码值从
[0, 1]中选择：- 1 表示 token 是 masked（被掩码），
- 0 表示 token 是 not masked（未被掩码）。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 用于 nullify （置零） self-attention 模块中选定的 head 的掩码。掩码值从[0, 1]中选择：- 1 表示 head 是 not masked（未被掩码），
- 0 表示 head 是 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 而不是普通元组。 - start_positions (
torch.LongTensor，形状为(batch_size,)，*可选*) — 用于计算 token 分类损失的已标注 span 起始位置（索引）的标签。 位置被限制在序列的长度 (sequence_length) 内。 序列之外的位置不计入损失计算。 - end_positions (
torch.LongTensor，形状为(batch_size,)，*可选*) — 用于计算 token 分类损失的已标注 span 结束位置（索引）的标签。 位置被限制在序列的长度 (sequence_length) 内。 序列之外的位置不计入损失计算。 - is_impossible (
torch.LongTensor，形状为(batch_size,)，*可选*) — 标签指示问题是否有答案（SQuAD 2.0）。 - cls_index (
torch.LongTensor，形状为(batch_size,)，*可选*) — 用于计算答案合理性的分类 token 的位置（索引）标签。 - p_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，*可选*) — 可选的 mask，用于遮蔽不能在答案中的 token（例如 [CLS], [PAD], ...）。 1.0 表示 token 应该被遮蔽。 0.0 表示 token 不被遮蔽。
返回值
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput 或 tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或当 config.return_dict=False 时），包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
torch.FloatTensor，形状为(1,)，*可选*，如果同时提供start_positions和end_positions则返回) — 分类损失，为起始 token、结束 token（以及如果提供is_impossible）分类损失的总和。 -
start_top_log_probs (
torch.FloatTensor，形状为(batch_size, config.start_n_top)，*可选*，如果未提供start_positions或end_positions则返回) — 排名靠前的config.start_n_top个起始 token 可能性的对数概率（beam-search）。 -
start_top_index (
torch.LongTensor，形状为(batch_size, config.start_n_top)，*可选*，如果未提供start_positions或end_positions则返回) — 排名靠前的config.start_n_top个起始 token 可能性的索引（beam-search）。 -
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个结束 token 可能性的对数概率（beam-search）。 -
end_top_index (
torch.LongTensor，形状为(batch_size, config.start_n_top * config.end_n_top)，*可选*，如果未提供start_positions或end_positions则返回) — 排名靠前的config.start_n_top * config.end_n_top个结束 token 可能性的索引（beam-search）。 -
cls_logits (
torch.FloatTensor，形状为(batch_size,)，*可选*，如果未提供start_positions或end_positions则返回) — 答案的is_impossible标签的对数概率。 -
mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态。可用于（参见mems输入）加速顺序解码。已将过去信息提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(torch.FloatTensor), 可选, 当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —torch.FloatTensor元组（embeddings 的输出一个，加上每层的输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(torch.FloatTensor), 可选, 当传递output_attentions=True或当config.output_attentions=True时返回) —torch.FloatTensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
The XLNetForQuestionAnswering forward 方法覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, XLNetForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet/xlnet-base-cased")
>>> 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.lossTFXLNetModel
class transformers.TFXLNetModel
< source >( config *inputs **kwargs )
参数
- config (XLNetConfig) — 模型配置类，包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重，只会加载配置。 请查看 from_pretrained() 方法来加载模型权重。
输出原始隐藏状态且顶部没有任何特定头的裸 XLNet 模型 Transformer。
此模型继承自 TFPreTrainedModel。 请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 的子类。 将其用作常规的 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与常规用法和行为相关的所有事项。
TensorFlow models and layers in transformers accept two formats as input
- having all inputs as keyword arguments (like PyTorch models), or
- having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models and layers. Because of this support, when using methods like model.fit() things should “just work” for you - just pass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second format outside of Keras methods like fit() and predict(), such as when creating your own layers or models with the Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first positional argument
- a single Tensor with
input_idsonly and nothing else:model(input_ids) - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
model([input_ids, attention_mask])ormodel([input_ids, attention_mask, token_type_ids]) - a dictionary with one or several input Tensors associated to the input names given in the docstring:
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
Note that when creating models and layers with subclassing then you don’t need to worry about any of this, as you can just pass inputs like you would to any other Python function!
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput or tuple(tf.Tensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。 索引可以使用 AutoTokenizer 获得。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.__call__()。 什么是输入 IDs？ - attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，*可选*) — 用于避免对 padding token 索引执行 attention 的 mask。 Mask 值在[0, 1]中选择：- 1 表示 token 未被遮蔽，
- 0 表示 token 已被遮蔽。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（参见下面的mems输出）。 可用于加速顺序解码。 已将其过去状态提供给此模型的 token IDs 不应作为input_ids传递，因为它们已被计算。 必须将use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensor，形状为(batch_size, sequence_length, sequence_length)，*可选*) — Mask 用于指示每个输入 token 的 attention 模式，值在[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i attend 到 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不 attend 到 j。
- 如果
- target_mapping (
torch.FloatTensor，形状为(batch_size, num_predict, sequence_length)，*可选*) — Mask 用于指示要使用的输出 token。 如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。 仅在预训练期间用于部分预测或用于顺序解码（生成）。 - token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，*可选*) — 分段 token 索引，用于指示输入的第一个和第二个部分。 索引在[0, 1]中选择：- 0 对应于句子 A token，
- 1 对应于句子 B token。
- input_mask (
torch.FloatTensor，形状为batch_size, sequence_length，*可选*) — Mask 用于避免对 padding token 索引执行 attention。attention_mask的负值，即对于真实 token 为 0，对于 padding 为 1，保留它是为了与原始代码库兼容。 Mask 值在[0, 1]中选择：- 1 表示 token 已被遮蔽，
- 0 表示 token 未被遮蔽。
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，*可选*) — Mask 用于 nullify self-attention 模块的选定 head。 Mask 值在[0, 1]中选择：- 1 表示 head 未被遮蔽，
- 0 表示 head 已被遮蔽。
- 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 而不是普通元组。
返回值
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput 或 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
last_hidden_state (
tf.Tensor，形状为(batch_size, num_predict, hidden_size)) — 模型最后一层的隐藏状态序列。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态。 可用于（参见mems输入）加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFXLNetModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFXLNetModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetModel.from_pretrained("xlnet/xlnet-base-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_stateTFXLNetLMHeadModel
class transformers.TFXLNetLMHeadModel
< source >( config *inputs **kwargs )
参数
- config (XLNetConfig) — 具有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重，仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
XLNet 模型，顶部带有一个语言建模 head（线性层，其权重与输入 embeddings 绑定）。
此模型继承自 TFPreTrainedModel。 请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 的子类。 将其用作常规的 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与常规用法和行为相关的所有事项。
TensorFlow models and layers in transformers accept two formats as input
- having all inputs as keyword arguments (like PyTorch models), or
- having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models and layers. Because of this support, when using methods like model.fit() things should “just work” for you - just pass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second format outside of Keras methods like fit() and predict(), such as when creating your own layers or models with the Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first positional argument
- a single Tensor with
input_idsonly and nothing else:model(input_ids) - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
model([input_ids, attention_mask])ormodel([input_ids, attention_mask, token_type_ids]) - a dictionary with one or several input Tensors associated to the input names given in the docstring:
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
Note that when creating models and layers with subclassing then you don’t need to worry about any of this, as you can just pass inputs like you would to any other Python function!
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput 或 tuple(tf.Tensor)
参数
- input_ids (
torch.LongTensor，形状为(batch_size, sequence_length)) — 词汇表中输入序列令牌的索引。可以使用 AutoTokenizer 获取索引。 有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 掩码，以避免在填充令牌索引上执行注意力机制。 在[0, 1]中选择的掩码值：- 1 表示未掩码的令牌，
- 0 表示已掩码的令牌。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（参见下面的mems输出）。 可用于加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensor，形状为(batch_size, sequence_length, sequence_length)，可选) — 掩码，用于指示每个输入令牌的注意力模式，值在[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 关注 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不关注 j。
如果未设置，则每个令牌都关注所有其他令牌（完全双向注意力）。 仅在预训练期间（用于定义因式分解顺序）或用于顺序解码（生成）时使用。
- 如果
- target_mapping (
torch.FloatTensor，形状为(batch_size, num_predict, sequence_length)，可选) — 掩码，用于指示要使用的输出令牌。 如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个令牌上。 仅在预训练期间用于部分预测或用于顺序解码（生成）。 - token_type_ids (
torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 分段令牌索引，用于指示输入的第一部分和第二部分。 索引在[0, 1]中选择：- 0 对应于句子 A 令牌，
- 1 对应于句子 B 令牌。
- input_mask (
torch.FloatTensor，形状为batch_size, sequence_length，可选) — 掩码，以避免在填充令牌索引上执行注意力机制。attention_mask的负数，即，实际令牌为 0，填充为 1，这与原始代码库保持兼容。在
[0, 1]中选择的掩码值：- 1 表示已掩码的令牌，
- 0 表示未掩码的令牌。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor，形状为(num_heads,)或(num_layers, num_heads)，可选) — 掩码，用于使自注意力模块的选定头无效。 在[0, 1]中选择的掩码值：- 1 表示头未被掩码，
- 0 表示头已被掩码。
- 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 (
tf.Tensor，形状为(batch_size, sequence_length)，可选) — 用于计算交叉熵分类损失的标签。 索引应在[0, ..., config.vocab_size - 1]中。
返回值
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput 或 tuple(tf.Tensor)
一个 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput 或 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
tf.Tensor，形状为 (1,)，可选，当提供labels时返回) 语言建模损失（用于下一个令牌预测）。 -
logits (
tf.Tensor，形状为(batch_size, num_predict, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇表令牌的分数）。num_predict对应于target_mapping.shape[1]。如果target_mapping为None，则num_predict对应于sequence_length。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态。 可用于（参见mems输入）加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFXLNetLMHeadModel 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> import tensorflow as tf
>>> import numpy as np
>>> from transformers import AutoTokenizer, TFXLNetLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-large-cased")
>>> model = TFXLNetLMHeadModel.from_pretrained("xlnet/xlnet-large-cased")
>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = tf.constant(tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=True))[
... None, :
... ] # We will predict the masked token
>>> perm_mask = np.zeros((1, input_ids.shape[1], input_ids.shape[1]))
>>> perm_mask[:, :, -1] = 1.0 # Previous tokens don't see last token
>>> target_mapping = np.zeros(
... (1, 1, input_ids.shape[1])
... ) # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
... 0, 0, -1
... ] = 1.0 # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(
... input_ids,
... perm_mask=tf.constant(perm_mask, dtype=tf.float32),
... target_mapping=tf.constant(target_mapping, dtype=tf.float32),
... )
>>> next_token_logits = outputs[
... 0
... ] # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]TFXLNetForSequenceClassification
class transformers.TFXLNetForSequenceClassification
< 源代码 >( config *inputs **kwargs )
参数
- config (XLNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
XLNet 模型，顶部带有一个序列分类/回归 head（pooled 输出顶部的线性层），例如用于 GLUE 任务。
此模型继承自 TFPreTrainedModel。 请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 的子类。 将其用作常规的 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与常规用法和行为相关的所有事项。
TensorFlow models and layers in transformers accept two formats as input
- having all inputs as keyword arguments (like PyTorch models), or
- having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models and layers. Because of this support, when using methods like model.fit() things should “just work” for you - just pass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second format outside of Keras methods like fit() and predict(), such as when creating your own layers or models with the Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first positional argument
- a single Tensor with
input_idsonly and nothing else:model(input_ids) - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
model([input_ids, attention_mask])ormodel([input_ids, attention_mask, token_type_ids]) - a dictionary with one or several input Tensors associated to the input names given in the docstring:
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
Note that when creating models and layers with subclassing then you don’t need to worry about any of this, as you can just pass inputs like you would to any other Python function!
call
< 源代码 >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput 或 tuple(tf.Tensor)
参数
- input_ids (形状为
(batch_size, sequence_length)的torch.LongTensor) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, sequence_length)的torch.FloatTensor, 可选) — 用于避免对填充标记索引执行注意力机制的掩码。掩码值在[0, 1]中选择：- 1 表示 未被掩码 的标记，
- 0 表示 已被掩码 的标记。
- mems (长度为
config.n_layers的List[torch.FloatTensor]) — 包含预先计算的隐藏状态（请参阅下面的mems输出）。可用于加速顺序解码。已将过去状态提供给此模型的标记 ID 不应作为input_ids传递，因为它们已被计算。use_mems必须设置为True才能使用mems。 - perm_mask (形状为
(batch_size, sequence_length, sequence_length)的torch.FloatTensor, 可选) — 用于指示每个输入标记的注意力模式的掩码，值在[0, 1]中选择：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不注意 j。
如果未设置，则每个标记都注意所有其他标记（完全双向注意力）。仅在预训练期间（用于定义分解顺序）或用于顺序解码（生成）时使用。
- 如果
- target_mapping (形状为
(batch_size, num_predict, sequence_length)的torch.FloatTensor, 可选) — 用于指示要使用的输出标记的掩码。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个标记上。仅在预训练期间用于部分预测或用于顺序解码（生成）。 - token_type_ids (形状为
(batch_size, sequence_length)的torch.LongTensor, 可选) — 分段标记索引，用于指示输入的第一个和第二个部分。索引在[0, 1]中选择：- 0 对应于 *句子 A* 标记，
- 1 对应于 *句子 B* 标记。
- input_mask (形状为
batch_size, sequence_length的torch.FloatTensor, 可选) — 用于避免对填充标记索引执行注意力机制的掩码。attention_mask的负数，即真实标记为 0，填充为 1，这保留是为了与原始代码库兼容。掩码值在
[0, 1]中选择：- 1 表示 已被掩码 的标记，
- 0 表示 未被掩码 的标记。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (形状为
(num_heads,)或(num_layers, num_heads)的torch.FloatTensor, 可选) — 用于使自注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：- 1 表示头部 未被掩码，
- 0 表示头部 已被掩码。
- 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 (形状为
(batch_size,)的tf.Tensor, 可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]中。如果config.num_labels == 1，则计算回归损失（均方误差损失）。如果config.num_labels > 1，则计算分类损失（交叉熵损失）。
返回值
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput 或 tuple(tf.Tensor)
一个 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (形状为
(1,)的tf.Tensor, 可选, 当提供label时返回) — 分类（或回归，如果config.num_labels==1）损失。 -
logits (形状为
(batch_size, config.num_labels)的tf.Tensor) — 分类（或回归，如果config.num_labels==1）得分（在 SoftMax 之前）。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态。 可用于（参见mems输入）加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFXLNetForSequenceClassification 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFXLNetForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForSequenceClassification.from_pretrained("xlnet/xlnet-base-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])>>> # 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 = TFXLNetForSequenceClassification.from_pretrained("xlnet/xlnet-base-cased", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).lossTFXLNetForMultipleChoice
class transformers.TFXLNetForMultipleChoice
< 源代码 >( config *inputs **kwargs )
参数
- config (XLNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
XLNET 模型，顶部具有多项选择分类头（池化输出顶部的线性层和一个 softmax），例如用于 RocStories/SWAG 任务。
此模型继承自 TFPreTrainedModel。 请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 的子类。 将其用作常规的 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与常规用法和行为相关的所有事项。
TensorFlow models and layers in transformers accept two formats as input
- having all inputs as keyword arguments (like PyTorch models), or
- having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models and layers. Because of this support, when using methods like model.fit() things should “just work” for you - just pass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second format outside of Keras methods like fit() and predict(), such as when creating your own layers or models with the Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first positional argument
- a single Tensor with
input_idsonly and nothing else:model(input_ids) - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
model([input_ids, attention_mask])ormodel([input_ids, attention_mask, token_type_ids]) - a dictionary with one or several input Tensors associated to the input names given in the docstring:
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
Note that when creating models and layers with subclassing then you don’t need to worry about any of this, as you can just pass inputs like you would to any other Python function!
call
< 源代码 >( input_ids: TFModelInputType | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput 或 tuple(tf.Tensor)
参数
- input_ids (形状为
(batch_size, num_choices, sequence_length)的torch.LongTensor) — 词汇表中输入序列标记的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (形状为
(batch_size, num_choices, sequence_length)的torch.FloatTensor, 可选) — 用于避免对填充标记索引执行注意力机制的掩码。掩码值在[0, 1]中选择：- 1 表示 未被掩码 的标记，
- 0 表示 已被掩码 的标记。
- mems (
List[torch.FloatTensor]of lengthconfig.n_layers) — 包含预先计算的隐藏状态（参见下面的mems输出）。可用于加速顺序解码。已将过去状态提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensorof shape(batch_size, sequence_length, sequence_length), optional) — 用于指示每个输入 token 的注意力模式的 Mask，值选自[0, 1]：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 关注 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不关注 j。
如果未设置，则每个 token 都会关注所有其他 token（完全双向注意力）。仅在预训练期间（用于定义因式分解顺序）或顺序解码（生成）时使用。
- 如果
- target_mapping (
torch.FloatTensorof shape(batch_size, num_predict, sequence_length), optional) — 用于指示要使用的输出 token 的 Mask。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。仅在预训练期间用于部分预测或顺序解码（生成）。 - token_type_ids (
torch.LongTensorof shape(batch_size, num_choices, sequence_length), optional) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引选自[0, 1]：- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
- input_mask (
torch.FloatTensorof shapebatch_size, num_choices, sequence_length, optional) — 用于避免对 padding token 索引执行注意力的 Mask。attention_mask的负数，即对于真实 token 为 0，对于 padding 为 1，这与原始代码库保持兼容。Mask 值选自
[0, 1]：- 1 表示 token 被掩码，
- 0 表示 token 未被掩码。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensorof shape(num_heads,)or(num_layers, num_heads), optional) — 用于 nullify 自注意力模块的选定 head 的 Mask。Mask 值选自[0, 1]：- 1 表示 head 未被掩码，
- 0 表示 head 被掩码。
- inputs_embeds (
torch.FloatTensorof shape(batch_size, num_choices, sequence_length, hidden_size), optional) — （可选）您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将input_ids索引转换为关联的向量，这将非常有用。 - output_attentions (
bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。 - output_hidden_states (
bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。 - return_dict (
bool, optional) — 是否返回 ModelOutput 而不是普通元组。 - labels (
tf.Tensorof shape(batch_size,), optional) — 用于计算多项选择分类损失的标签。索引应为[0, ..., num_choices]，其中num_choices是输入张量的第二个维度的大小。（请参阅上面的input_ids）
返回值
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput 或 tuple(tf.Tensor)
一个 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
tf.Tensorof shape (1,), optional, 当提供labels时返回) — 分类损失。 -
logits (
tf.Tensorof shape(batch_size, num_choices)) — num_choices 是输入张量的第二个维度。（请参阅上面的 input_ids）。分类得分（SoftMax 之前）。
-
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态。 可用于（参见mems输入）加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFXLNetForMultipleChoice forward 方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFXLNetForMultipleChoice
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForMultipleChoice.from_pretrained("xlnet/xlnet-base-cased")
>>> 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."
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs) # batch size is 1
>>> # the linear classifier still needs to be trained
>>> logits = outputs.logitsTFXLNetForTokenClassification
class transformers.TFXLNetForTokenClassification
< source >( config *inputs **kwargs )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，而只会加载配置。查看 from_pretrained() 方法以加载模型权重。
XLNet 模型，顶部带有一个 token 分类头（hidden-states 输出顶部的线性层），例如用于命名实体识别 (NER) 任务。
此模型继承自 TFPreTrainedModel。 请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 的子类。 将其用作常规的 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与常规用法和行为相关的所有事项。
TensorFlow models and layers in transformers accept two formats as input
- having all inputs as keyword arguments (like PyTorch models), or
- having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models and layers. Because of this support, when using methods like model.fit() things should “just work” for you - just pass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second format outside of Keras methods like fit() and predict(), such as when creating your own layers or models with the Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first positional argument
- a single Tensor with
input_idsonly and nothing else:model(input_ids) - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
model([input_ids, attention_mask])ormodel([input_ids, attention_mask, token_type_ids]) - a dictionary with one or several input Tensors associated to the input names given in the docstring:
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
Note that when creating models and layers with subclassing then you don’t need to worry about any of this, as you can just pass inputs like you would to any other Python function!
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput 或 tuple(tf.Tensor)
参数
- input_ids (
torch.LongTensorof shape(batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。可以使用 AutoTokenizer 获取索引。有关详细信息，请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensorof shape(batch_size, sequence_length), optional) — 用于避免对 padding token 索引执行注意力的 Mask。Mask 值选自[0, 1]：- 1 表示 token 未被掩码，
- 0 表示 token 被掩码。
- mems (
List[torch.FloatTensor]of lengthconfig.n_layers) — 包含预先计算的隐藏状态（参见下面的mems输出）。可用于加速顺序解码。已将过去状态提供给此模型的 token id 不应作为input_ids传递，因为它们已被计算过。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensorof shape(batch_size, sequence_length, sequence_length), optional) — 用于指示每个输入 token 的注意力模式的 Mask，值选自[0, 1]：- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 关注 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不关注 j。
如果未设置，则每个 token 都会关注所有其他 token（完全双向注意力）。仅在预训练期间（用于定义因式分解顺序）或顺序解码（生成）时使用。
- 如果
- target_mapping (
torch.FloatTensorof shape(batch_size, num_predict, sequence_length), optional) — 用于指示要使用的输出 token 的 Mask。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。仅在预训练期间用于部分预测或顺序解码（生成）。 - token_type_ids (
torch.LongTensorof shape(batch_size, sequence_length), optional) — 分段 token 索引，用于指示输入的第一个和第二个部分。索引选自[0, 1]：- 0 对应于 sentence A token，
- 1 对应于 sentence B token。
- input_mask (
torch.FloatTensorof shapebatch_size, sequence_length, optional) — 用于避免对 padding token 索引执行注意力的 Mask。attention_mask的负数，即对于真实 token 为 0，对于 padding 为 1，这与原始代码库保持兼容。Mask 值选自
[0, 1]：- 1 表示 token 被掩码，
- 0 表示 token 未被掩码。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor, 形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于屏蔽自注意力模块中选定头的掩码。掩码值在[0, 1]中选择:- 1 表示头是未被屏蔽的，
- 0 表示头是被屏蔽的。
- 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 (
tf.Tensor, 形状为(batch_size, sequence_length), 可选) — 用于计算 token 分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。
返回值
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput 或 tuple(tf.Tensor)
一个 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
tf.Tensor, 形状为(1,), 可选, 当提供labels时返回) — 分类损失。 -
logits (
tf.Tensor, 形状为(batch_size, sequence_length, config.num_labels)) — 分类得分（SoftMax 之前）。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态。 可用于（参见mems输入）加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFXLNetForTokenClassification 前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFXLNetForTokenClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForTokenClassification.from_pretrained("xlnet/xlnet-base-cased")
>>> inputs = tokenizer(
... "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )
>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-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] for t in predicted_token_class_ids[0].numpy().tolist()]TFXLNetForQuestionAnsweringSimple
class transformers.TFXLNetForQuestionAnsweringSimple
< source >( config *inputs **kwargs )
参数
- config (XLNetConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅加载配置。查看 from_pretrained() 方法以加载模型权重。
用于抽取式问答任务（如 SQuAD）的顶部带有跨度分类 head 的 XLNet 模型（隐藏状态输出顶部的线性层，用于计算 span start logits 和 span end logits）。
此模型继承自 TFPreTrainedModel。 请查看超类文档以了解库为其所有模型实现的通用方法（例如下载或保存、调整输入嵌入大小、剪枝 head 等）。
此模型也是 keras.Model 的子类。 将其用作常规的 TF 2.0 Keras 模型，并参阅 TF 2.0 文档以了解与常规用法和行为相关的所有事项。
TensorFlow models and layers in transformers accept two formats as input
- having all inputs as keyword arguments (like PyTorch models), or
- having all inputs as a list, tuple or dict in the first positional argument.
The reason the second format is supported is that Keras methods prefer this format when passing inputs to models and layers. Because of this support, when using methods like model.fit() things should “just work” for you - just pass your inputs and labels in any format that model.fit() supports! If, however, you want to use the second format outside of Keras methods like fit() and predict(), such as when creating your own layers or models with the Keras Functional API, there are three possibilities you can use to gather all the input Tensors in the first positional argument
- a single Tensor with
input_idsonly and nothing else:model(input_ids) - a list of varying length with one or several input Tensors IN THE ORDER given in the docstring:
model([input_ids, attention_mask])ormodel([input_ids, attention_mask, token_type_ids]) - a dictionary with one or several input Tensors associated to the input names given in the docstring:
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
Note that when creating models and layers with subclassing then you don’t need to worry about any of this, as you can just pass inputs like you would to any other Python function!
call
< source >( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: bool = False ) → transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput 或 tuple(tf.Tensor)
参数
- input_ids (
torch.LongTensor, 形状为(batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。索引可以使用 AutoTokenizer 获得。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
- attention_mask (
torch.FloatTensor, 形状为(batch_size, sequence_length), 可选) — 用于避免在 padding token 索引上执行注意力的掩码。掩码值在[0, 1]中选择:- 1 表示 tokens 是未被掩码的，
- 0 表示 tokens 是被掩码的。
- mems (
List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（参见下面的mems输出）。可用于加速顺序解码。已将其过去信息提供给此模型的 token IDs 不应作为input_ids传递，因为它们已被计算。必须将
use_mems设置为True才能使用mems。 - perm_mask (
torch.FloatTensor, 形状为(batch_size, sequence_length, sequence_length), 可选) — 用于指示每个输入 token 的注意力模式的掩码，值在[0, 1]中选择:- 如果
perm_mask[k, i, j] = 0，则批次 k 中的 i 注意 j； - 如果
perm_mask[k, i, j] = 1，则批次 k 中的 i 不注意 j。
如果未设置，则每个 token 都注意所有其他 token（完全双向注意力）。仅在预训练期间（用于定义分解顺序）或用于顺序解码（生成）时使用。
- 如果
- target_mapping (
torch.FloatTensor, 形状为(batch_size, num_predict, sequence_length), 可选) — 用于指示要使用的输出 token 的掩码。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个 token 上。仅在预训练期间用于部分预测或用于顺序解码（生成）。 - token_type_ids (
torch.LongTensor, 形状为(batch_size, sequence_length), 可选) — 段 token 索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择:- 0 对应于 句子 A token，
- 1 对应于 句子 B token。
- input_mask (
torch.FloatTensor, 形状为batch_size, sequence_length, 可选) — 用于避免在 padding token 索引上执行注意力的掩码。attention_mask的负数，即，真实 tokens 为 0，padding 为 1，这与原始代码库保持兼容。掩码值在
[0, 1]中选择:- 1 表示 tokens 是被掩码的，
- 0 表示 tokens 是未被掩码的。
您只能使用
input_mask和attention_mask中的一个。 - head_mask (
torch.FloatTensor, 形状为(num_heads,)或(num_layers, num_heads), 可选) — 用于 nullify 自注意力模块中选定头的掩码。掩码值在[0, 1]中选择:- 1 表示头是未被屏蔽的，
- 0 表示头是被屏蔽的。
- 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 而不是纯元组。 - start_positions (
tf.Tensor, 形状为(batch_size,), 可选) — 用于计算 token 分类损失的标签跨度的开始位置（索引）。位置被限制在序列的长度（sequence_length）内。序列之外的位置不计入损失计算。 - end_positions (
tf.Tensor, 形状为(batch_size,), 可选) — 用于计算 token 分类损失的标签跨度的结束位置（索引）。位置被限制在序列的长度（sequence_length）内。序列之外的位置不计入损失计算。
返回值
transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput 或 tuple(tf.Tensor)
一个 transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput 或一个 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），其中包含各种元素，具体取决于配置 (XLNetConfig) 和输入。
-
loss (
tf.Tensor, 形状为(1,), 可选, 当提供labels时返回) — 总跨度提取损失是开始和结束位置的交叉熵损失之和。 -
start_logits (
tf.Tensor, 形状为(batch_size, sequence_length,)) — 跨度开始得分（SoftMax 之前）。 -
end_logits (
tf.Tensor，形状为(batch_size, sequence_length,)) — 片段结尾得分（在 SoftMax 之前）。 -
mems (
List[tf.Tensor]，长度为config.n_layers) — 包含预先计算的隐藏状态。 可用于（参见mems输入）加速顺序解码。 已将其过去状态提供给此模型的令牌 ID 不应作为input_ids传递，因为它们已被计算过。 -
hidden_states (
tuple(tf.Tensor)，可选，当传递output_hidden_states=True或当config.output_hidden_states=True时返回) —tf.Tensor元组（嵌入输出一个，每层输出一个），形状为(batch_size, sequence_length, hidden_size)。模型在每层输出以及初始 embedding 输出处的隐藏状态。
-
attentions (
tuple(tf.Tensor)，可选，当传递output_attentions=True或当config.output_attentions=True时返回) —tf.Tensor元组（每层一个），形状为(batch_size, num_heads, sequence_length, sequence_length)。注意力 softmax 之后的注意力权重，用于计算自注意力 head 中的加权平均值。
TFXLNetForQuestionAnsweringSimple 的前向方法，覆盖了 __call__ 特殊方法。
尽管 forward pass 的配方需要在该函数中定义，但应该在之后调用 Module 实例而不是此函数，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。
示例
>>> from transformers import AutoTokenizer, TFXLNetForQuestionAnsweringSimple
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet/xlnet-base-cased")
>>> model = TFXLNetForQuestionAnsweringSimple.from_pretrained("xlnet/xlnet-base-cased")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)
>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]