原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/xlm-roberta-xl
XLM-RoBERTa-XL 模型是由 Naman Goyal、Jingfei Du、Myle Ott、Giri Anantharaman、Alexis Conneau 在用于多语言掩码语言建模的更大规模 Transformer中提出的。
论文摘要如下:
最近的工作表明,跨语言语言模型预训练对于跨语言理解的有效性。在这项研究中,我们展示了两个更大的多语言掩码语言模型的结果,参数分别为 35 亿和 107 亿。我们的两个新模型 XLM-R XL 和 XLM-R XXL 在 XNLI 上的平均准确率比 XLM-R 高出 1.8%和 2.4%。我们的模型还在 GLUE 基准测试的几个英语任务中比 RoBERTa-Large 模型平均高出 0.3%,同时处理了 99 种更多的语言。这表明具有更大容量的预训练模型可能在高资源语言上取得强大性能的同时,极大地改善低资源语言。我们公开提供我们的代码和模型。
此模型由Soonhwan-Kwon和stefan-it贡献。原始代码可以在这里找到。
XLM-RoBERTa-XL 是在 100 种不同语言上训练的多语言模型。与一些 XLM 多语言模型不同,它不需要lang
张量来理解使用的语言,并且应该能够从输入 id 中确定正确的语言。
class transformers.XLMRobertaXLConfig
参数
vocab_size
(int
,可选,默认为 250880)—XLM_ROBERTA_XL 模型的词汇大小。定义了在调用 XLMRobertaXLModel 时可以表示的不同标记数量。
hidden_size
(int
,可选,默认为 2560)—编码器层和池化器层的维度。
num_hidden_layers
(int
,可选,默认为 36)—Transformer 编码器中的隐藏层数量。
num_attention_heads
(int
,可选,默认为 32)—Transformer 编码器中每个注意力层的注意力头数。
intermediate_size
(int
,可选,默认为 10240)—Transformer 编码器中“中间”(通常称为前馈)层的维度。
hidden_act
(str
或Callable
,可选,默认为"gelu"
)—编码器和池化器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。
hidden_dropout_prob
(float
,可选,默认为 0.1)—嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob
(float
,可选,默认为 0.1)—注意力概率的 dropout 比率。
max_position_embeddings
(int
,可选,默认为 514)—此模型可能会与之一起使用的最大序列长度。通常将其设置为较大的值以防万一(例如 512、1024 或 2048)。
type_vocab_size
(int
, 可选, 默认为 1) — 在调用 XLMRobertaXLModel 或TFXLMRobertaXLModel
时传递的token_type_ids
的词汇量大小。
initializer_range
(float
, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态分布初始化器的标准差。
layer_norm_eps
(float
, 可选, 默认为 1e-5) — 层归一化层使用的 epsilon。
position_embedding_type
(str
, 可选, 默认为"absolute"
) — 位置嵌入的类型。选择"absolute"
之一,"relative_key"
,"relative_key_query"
。对于位置嵌入,请使用"absolute"
。有关"relative_key"
的更多信息,请参阅Self-Attention with Relative Position Representations (Shaw et al.)。有关"relative_key_query"
的更多信息,请参阅[Improve Transformer Models with Better Relative Position Embeddings (Huang et al.)]中的Method 4(https://arxiv.org/abs/2009.13658)。
use_cache
(bool
, 可选, 默认为True
) — 模型是否应返回最后的键/值注意力(并非所有模型都使用)。仅在config.is_decoder=True
时相关。
classifier_dropout
(float
, 可选) — 分类头的 dropout 比率。
这是用于存储 XLMRobertaXLModel 或TFXLMRobertaXLModel
配置的配置类。它用于根据指定的参数实例化一个 XLM_ROBERTA_XL 模型,定义模型架构。使用默认值实例化配置将产生类似于 XLM_ROBERTA_XL facebook/xlm-roberta-xl架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。
示例:
class transformers.XLMRobertaXLModel
参数
config
(XLMRobertaXLConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。裸 XLM-RoBERTa-XL 模型变压器输出原始隐藏状态,没有特定的头部。此模型继承自 PreTrainedModel。检查超类文档以获取库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有事项。
该模型可以作为编码器(仅具有自注意力)以及解码器运行,此时在自注意力层之间添加了一层交叉注意力,遵循Attention is all you need一书中描述的架构,作者为 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin。要使模型作为解码器运行,需要将配置中的is_decoder
参数初始化为True
。要在 Seq2Seq 模型中使用,需要将模型初始化为is_decoder
参数和add_cross_attention
参数均设置为True
;然后预期将encoder_hidden_states
作为输入传递给前向传递。Attention is all you need:arxiv.org/abs/1706.03762
forward
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参见 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]
之间:
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]
之间:
masked
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以选择直接传递嵌入表示而不是传递input_ids
。如果您希望更好地控制如何将input_ids
索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。
encoder_hidden_states
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 编码器最后一层的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。
encoder_attention_mask
(形状为 (batch_size, sequence_length)
的 torch.FloatTensor
,可选) — 用于避免在编码器输入的填充标记索引上执行注意力的掩码。如果模型配置为解码器,则在交叉注意力中使用此掩码。选择的掩码值为 [0, 1]
:
past_key_values
(长度为 config.n_layers
的 tuple(tuple(torch.FloatTensor))
,每个元组有 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的张量) — 包含注意力块的预计算的键和值隐藏状态。可用于加速解码。
如果使用了 past_key_values
,用户可以选择只输入形状为 (batch_size, 1)
的最后 decoder_input_ids
(那些没有将它们的过去键值状态提供给此模型的)而不是形状为 (batch_size, sequence_length)
的所有 decoder_input_ids
。
use_cache
(bool
,可选) — 如果设置为 True
,则返回 past_key_values
键值状态,并可用于加速解码(参见 past_key_values
)。
返回
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个 torch.FloatTensor
元组(如果传递了 return_dict=False
或当 config.return_dict=False
时)包括根据配置(XLMRobertaXLConfig)和输入的不同元素。
last_hidden_state
(形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
) — 模型最后一层的隐藏状态序列的输出。
pooler_output
(形状为 (batch_size, hidden_size)
的 torch.FloatTensor
) — 经过用于辅助预训练任务的层进一步处理后的序列的第一个标记(分类标记)的最后一层隐藏状态。例如,对于 BERT 系列模型,这返回经过线性层和 tanh 激活函数处理后的分类标记。线性层的权重是从预训练期间的下一个句子预测(分类)目标中训练的。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递 output_hidden_states=True
或当 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出加上每一层的输出)。
模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递 output_attentions=True
或当 config.output_attentions=True
时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)
的 torch.FloatTensor
元组(每层一个)。
注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递 output_attentions=True
和 config.add_cross_attention=True
或当 config.output_attentions=True
时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)
的 torch.FloatTensor
元组(每层一个)。
解码器的交叉注意力层的注意力权重,在注意力 softmax 之后,用于计算交叉注意力头中的加权平均值。
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回)— 长度为config.n_layers
的元组,每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)
的张量,如果config.is_encoder_decoder=True
还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)
的张量。
包含预先计算的隐藏状态(自注意力块中的键和值,以及在交叉注意力块中如果config.is_encoder_decoder=True
的情况下)可以用于加速顺序解码。
XLMRobertaXLModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.XLMRobertaXLForCausalLM
参数
config
(XLMRobertaXLConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。XLM-RoBERTa-XL 模型,在顶部带有用于 CLM 微调的语言建模
头。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 输入序列标记在词汇表中的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]
之间:
position_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
,optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。什么是位置 ID?
head_mask
(torch.FloatTensor
,形状为(num_heads,)
或(num_layers, num_heads)
,optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]
之间:
masked
,
masked
。
inputs_embeds
(torch.FloatTensor
,形状为(batch_size, 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 而不是普通元组。
encoder_hidden_states
(torch.FloatTensor
,形状为(batch_size, sequence_length, hidden_size)
,optional) — 编码器最后一层的隐藏状态序列。如果模型配置为解码器,则在交叉注意力中使用。
encoder_attention_mask
(torch.FloatTensor
,形状为(batch_size, sequence_length)
,optional) — 避免对编码器输入的填充标记索引执行注意力的掩码。如果模型配置为解码器,则在交叉注意力中使用此掩码。掩码值选在[0, 1]
之间:
masked
的标记,
masked
的标记。
labels
(torch.LongTensor
,形状为(batch_size, sequence_length)
,optional) — 用于计算从左到右的语言建模损失(下一个单词预测)的标签。索引应在[-100, 0, ..., config.vocab_size]
中(参见input_ids
文档字符串)索引设置为-100
的标记将被忽略(masked),仅对具有标签在[0, ..., config.vocab_size]
中的标记计算损失
past_key_values
(tuple(tuple(torch.FloatTensor))
,长度为config.n_layers
,每个元组有 4 个形状为(batch_size, num_heads, sequence_length - 1, embed_size_per_head)
的张量) — 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values
,用户可以选择仅输入最后一个decoder_input_ids
(这些不会将其过去的键值状态提供给此模型)的形状为(batch_size, 1)
的张量,而不是所有形状为(batch_size, sequence_length)
的decoder_input_ids
。
use_cache
(bool
, optional) — 如果设置为True
,则返回past_key_values
键值状态,可用于加速解码(参见past_key_values
)。
返回
transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(XLMRobertaXLConfig)和输入的不同元素。
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回) - 语言建模损失(用于下一个标记预测)。
logits
(形状为(batch_size, sequence_length, config.vocab_size)
的torch.FloatTensor
) - 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) - 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层的输出,则为嵌入的输出+每一层的输出)。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) - 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
在自注意力头中使用的注意力权重之后,用于计算加权平均值。
cross_attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) - 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
在注意力 softmax 之后的交叉注意力权重,用于计算交叉注意力头中的加权平均值。
past_key_values
(tuple(tuple(torch.FloatTensor))
,可选,当传递use_cache=True
或config.use_cache=True
时返回) - 长度为config.n_layers
的torch.FloatTensor
元组,每个元组包含自注意力和交叉注意力层的缓存键、值状态,如果模型在编码器-解码器设置中使用,则相关。仅在config.is_decoder = True
时相关。
包含预先计算的隐藏状态(注意力块中的键和值),可用于加速顺序解码(参见past_key_values
输入)。
XLMRobertaXLForCausalLM 的前向方法,覆盖__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.XLMRobertaXLForMaskedLM
参数
config
(XLMRobertaXLConfig](/docs/transformers/v4.37.2/en/main_classes/model#transformers.PreTrainedModel.from_pretrained)方法以加载模型权重。XLM-RoBERTa-XL 模型在顶部带有语言建模
头。此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。此模型还是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。
forward
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
未屏蔽
的标记,
被屏蔽
的标记为 0。什么是注意力掩码?
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引选择在[0, 1]
之间:
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。什么是位置 ID?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块中的选定头部失效的掩码。掩码值选择在[0, 1]
之间:
未屏蔽
,
被屏蔽
。
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, sequence_length)
的torch.LongTensor
,可选)— 用于计算被屏蔽语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]
内(参见input_ids
文档字符串)。索引设置为-100
的标记将被忽略(被屏蔽),损失仅计算具有标签在[0, ..., config.vocab_size]
内的标记
kwargs
(Dict[str, any]
,可选,默认为*{}*)— 用于隐藏已弃用的旧参数。
返回
transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含根据配置(XLMRobertaXLConfig)和输入的各种元素。
loss
(torch.FloatTensor
of shape (1,)
, optional, 当提供 labels
时返回) — 掩码语言建模(MLM)损失。
logits
(torch.FloatTensor
of shape (batch_size, sequence_length, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
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)
。
在自注意力头中用于计算加权平均值的注意力权重。
XLMRobertaXLForMaskedLM 的前向方法覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.XLMRobertaXLForSequenceClassification
参数
config
(XLMRobertaXLConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只会加载配置。查看 from_pretrained() 方法以加载模型权重。XLM-RoBERTa-XL 模型变换器,顶部带有序列分类/回归头(池化输出之上的线性层),例如用于 GLUE 任务。
该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。该模型也是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解一般用法和行为相关的所有事项。
forward
参数
input_ids
(torch.LongTensor
of shape (batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call
() 以获取详细信息。什么是输入 ID?
attention_mask
(torch.FloatTensor
of shape (batch_size, sequence_length)
, optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]
之间。
masked
掉的标记。什么是注意力掩码?
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 段标记索引,指示输入的第一部分和第二部分。索引在[0, 1]
中选择:
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
内选择。什么是位置 ID?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块中选择的头部失效的掩码。掩码值选在[0, 1]
之间:
masked
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制如何将input_ids
索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量下的attentions
。
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量下的hidden_states
。
return_dict
(bool
,可选)- 是否返回 ModelOutput 而不是普通元组。
labels
(形状为(batch_size,)
的torch.LongTensor
,可选)- 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]
范围内。如果config.num_labels == 1
,则计算回归损失(均方损失),如果config.num_labels > 1
,则计算分类损失(交叉熵)。
返回
transformers.modeling_outputs.SequenceClassifierOutput 或torch.FloatTensor
元组
一个 transformers.modeling_outputs.SequenceClassifierOutput 或torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(XLMRobertaXLConfig)和输入的各种元素。
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)- 分类(如果 config.num_labels==1 则为回归)损失。
logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)- 分类(如果 config.num_labels==1 则为回归)得分(SoftMax 之前)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每层的输出)。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
XLMRobertaXLForSequenceClassification 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
单标签分类示例:
多标签分类示例:
class transformers.XLMRobertaXLForMultipleChoice
参数
config
(XLMRobertaXLConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。XLM-RoBERTa-XL 模型,顶部带有多选分类头(池化输出上的线性层和 softmax),例如用于 RocStories/SWAG 任务。
该模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。该模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(torch.LongTensor
of shape (batch_size, num_choices, sequence_length)
) — 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call
()。什么是输入 ID?
attention_mask
(torch.FloatTensor
of shape (batch_size, num_choices, sequence_length)
, optional) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1]
中选择:
masked
的标记,
masked
的标记。什么是注意力掩码?
token_type_ids
(torch.LongTensor
of shape (batch_size, num_choices, sequence_length)
, optional) — 段标记索引,用于指示输入的第一部分和第二部分。索引在 [0, 1]
中选择:
position_ids
(torch.LongTensor
of shape (batch_size, num_choices, sequence_length)
, optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1]
中选择。什么是位置 ID?
head_mask
(torch.FloatTensor
of shape (num_heads,)
or (num_layers, num_heads)
, optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在 [0, 1]
中选择:
inputs_embeds
(形状为(batch_size, num_choices, 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,)
的torch.LongTensor
,可选)— 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]
范围内,其中num_choices
是输入张量的第二维的大小。(参见上面的input_ids
)
返回
transformers.modeling_outputs.MultipleChoiceModelOutput 或tuple(torch.FloatTensor)
一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
时)包含各种元素,取决于配置(XLMRobertaXLConfig)和输入。
loss
(形状为*(1,)*的torch.FloatTensor
,可选,当提供labels
时返回)— 分类损失。
logits
(形状为(batch_size, num_choices)
的torch.FloatTensor
)— num_choices是输入张量的第二维。(参见上面的input_ids)。
分类得分(SoftMax 之前)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入输出的输出+每层的输出)。
模型在每一层输出处的隐藏状态以及可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
XLMRobertaXLForMultipleChoice 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.XLMRobertaXLForTokenClassification
参数
config
(XLMRobertaXLConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。XLM-RoBERTa-XL 模型在顶部具有一个令牌分类头(隐藏状态输出的线性层),例如用于命名实体识别(NER)任务。
此模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
前向
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列令牌的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。输入 ID 是什么?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充令牌索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 指示输入的第一部分和第二部分的段标记索引。索引选择在[0, 1]
之间:
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列令牌在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]
。位置 ID 是什么?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]
之间:
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 而不是一个普通的元组。
标签
(torch.LongTensor
,形状为 (batch_size, sequence_length)
,可选) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1]
范围内。
返回
transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor
元组(如果传递 return_dict=False
或 config.return_dict=False
时)包含根据配置(XLMRobertaXLConfig)和输入的各种元素。
loss
(torch.FloatTensor
,形状为 (1,)
,可选,当提供 labels
时返回) — 分类损失。
logits
(torch.FloatTensor
,形状为 (batch_size, sequence_length, config.num_labels)
) — 分类分数(SoftMax 之前)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递 output_hidden_states=True
或 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
元组。
模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递 output_attentions=True
或 config.output_attentions=True
时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)
的 torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
XLMRobertaXLForTokenClassification 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的配方需要在此函数内定义,但应该在此之后调用 Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
class transformers.XLMRobertaXLForQuestionAnswering
参数
config
(XLMRobertaXLConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。XLM-RoBERTa-XL 模型,顶部带有一个用于提取式问答任务(如 SQuAD)的跨度分类头(在隐藏状态输出的线性层上计算 span start logits
和 span end logits
)。
该模型继承自 PreTrainedModel。请查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]
范围内:
token_type_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引在[0, 1]
范围内选择:
position_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
,可选)— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]
中选择。什么是位置 ID?
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]
范围内:
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 而不是一个普通元组。
start_positions
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算标记分类损失的标记跨度起始位置(索引)的标签。位置被夹紧到序列的长度(sequence_length
)。序列外的位置不会被考虑在内,用于计算损失。
end_positions
(形状为(batch_size,)
的torch.LongTensor
,可选)- 用于计算标记跨度结束位置(索引)的标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length
)。序列外的位置不会被考虑在内以计算损失。
返回
transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)
transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,取决于配置(XLMRobertaXLConfig)和输入。
loss
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)- 总跨度提取损失是起始和结束位置的交叉熵之和。
start_logits
(形状为(batch_size, sequence_length)
的torch.FloatTensor
)- 跨度起始得分(SoftMax 之前)。
end_logits
(形状为(batch_size, sequence_length)
的torch.FloatTensor
)- 跨度结束得分(SoftMax 之前)。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(如果模型有嵌入层,则为嵌入的输出+每个层的输出)。
模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
XLMRobertaXLForQuestionAnswering 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/xlm-v
XLM-V 是一个多语言语言模型,具有一个由 Common Crawl 的 2.5TB 数据训练的一百万标记词汇(与 XLM-R 相同)。它在 Davis Liang、Hila Gonen、Yuning Mao、Rui Hou、Naman Goyal、Marjan Ghazvininejad、Luke Zettlemoyer 和 Madian Khabsa 的论文XLM-V: Overcoming the Vocabulary Bottleneck in Multilingual Masked Language Models中介绍。
从 XLM-V 论文的摘要中:
大型多语言语言模型通常依赖于跨 100 多种语言共享的单一词汇表。随着这些模型的参数数量和深度增加,词汇表大小基本保持不变。这种词汇瓶颈限制了诸如 XLM-R 之类的多语言模型的表征能力。在本文中,我们介绍了一种通过减少语言之间的标记共享并分配词汇容量来实现对非常大型多语言词汇的扩展的新方法,以实现对每种单独语言的足够覆盖。使用我们的词汇表进行标记化通常比 XLM-R 更具语义意义且更短。利用这个改进的词汇表,我们训练了 XLM-V,一个具有一百万标记词汇的多语言语言模型。XLM-V 在我们测试的每个任务上都优于 XLM-R,包括自然语言推理(XNLI)、问答(MLQA、XQuAD、TyDiQA)和命名实体识别(WikiAnn)等低资源任务(Americas NLI、MasakhaNER)。
该模型由stefan-it贡献,包括对 XLM-V 在下游任务上的详细实验。实验存储库可以在这里找到。
fairseq
库转换即可。
XLMTokenizer
实现用于加载词汇表并执行标记化。
XLM-V(基础大小)模型可在facebook/xlm-v-base
标识符下找到。
XLM-V 架构与 XLM-RoBERTa 相同,请参考 XLM-RoBERTa 文档以获取 API 参考和示例。
原始文本:
huggingface.co/docs/transformers/v4.37.2/en/model_doc/xlnet
XLNet 模型是由 Zhilin Yang、Zihang Dai、Yiming Yang、Jaime Carbonell、Ruslan Salakhutdinov、Quoc V. Le 提出的,其论文名为《XLNet: Generalized Autoregressive Pretraining for Language Understanding》(https://arxiv.org/abs/1906.08237)。XLNet 是 Transformer-XL 模型的扩展,使用自回归方法进行预训练,通过最大化输入序列分解顺序的所有排列的期望似然来学习双向上下文。
论文摘要如下:
具有建模双向上下文的能力,基于去噪自编码的 BERT 比基于自回归语言建模的预训练方法表现更好。然而,BERT 依赖于用掩码损坏输入,忽略了掩码位置之间的依赖关系,并且存在预训练和微调之间的差异。鉴于这些优缺点,我们提出了 XLNet,一种广义的自回归预训练方法,它(1)通过最大化分解顺序的所有排列的期望似然来实现学习双向上下文,(2)通过其自回归公式克服了 BERT 的局限性。此外,XLNet 将 Transformer-XL 的思想整合到预训练中。在可比的实验设置下,XLNet 在 20 个任务中表现优于 BERT,通常差距很大,包括问答、自然语言推理、情感分析和文档排名。
perm_mask
输入在训练和测试时进行控制。
target_mapping
输入选择的。
perm_mask
和target_mapping
输入来控制注意力范围和输出(请参见examples/pytorch/text-generation/run_generation.py中的示例)
class transformers.XLNetConfig
参数
vocab_size
(int
, optional, defaults to 32000) — XLNet 模型的词汇量。定义了在调用 XLNetModel 或 TFXLNetModel 时可以表示的不同标记数量。
d_model
(int
, optional, defaults to 1024) — 编码器层和池化层的维度。
n_layer
(int
, optional, defaults to 24) — Transformer 编码器中的隐藏层数。
n_head
(int
, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。
d_inner
(int
, optional, defaults to 4096) — Transformer 编码器中“中间”(通常称为前馈)层的维度。
ff_activation
(str
or Callable
, optional, defaults to "gelu"
) — 在 Transformer 编码器中的非线性激活函数(函数或字符串)。如果是字符串,支持"gelu"
、"relu"
、"silu"
和"gelu_new"
。
untie_r
(bool
, optional, defaults to True
) — 是否解开相对位置偏差
attn_type
(str
, optional, defaults to "bi"
) — 模型使用的注意力类型。为 XLNet 设置"bi"
,为 Transformer-XL 设置"uni"
。
initializer_range
(float
, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps
(float
, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
dropout
(float
, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
mem_len
(int
or None
, optional) — 要缓存的标记数。已经在先前的前向传递中预先计算的键/值对不会重新计算。有关更多信息,请参阅快速入门。
reuse_len
(int
, optional) — 当前批次中要缓存和将来重复使用的标记数。
bi_data
(bool
, optional, defaults to False
) — 是否使用双向输入管道。通常在预训练期间设置为True
,在微调期间设置为False
。
clamp_len
(int
, optional, defaults to -1) — 将大于 clamp_len 的所有相对距离限制。将此属性设置为-1 表示不限制。
same_length
(bool
, optional, defaults to False
) — 是否对每个标记使用相同的注意力长度。
summary_type
(str
, optional, defaults to “last”) — 在进行序列摘要时使用的参数。用于序列分类和多选模型。
必须是以下选项之一:
"last"
: 取最后一个标记的隐藏状态(类似于 XLNet)。
"first"
: 取第一个标记的隐藏状态(类似于 BERT)。
"mean"
: 取所有标记隐藏状态的平均值。
"cls_index"
: 提供分类标记位置的张量(类似于 GPT/GPT-2)。
"attn"
: 目前未实现,使用多头注意力。
summary_use_proj
(bool
, optional, defaults to True
) — 在进行序列摘要时使用的参数。用于序列分类和多选模型。
是否在向量提取后添加投影。
summary_activation
(str
, optional) — 在进行序列摘要时使用的参数。用于序列分类和多选模型。
将输出传递给 tanh 激活以获得 tanh 激活,其他任何值都将导致无激活。
summary_proj_to_labels
(boo
, optional, defaults to True
) — 用于序列分类和多选模型。
投影输出应具有config.num_labels
或config.hidden_size
类。
summary_last_dropout
(float
, optional, defaults to 0.1) — 用于序列分类和多选模型。
在投影和激活之后要使用的丢失比率。
start_n_top
(int
, optional, defaults to 5) — 在 SQuAD 评估脚本中使用。
end_n_top
(int
, optional, defaults to 5) — 在 SQuAD 评估脚本中使用。
use_mems_eval
(bool
, optional, defaults to True
) — 模型在评估模式下是否应使用循环记忆机制。
use_mems_train
(bool
, optional, defaults to False
) — 模型在训练模式下是否应使用循环记忆机制。
对于预训练,建议将 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-large-cased 架构的配置。
配置对象继承自 PretrainedConfig,可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。
示例:
class transformers.XLNetTokenizer
参数
vocab_file
(str
) — 包含实例化标记器所需词汇的 SentencePiece 文件(通常具有 .spm 扩展名)。
do_lower_case
(bool
, optional, defaults to False
) — 是否在标记化时将输入转换为小写。
remove_space
(bool
, optional, defaults to True
) — 在标记化时是否去除文本中的空格(删除字符串前后的多余空格)。
keep_accents
(bool
, optional, defaults to False
) — 在标记化时是否保留重音。
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
, 可选, 默认为 "<cls>"
) — 在进行序列分类(对整个序列进行分类而不是每个标记的分类)时使用的分类器标记。在构建带有特殊标记的序列时,它是序列的第一个标记。
mask_token
(str
, 可选, 默认为 "<mask>"
) — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
additional_special_tokens
(List[str]
, 可选, 默认为 ['<eop>', '<eod>']
) — 分词器使用的额外特殊标记。
sp_model_kwargs
(dict
, 可选) — 将传递给SentencePieceProcessor.__init__()
方法。SentencePiece 的 Python 包装器可用于设置:
enable_sampling
: 启用子词正则化。
nbest_size
: 单字采样参数。对于 BPE-Dropout 无效。
nbest_size = {0,1}
: 不执行采样。
nbest_size > 1
: 从 nbest_size 结果中进行采样。
nbest_size < 0
: 假设 nbest_size 为无限,并使用前向过滤和后向采样算法从所有假设(格)中进行采样。
alpha
: 用于单字采样的平滑参数,以及用于 BPE-dropout 合并操作的丢弃概率。
sp_model
(SentencePieceProcessor
) — 用于每次转换(字符串、标记和 ID)的SentencePiece处理器。
构建一个 XLNet 分词器。基于SentencePiece。
此分词器继承自 PreTrainedTokenizer,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
参数
token_ids_0
(List[int]
) — 将添加特殊标记的 ID 列表。
token_ids_1
(List[int]
, 可选) — 序列对的第二个 ID 列表(可选)。
返回
List[int]
带有适当特殊标记的输入 ID 列表。
通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。一个 XLNet 序列的格式如下:
X <sep> <cls>
A <sep> B <sep> <cls>
get_special_tokens_mask
参数
token_ids_0
(List[int]
) — ID 列表。
token_ids_1
(List[int]
, 可选) — 序列对的第二个 ID 列表(可选)。
already_has_special_tokens
(bool
, 可选, 默认为 False
) — 标记列表是否已经使用特殊标记格式化为模型。
返回
List[int]
一个整数列表,范围为[0, 1]:1 表示特殊标记,0 表示序列标记。
从没有添加特殊标记的标记列表中检索序列 ID。在使用分词器的prepare_for_model
方法添加特殊标记时调用此方法。
create_token_type_ids_from_sequences
参数
token_ids_0
(List[int]
) — ID 列表。
token_ids_1
(List[int]
, 可选) — 序列对的第二个 ID 列表(可选)。
返回
List[int]
根据给定序列的标记类型 ID 列表。
从传递的两个序列创建一个用于序列对分类任务的掩码。一个 XLNet
序列对掩码的格式如下:
如果token_ids_1
为None
,则此方法仅返回掩码的第一部分(0s)。
save_vocabulary
class transformers.XLNetTokenizerFast
参数
vocab_file
(str
)— SentencePiece 文件(通常具有.spm 扩展名),其中包含实例化标记器所需的词汇。
do_lower_case
(bool
,可选,默认为True
)— 在标记化时是否将输入转换为小写。
remove_space
(bool
,可选,默认为True
)— 在标记化时是否去除文本(删除字符串前后的多余空格)。
keep_accents
(bool
,可选,默认为False
)— 在标记化时是否保留重音。
bos_token
(str
,可选,默认为"<s>"
)— 在预训练期间使用的序列开始标记。可用作序列分类器标记。
在使用特殊标记构建序列时,这不是用于序列开始的标记。使用的标记是cls_token
。
eos_token
(str
,可选,默认为"</s>"
)— 序列结束标记。
在使用特殊标记构建序列时,这不是用于序列结束的标记。使用的标记是sep_token
。
unk_token
(str
,可选,默认为"<unk>"
)— 未知标记。词汇表中不存在的标记无法转换为 ID,而是设置为此标记。
sep_token
(str
,可选,默认为"<sep>"
)— 分隔符标记,在构建来自多个序列的序列时使用,例如用于序列分类的两个序列或用于问题回答的文本和问题。它还用作使用特殊标记构建的序列的最后一个标记。
pad_token
(str
,可选,默认为"<pad>"
)— 用于填充的标记,例如在批处理不同长度的序列时使用。
cls_token
(str
,可选,默认为"<cls>"
)— 在进行序列分类(整个序列的分类而不是每个标记的分类)时使用的分类器标记。在使用特殊标记构建时,它是序列的第一个标记。
mask_token
(str
,可选,默认为"<mask>"
)— 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
additional_special_tokens
(List[str]
,可选,默认为["<eop>", "<eod>"]
)— 标记器使用的其他特殊标记。
sp_model
(SentencePieceProcessor
)— 用于每次转换(字符串、标记和 ID)的SentencePiece处理器。
构建“快速”XLNet 标记器(由 HuggingFace 的tokenizers库支持)。基于Unigram。
此标记器继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。
build_inputs_with_special_tokens
参数
token_ids_0
(List[int]
)— 将添加特殊标记的 ID 列表。
token_ids_1
(List[int]
,可选)— 序列对的可选第二个 ID 列表。
返回
List[int]
具有适当特殊标记的 input IDs 列表。
通过连接和添加特殊标记,为序列分类任务构建来自序列或序列对的模型输入。XLNet 序列的格式如下:
X <sep> <cls>
A <sep> B <sep> <cls>
create_token_type_ids_from_sequences
参数
token_ids_0
(List[int]
)- ID 列表。
token_ids_1
(List[int]
,可选)- 序列对的第二个 ID 列表(可选)。
返回
List[int]
根据给定的序列,列出令牌类型 ID。
从传递的两个序列创建一个用于序列对分类任务的掩码。一个 XLNet
序列对掩码的格式如下:
如果token_ids_1
为None
,则此方法仅返回掩码的第一部分(0)。
class transformers.models.xlnet.modeling_xlnet.XLNetModelOutput
参数
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
输入)。将其过去传递给此模型的令牌 ID 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每一层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetModel 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetLMHeadModelOutput
参数
loss
(形状为*(1,)*的torch.FloatTensor
,可选,当提供labels
时返回)- 语言建模损失(用于下一个令牌预测)。
logits
(形状为(batch_size, num_predict, config.vocab_size)
的torch.FloatTensor
)- 语言建模头的预测分数(SoftMax 之前每个词汇令牌的分数)。
num_predict
对应于target_mapping.shape[1]
。如果target_mapping
为None
,则num_predict
对应于sequence_length
。
mems
(长度为config.n_layers
的List[torch.FloatTensor]
)- 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去传递给此模型的令牌 ID 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每一层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
XLNetLMHeadModel 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForSequenceClassificationOutput
参数
loss
(torch.FloatTensor
,形状为(1,)
,可选, 当提供label
时返回) — 分类(如果config.num_labels==1
则为回归)损失。
logits
(torch.FloatTensor
,形状为(batch_size, config.num_labels)
) — 分类(如果config.num_labels==1
则为回归)得分(SoftMax 之前)。
mems
(List[torch.FloatTensor]
,长度为config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码。将过去给定给该模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
XLNetForSequenceClassification 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput
参数
loss
(torch.FloatTensor
,形状为*(1,)*,可选, 当提供labels
时返回) — 分类损失。
logits
(torch.FloatTensor
,形状为(batch_size, num_choices)
) — num_choices是输入张量的第二维度。(参见上面的input_ids)。
分类得分(SoftMax 之前)。
mems
(List[torch.FloatTensor]
,长度为config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码。将过去给定给该模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
XLNetForMultipleChoice 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput
参数
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 分类损失。
logits
(torch.FloatTensor
,形状为(batch_size, sequence_length, config.num_labels)
) — 分类分数(SoftMax 之前)。
mems
(List[torch.FloatTensor]
,长度为config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去传递给此模型的标记 ID 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每个层的输出以及初始嵌入输出的隐藏状态。
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForTokenClassificationOutput
的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput
参数
loss
(torch.FloatTensor
,形状为(1,)
,可选,当提供labels
时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
start_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length,)
) — 跨度开始分数(SoftMax 之前)。
end_logits
(torch.FloatTensor
,形状为(batch_size, sequence_length,)
) — 跨度结束分数(SoftMax 之前)。
mems
(List[torch.FloatTensor]
,长度为config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去传递给此模型的标记 ID 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
, 可选, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每个层的输出以及初始嵌入输出的隐藏状态。
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每个层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForQuestionAnsweringSimple 的输出类型。
class transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput
参数
loss
(torch.FloatTensor
,形状为(1,)
,可选,如果提供了start_positions
和end_positions
则返回) — 分类损失,作为开始标记、结束标记(如果提供)的分类损失之和。
start_top_log_probs
(形状为(batch_size, config.start_n_top)
的torch.FloatTensor
,可选,如果未提供start_positions
或end_positions
则返回)- 顶部config.start_n_top
开始标记可能性(波束搜索)的对数概率。
start_top_index
(形状为(batch_size, config.start_n_top)
的torch.LongTensor
,可选,如果未提供start_positions
或end_positions
则返回)- 顶部config.start_n_top
开始标记可能性(波束搜索)的索引。
end_top_log_probs
(形状为(batch_size, config.start_n_top * config.end_n_top)
的torch.FloatTensor
,可选,如果未提供start_positions
或end_positions
则返回)- 顶部config.start_n_top * config.end_n_top
结束标记可能性(波束搜索)的对数概率。
end_top_index
(形状为(batch_size, config.start_n_top * config.end_n_top)
的torch.LongTensor
,可选,如果未提供start_positions
或end_positions
则返回)- 顶部config.start_n_top * config.end_n_top
结束标记可能性(波束搜索)的索引。
cls_logits
(形状为(batch_size,)
的torch.FloatTensor
,可选,如果未提供start_positions
或end_positions
则返回)- 答案的is_impossible
标签的对数概率。
mems
(长度为config.n_layers
的List[torch.FloatTensor]
)- 包含预先计算的隐藏状态。可以用于加速顺序解码(查看mems
输入)。将其过去给予该模型的标记 id 不应作为input_ids
传递,因为它们已经被计算过。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForQuestionAnswering 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput
参数
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
输入)。将其过去给予该模型的标记 id 不应作为input_ids
传递,因为它们已经被计算过。
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetModel 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput
参数
loss
(形状为*(1,)*的 tf.Tensor
,可选,当提供labels
时返回) — 语言建模损失(用于下一个标记预测)。
logits
(形状为
(batch_size, num_predict, config.vocab_size)的 tf.Tensor
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
num_predict
对应于target_mapping.shape[1]
。如果target_mapping
为None
,则num_predict
对应于sequence_length
。
mems
(长度为
config.n_layers的 List[tf.Tensor]
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去给定给该模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出,一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetLMHeadModel 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForSequenceClassificationOutput
参数
loss
(tf.Tensor
,形状为(1,)
,可选,当提供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
输入)。将其过去给定给该模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出,一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForSequenceClassification 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForMultipleChoiceOutput
参数
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]) — 包含预先计算的隐藏状态。可用于加速顺序解码。将其过去传递给此模型的标记 id 不应作为
input_ids`传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。
模型每一层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForMultipleChoice 的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForTokenClassificationOutput
参数
loss
(形状为
(1,)的
tf.Tensor, *optional*, 当提供
labels`时返回) — 分类损失。
logits
(形状为
(batch_size, sequence_length, config.num_labels)的
tf.Tensor`) — 分类分数(SoftMax 之前)。
mems
(长度为
config.n_layers的
List[tf.Tensor]) — 包含预先计算的隐藏状态。可用于加速顺序解码。将其过去传递给此模型的标记 id 不应作为
input_ids`传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每层的输出)。
模型每一层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForTokenClassificationOutput
的输出类型。
class transformers.models.xlnet.modeling_tf_xlnet.TFXLNetForQuestionAnsweringSimpleOutput
参数
loss
(形状为
(1,)的
tf.Tensor, *optional*, 当提供
labels`时返回) — 总跨度提取损失是起始和结束位置的交叉熵之和。
start_logits
(形状为
(batch_size, sequence_length,)的
tf.Tensor`) — 跨度起始分数(SoftMax 之前)。
end_logits
(形状为
(batch_size, sequence_length,)的
tf.Tensor`) — 跨度结束分数(SoftMax 之前)。
mems
(长度为
config.n_layers的
List[tf.Tensor]) — 包含预先计算的隐藏状态。可用于加速顺序解码。将其过去传递给此模型的标记 id 不应作为
input_ids`传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
,可选,当传递 output_hidden_states=True
或 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每个层的输出以及初始嵌入输出的隐藏状态。
attentions
(tuple(tf.Tensor)
,可选,当传递 output_attentions=True
或 config.output_attentions=True
时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)
的 tf.Tensor
元组(每个层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForQuestionAnsweringSimple 的输出类型。
PytorchHide Pytorch 内容
class transformers.XLNetModel
参数
config
(XLNetConfig) — 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。裸的 XLNet 模型变压器输出原始隐藏状态,没有特定的头部。
这个模型继承自 PreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。
forward
参数
input_ids
(形状为 (batch_size, sequence_length)
的 torch.LongTensor
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call
() 以获取详细信息。
什么是输入 ID?
attention_mask
(形状为 (batch_size, sequence_length)
的 torch.FloatTensor
,可选) — 避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1]
:
masked
的标记为 1,
masked
的标记为 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 中我关注 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]
中选择:
什么是标记类型 ID?
input_mask
(形状为batch_size, sequence_length
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。负的attention_mask
,即对于真实标记为 0,对于填充为 1,这保留了与原始代码库的兼容性。
选择的掩码值在[0, 1]
中:
masked
的标记,
masked
的标记。
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在[0, 1]
中:
masked
,
masked
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)- 可选地,您可以选择直接传递嵌入表示,而不是传递input_ids
。如果您想要更多控制权来将input_ids
索引转换为相关向量,这将非常有用,而不是使用模型的内部嵌入查找矩阵。
output_attentions
(bool
,可选)- 是否返回所有注意力层的注意力张量。有关更多详细信息,请参见返回张量中的attentions
。
output_hidden_states
(bool
,可选)- 是否返回所有层的隐藏状态。有关更多详细信息,请参见返回张量中的hidden_states
。
return_dict
(bool
,可选)- 是否返回一个 ModelOutput 而不是一个普通元组。
返回
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
输入)。将其过去传递给此模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行前后处理步骤,而后者会默默忽略它们。
示例:
class transformers.XLNetLMHeadModel
参数
config
(XLNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。在顶部带有语言建模头的 XLNet 模型(线性层,权重与输入嵌入绑定)。
此模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法(例如下载或保存,调整输入嵌入,修剪头等)。
此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()以获取详细信息。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:
not masked
的标记为 1。
masked
的标记为 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
(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]
:
什么是标记类型 ID?
input_mask
(torch.FloatTensor
,形状为 batch_size, sequence_length
,可选) — 用于避免在填充标记索引上执行注意力的掩码。是 attention_mask
的负值,即对于真实标记为 0,对于填充标记为 1,这是为了与原始代码基础保持兼容性。
掩码值选择在 [0, 1]
:
您只能使用 input_mask
和 attention_mask
中的一个。
head_mask
(torch.FloatTensor
,形状为 (num_heads,)
或 (num_layers, num_heads)
,可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1]
:
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
时返回) 语言建模损失(用于下一个标记预测)。
logits
(torch.FloatTensor
,形状为 (batch_size, num_predict, config.vocab_size)
) — 语言建模头的预测分数(SoftMax 之前每个词汇标记的分数)。
num_predict
对应于 target_mapping.shape[1]
。如果 target_mapping
是 None
,那么 num_predict
对应于 sequence_length
。
mems
(List[torch.FloatTensor]
,长度为 config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码。将其过去传递给此模型的标记 id 不应作为 input_ids
传递,因为它们已经计算过了。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递 output_hidden_states=True
或 config.output_hidden_states=True
时返回) — 形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每个层的输出以及初始嵌入输出的隐藏状态。
attentions
(tuple(torch.FloatTensor)
,可选,当传递 output_attentions=True
或 config.output_attentions=True
时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length)
的 torch.FloatTensor
元组(每个层一个)。
注意力权重在注意力 softmax 之后,用于计算自注意力头中的加权平均值。
XLNetLMHeadModel 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用 Module
实例而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.XLNetForSequenceClassification
参数
config
(XLNetConfig) — 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。在顶部具有序列分类/回归头的 XLNet 模型(在汇总输出的顶部有一个线性层),例如用于 GLUE 任务。
此模型继承自 PreTrainedModel。检查超类文档以获取库实现的所有模型的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module 子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(torch.LongTensor
,形状为 (batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为 (batch_size, sequence_length)
的 torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1]
中选择:
masked
的标记,
masked
的标记。
什么是注意力掩码?
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]
中选择:
什么是标记类型 ID?
input_mask
(形状为 batch_size, sequence_length
的 torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。attention_mask
的负值,即对于真实标记为 0,对于填充为 1,这是为了与原始代码库保持兼容性。
掩码值在 [0, 1]
中选择:
masked
的标记,
masked
的标记。
您只能使用 input_mask
和 attention_mask
中的一个。
head_mask
(形状为 (num_heads,)
或 (num_layers, num_heads)
的 torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1]
中选择:
masked
,
masked
。
inputs_embeds
(形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
,可选)— 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids
。如果您想要更多控制权,以便将 input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
。
return_dict
(bool
,可选)— 是否返回 ModelOutput 而不是普通元组。
labels
(形状为 (batch_size,)
的 torch.LongTensor
,可选)— 用于计算序列分类/回归损失的标签。索引应在 [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
(形状为(1,)
的torch.FloatTensor
,可选,当提供label
时返回)- 分类(如果 config.num_labels==1 则为回归)损失。
logits
(形状为(batch_size, config.num_labels)
的torch.FloatTensor
)- 分类(如果 config.num_labels==1 则为回归)分数(SoftMax 之前)。
mems
(List[torch.FloatTensor]
,长度为config.n_layers
)- 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去传递给该模型的令牌 id 不应作为input_ids
传递,因为它们已经被计算过。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或当config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层的输出处的隐藏状态加上初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或当config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每一层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForSequenceClassification 前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
单标签分类示例:
多标签分类示例:
class transformers.XLNetForMultipleChoice
参数
config
(XLNetConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。在顶部具有多选分类头的 XLNet 模型(池化输出上的线性层和 softmax),例如用于 RACE/SWAG 任务。
该模型继承自 PreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法(例如下载或保存,调整输入嵌入,修剪头等)。
该模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有内容。
forward
参数
input_ids
(形状为(batch_size, num_choices, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, num_choices, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。在[0, 1]
中选择的掩码值:
masked
的标记为 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, num_choices, sequence_length)
的torch.LongTensor
,可选)- 段标记索引,指示输入的第一部分和第二部分。索引在[0, 1]
中选择:
什么是标记类型 ID?
input_mask
(形状为batch_size, num_choices, sequence_length
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。attention_mask
的负值,即对于真实标记为 0,对于填充为 1,这是为了与原始代码库保持兼容性。
在[0, 1]
中选择的掩码值:
masked
的标记为 1,
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。在[0, 1]
中选择的掩码值:
masked
。
inputs_embeds
(形状为(batch_size, num_choices, 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,)
的torch.LongTensor
,可选)— 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]
范围内,其中num_choices
是输入张量的第二维的大小。(见上面的input_ids
)
返回
transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput 或tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetForMultipleChoiceOutput 或一个torch.FloatTensor
元组(如果传递return_dict=False
或config.return_dict=False
)包含根据配置(XLNetConfig)和输入的不同元素。
loss
(形状为*(1,)*的torch.FloatTensor
,可选,当提供labels
时返回)— 分类损失。
logits
(形状为(batch_size, num_choices)
的torch.FloatTensor
)— num_choices是输入张量的第二维。(参见上面的input_ids)。
SoftMax 之前的分类分数。
mems
(长度为config.n_layers
的List[torch.FloatTensor]
)— 包含预计算的隐藏状态。可以用于加速顺序解码。将过去给定给该模型的令牌 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每个层的输出处的隐藏状态加上初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForMultipleChoice 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的配方需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者则默默地忽略它们。
示例:
class transformers.XLNetForTokenClassification
参数
config
(XLNetConfig)— 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。在顶部带有令牌分类头的 XLNet 模型(隐藏状态输出的顶部线性层),例如用于命名实体识别(NER)任务。
此模型继承自 PreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头部等)。
此模型还是一个 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取与一般用法和行为相关的所有信息。
前进
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:
masked
的标记,
masked
的标记。
什么是注意力掩码?
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]
中选择:
什么是标记类型 ID?
input_mask
(形状为batch_size, sequence_length
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。attention_mask
的负值,即对于真实标记为 0,对于填充标记为 1,这是为了与原始代码库保持兼容性。
掩码值在[0, 1]
中选择:
masked
的标记,
masked
的标记。
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:
masked
,
masked
。
inputs_embeds
(形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
,可选)— 可选地,您可以选择直接传递嵌入表示而不是传递input_ids
。如果您希望更多地控制如何将input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,这将非常有用。
output_attentions
(bool
,可选)— 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的attentions
。
output_hidden_states
(bool
,可选)— 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的hidden_states
。
return_dict
(bool
,可选)— 是否返回一个 ModelOutput 而不是一个普通元组。
labels
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算多项选择分类损失的标签。索引应在[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
(形状为(1,)
的torch.FloatTensor
,可选,当提供labels
时返回)— 分类损失。
logits
(形状为(batch_size, sequence_length, config.num_labels)
的torch.FloatTensor
)— 分类分数(SoftMax 之前)。
mems
(长度为config.n_layers
的List[torch.FloatTensor]
)— 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去给予该模型的标记 id 不应作为input_ids
传递,因为它们已经被计算。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForTokenClassification 的前向方法覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行前后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.XLNetForQuestionAnsweringSimple
参数
config
(XLNetConfig) — 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained() 方法来加载模型权重。XLNet 模型在顶部具有一个用于提取式问答任务(如 SQuAD)的跨度分类头(在隐藏状态输出的顶部有线性层,用于计算 span start logits
和 span end logits
)。
这个模型继承自 PreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
这个模型也是一个 PyTorch torch.nn.Module 子类。将其用作常规的 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(torch.LongTensor
,形状为 (batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call
() 获取详细信息。
什么是输入 ID?
attention_mask
(torch.FloatTensor
,形状为 (batch_size, sequence_length)
,可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1]
中选择:
什么是注意力掩码?
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
,则 i 在第 k 批次中关注 j;
perm_mask[k, i, j] = 1
,则 i 在第 k 批次中不会关注 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]
中选择:
什么是标记类型 ID?
input_mask
(torch.FloatTensor
of shape batch_size, sequence_length
, optional) — 用于避免在填充标记索引上执行注意力的掩码。attention_mask
的负值,即对于真实标记为 0,对于填充为 1,这是为了与原始代码库保持兼容性。
在[0, 1]
中选择的掩码值:
masked
的标记,
masked
的标记。
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(torch.FloatTensor
of shape (num_heads,)
or (num_layers, num_heads)
, optional) — 用于使自注意力模块中选择的头部失效的掩码。在[0, 1]
中选择的掩码值:
masked
,
masked
。
inputs_embeds
(torch.FloatTensor
of shape (batch_size, 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 而不是普通元组。
start_positions
(torch.LongTensor
of shape (batch_size,)
, optional) — 用于计算标记分类损失的标记范围起始位置的位置(索引)标签。位置被夹紧到序列的长度(sequence_length
)。超出序列范围的位置不会被考虑在内计算损失。
end_positions
(torch.LongTensor
of shape (batch_size,)
, optional) — 用于计算标记范围结束位置的位置(索引)标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length
)。超出序列范围的位置不会被考虑在内计算损失。
返回
transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或tuple(torch.FloatTensor)
一个 transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput 或一个torch.FloatTensor
元组(如果传递了return_dict=False
或config.return_dict=False
时)包含各种元素,这取决于配置(XLNetConfig)和输入。
loss
(torch.FloatTensor
of shape (1,)
, optional, 当提供labels
时返回) — 总跨度提取损失是起始位置和结束位置的交叉熵之和。
start_logits
(torch.FloatTensor
of shape (batch_size, sequence_length,)
) — 跨度起始分数(SoftMax 之前)。
end_logits
(torch.FloatTensor
of shape (batch_size, sequence_length,)
) — 跨度结束分数(SoftMax 之前)。
mems
(List[torch.FloatTensor]
of length config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(见mems
输入)。将其过去传递给此模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(torch.FloatTensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, 可选, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的torch.FloatTensor
元组(每层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForQuestionAnsweringSimple 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.XLNetForQuestionAnswering
参数
config
(XLNetConfig) — 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法来加载模型权重。XLNet 模型在顶部具有用于提取式问答任务(如 SQuAD)的跨度分类头(在隐藏状态输出的线性层上计算span start logits
和span end logits
)。
此模型继承自 PreTrainedModel。查看超类文档以了解库为其所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块,并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。
forward
参数
input_ids
(torch.LongTensor
,形状为(batch_size, sequence_length)
) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(torch.FloatTensor
,形状为(batch_size, sequence_length)
,可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]
之间:
未被掩码
的标记,
被掩码
的标记。
什么是注意力掩码?
mems
(List[torch.FloatTensor]
,长度为config.n_layers
) — 包含预先计算的隐藏状态(见下面的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
,则 i 在批次 k 中关注 j;
perm_mask[k, i, j] = 1
,则 i 在批次 k 中不参与 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]
中选择:
什么是标记类型 ID?
input_mask
(形状为batch_size, sequence_length
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。attention_mask
的负值,即对于真实标记为 0,对于填充标记为 1,这保持与原始代码库的兼容性。
掩码值在[0, 1]
中选择:
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:
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 而不是普通元组。
start_positions
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算标记跨度起始位置的标签(索引)的标签。位置被夹紧到序列的长度(sequence_length
)。序列外的位置不会计入损失计算。
end_positions
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算标记分类损失的标记跨度结束位置(索引)的标签。位置被夹紧到序列的长度(sequence_length
)。序列外的位置不会计入损失计算。
is_impossible
(形状为(batch_size,)
的torch.LongTensor
,可选)— 标签,指示问题是否有答案或无答案(SQuAD 2.0)
cls_index
(形状为(batch_size,)
的torch.LongTensor
,可选)— 用于计算答案可信度的分类标记(索引)的标签。
p_mask
(torch.FloatTensor
of shape (batch_size, sequence_length)
, optional) — 不能包含在答案中的标记的可选掩码(例如 [CLS],[PAD],…)。1.0 表示应该屏蔽标记。0.0 表示标记未被屏蔽。
返回
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
of shape (1,)
, optional, returned if both start_positions
and end_positions
are provided) — 分类损失,作为开始标记、结束标记(如果提供的话还有 is_impossible)分类损失的总和。
start_top_log_probs
(torch.FloatTensor
of shape (batch_size, config.start_n_top)
, optional, returned if start_positions
or end_positions
is not provided) — 顶部 config.start_n_top 开始标记可能性的对数概率(波束搜索)。
start_top_index
(torch.LongTensor
of shape (batch_size, config.start_n_top)
, optional, returned if start_positions
or end_positions
is not provided) — 顶部 config.start_n_top 开始标记可能性的索引(波束搜索)。
end_top_log_probs
(torch.FloatTensor
of shape (batch_size, config.start_n_top * config.end_n_top)
, optional, returned if start_positions
or end_positions
is not provided) — 顶部 config.start_n_top * config.end_n_top
结束标记可能性的对数概率(波束搜索)。
end_top_index
(torch.LongTensor
of shape (batch_size, config.start_n_top * config.end_n_top)
, optional, returned if start_positions
or end_positions
is not provided) — 顶部 config.start_n_top * config.end_n_top
结束标记可能性的索引(波束搜索)。
cls_logits
(torch.FloatTensor
of shape (batch_size,)
, optional, returned if start_positions
or end_positions
is not provided) — 答案的 is_impossible
标签的对数概率。
mems
(List[torch.FloatTensor]
of length config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(参见 mems
输入)。将其过去传递给此模型的标记 id 不应作为 input_ids
传递,因为它们已经计算过了。
hidden_states
(tuple(torch.FloatTensor)
, optional, returned when output_hidden_states=True
is passed or when config.output_hidden_states=True
) — torch.FloatTensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)的元组,形状为 (batch_size, sequence_length, hidden_size)
。
模型在每一层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(torch.FloatTensor)
, optional, returned when output_attentions=True
is passed or when config.output_attentions=True
) — torch.FloatTensor
元组(每层一个)的元组,形状为 (batch_size, num_heads, sequence_length, sequence_length)
。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
XLNetForQuestionAnswering 的前向方法,覆盖了 __call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用 Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
TensorFlowHide TensorFlow 内容
class transformers.TFXLNetModel
参数
config
(XLNetConfig)- 具有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained() 方法以加载模型权重。裸的 XLNet 模型变换器输出原始隐藏状态,没有特定的头部。
此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(例如下载或保存,调整输入嵌入,修剪头等)。
此模型也是 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。
TensorFlow 模型和 transformers
中的层接受两种格式作为输入:
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持,当使用像 model.fit()
这样的方法时,对你来说应该“只需工作” - 只需以 model.fit()
支持的任何格式传递你的输入和标签!但是,如果你想在 Keras 方法之外使用第二种格式,比如在使用 Keras Functional
API 创建自己的层或模型时,有三种可能性可以用来收集所有输入张量在第一个位置参数中:
input_ids
的单个张量,没有其他内容:model(input_ids)
model([input_ids, attention_mask])
或 model([input_ids, attention_mask, token_type_ids])
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意,当使用 子类化 创建模型和层时,你不需要担心这些问题,因为你可以像对待任何其他 Python 函数一样传递输入!
call
参数
input_ids
(形状为 (batch_size, sequence_length)
的 torch.LongTensor
)- 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call
() 以获取详细信息。
什么是输入 ID?
attention_mask
(形状为 (batch_size, sequence_length)
的 torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。 选择在 [0, 1]
中的掩码值:
什么是注意力掩码?
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
,则 i 在批次 k 中关注 j;
perm_mask[k, i, j] = 1
,则 i 在批次 k 中不会关注 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]
:
什么是标记类型 ID?
input_mask
(torch.FloatTensor
,形状为 batch_size, sequence_length
,可选) — 用于避免在填充标记索引上执行注意力。负的 attention_mask
,即对于真实标记为 0,对于填充为 1,这是为了与原始代码库保持兼容性。
遮蔽值选择在 [0, 1]
:
您只能使用 input_mask
和 attention_mask
中的一个。
head_mask
(torch.FloatTensor
,形状为 (num_heads,)
或 (num_layers, num_heads)
,可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1]
:
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
(长度为config.n_layers
的List[tf.Tensor]
)- 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。已经计算过的 token id 不应该作为input_ids
传递,因为它们已经被计算过。
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层输出的隐藏状态以及初始嵌入输出。
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会处理运行前后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.TFXLNetLMHeadModel
参数
config
(XLNetConfig)- 模型配置类,包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重,只加载配置。查看 from_pretrained()方法来加载模型权重。在顶部带有语言建模头的 XLNet 模型(线性层,其权重与输入嵌入相关联)。
此模型继承自 TFPreTrainedModel。查看超类文档以了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
此模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。
TensorFlow 模型和层在transformers
中接受两种格式的输入:
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用model.fit()
等方法时,应该“只需传递”您的输入和标签,以任何model.fit()
支持的格式!然而,如果您想在 Keras 方法之外使用第二种格式,比如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可以用来收集第一个位置参数中的所有输入张量:
input_ids
的张量,没有其他内容:model(input_ids)
model([input_ids, attention_mask])
或model([input_ids, attention_mask, token_type_ids])
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待任何其他 Python 函数一样传递输入!
call
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力。掩码值选定在[0, 1]
中:
什么是注意力掩码?
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]
中:
什么是标记类型 ID?
input_mask
(形状为batch_size, sequence_length
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力。attention_mask
的负值,即对于真实标记为 0,对于填充为 1,这是为了与原始代码库保持兼容性。
掩码值选定在[0, 1]
中:
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)- 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]
中:
inputs_embeds
(torch.FloatTensor
,形状为(batch_size, 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.Tensor
,形状为(batch_size, sequence_length)
,optional) — 用于计算交叉熵分类损失的标签。索引应在[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,)*,optional,当提供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]
of length config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去传递给此模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
每个层输出的模型的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每个层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetLMHeadModel 的前向方法,覆盖了__call__
特殊方法。
虽然前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.TFXLNetForSequenceClassification
参数
config
(XLNetConfig)- 模型的所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。XLNet 模型在顶部具有序列分类/回归头(池化输出的顶部线性层),例如用于 GLUE 任务。
此模型继承自 TFPreTrainedModel。检查超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有此支持,当使用model.fit()
等方法时,应该可以“正常工作” - 只需传递您的输入和标签,以任何model.fit()
支持的格式!但是,如果您想在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可用于收集所有输入张量在第一个位置参数中:
input_ids
的单个张量,没有其他内容:model(input_ids)
model([input_ids, attention_mask])
或model([input_ids, attention_mask, token_type_ids])
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待任何其他 Python 函数一样传递输入!
call
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 避免在填充标记索引上执行注意力的掩码。选择在[0, 1]
中的掩码值:
什么是注意力掩码?
mems
(长度为config.n_layers
的List[torch.FloatTensor]
)- 包含预先计算的隐藏状态(参见下面的mems
输出)。可用于加速顺序解码。将其过去传递给此模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
use_mems
必须设置为True
才能使用mems
。
perm_mask
(torch.FloatTensor
of shape (batch_size, sequence_length, sequence_length)
, optional) — 用于指示每个输入标记的注意力模式的掩码,其值在[0, 1]
中选择:
perm_mask[k, i, j] = 0
,则 i 在批次 k 中关注 j;
perm_mask[k, i, j] = 1
,则 i 在批次 k 中不会关注 j。
如果未设置,每个标记都关注所有其他标记(完全双向注意力)。仅在预训练期间(用于定义分解顺序)或用于顺序解码(生成)时使用。
target_mapping
(torch.FloatTensor
of shape (batch_size, num_predict, sequence_length)
, optional) — 用于指示要使用的输出标记的掩码。如果target_mapping[k, i, j] = 1
,则批次 k 中的第 i 个预测位于第 j 个标记上。仅在预训练期间用于部分预测或用于顺序解码(生成)。
token_type_ids
(torch.LongTensor
of shape (batch_size, sequence_length)
, optional) — 段标记索引,用于指示输入的第一部分和第二部分。索引在[0, 1]
中选择:
什么是标记类型 ID?
input_mask
(torch.FloatTensor
of shape batch_size, sequence_length
, optional) — 用于避免在填充标记索引上执行注意力的掩码。attention_mask
的负值,即对于真实标记为 0,对于填充为 1,这是为了与原始代码库保持兼容性。
掩码值在[0, 1]
中选择:
masked
,
masked
。
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(torch.FloatTensor
of shape (num_heads,)
or (num_layers, num_heads)
, optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:
masked
,
masked
。
inputs_embeds
(torch.FloatTensor
of shape (batch_size, 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.Tensor
of shape (batch_size,)
, optional) — 用于计算序列分类/回归损失的标签。索引应在[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
(长度为config.n_layers
的List[tf.Tensor]
)- 包含预先计算的隐藏状态。可以用于加速顺序解码(查看mems
输入)。将其过去给予此模型的标记 id 不应作为input_ids
传递,因为它们已经被计算。
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回)- 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
每层输出的模型的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回)- 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均。
TFXLNetForSequenceClassification 的前向方法,覆盖__call__
特殊方法。
尽管前向传递的方法需要在此函数内定义,但应该在此之后调用Module
实例,而不是这个,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.TFXLNetForMultipleChoice
参数
config
(XLNetConfig)- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。XLNET 模型在顶部具有多选分类头(池化输出顶部的线性层和 softmax),例如用于 RocStories/SWAG 任务。
这个模型继承自 TFPreTrainedModel。查看超类文档以获取库实现的所有模型的通用方法(例如下载或保存,调整输入嵌入大小,修剪头等)。
这个模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用model.fit()
等方法时,应该“只需工作” - 只需以model.fit()
支持的任何格式传递输入和标签!然而,如果要在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可用于收集第一个位置参数中的所有输入张量:
input_ids
的单个张量,没有其他内容:model(input_ids)
model([input_ids, attention_mask])
或model([input_ids, attention_mask, token_type_ids])
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待任何其他 Python 函数一样传递输入!
call
参数
input_ids
(形状为(batch_size, num_choices, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, num_choices, sequence_length)
的torch.FloatTensor
,可选)— 用于避免对填充标记索引执行注意力。掩码值在[0, 1]
中选择:
什么是注意力掩码?
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, num_choices, sequence_length)
的torch.LongTensor
,可选)— 段标记索引,指示输入的第一部分和第二部分。索引在[0, 1]
中选择:
什么是标记类型 ID?
input_mask
(形状为batch_size, num_choices, sequence_length
的torch.FloatTensor
,可选)— 用于避免对填充标记索引执行注意力。attention_mask
的负值,即对于真实标记为 0,对于填充为 1,这是为了与原始代码库保持兼容性。
掩码值在[0, 1]
中选择:
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:
masked
。
inputs_embeds
(形状为(batch_size, num_choices, 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, ..., 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
(形状为*(1,)*的tf.Tensor
,可选,当提供labels
时返回)— 分类损失。
logits
(形状为(batch_size, num_choices)
的tf.Tensor
)— num_choices是输入张量的第二维。(参见上面的input_ids)。
SoftMax 之前的分类分数。
mems
(长度为config.n_layers
的List[tf.Tensor]
)— 包含预先计算的隐藏状态。可以用于加速顺序解码(参见mems
输入)。将其过去给定给此模型的标记 ID 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或者config.output_hidden_states=True
时返回)— 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每个层的输出)。
模型在每个层的输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或者config.output_attentions=True
时返回)— 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForMultipleChoice 的前向方法,覆盖了__call__
特殊方法。
尽管前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.TFXLNetForTokenClassification
参数
config
(XLNetConfig)- 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只加载配置。查看 from_pretrained()方法以加载模型权重。在顶部带有令牌分类头的 XLNet 模型(隐藏状态输出的顶部线性层),例如用于命名实体识别(NER)任务。
此模型继承自 TFPreTrainedModel。查看超类文档以获取库为所有模型实现的通用方法(例如下载或保存、调整输入嵌入、修剪头等)。
此模型还是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
支持第二种格式的原因是,当将输入传递给模型和层时,Keras 方法更喜欢这种格式。由于有了这种支持,当使用model.fit()
等方法时,应该可以正常工作-只需传递您的输入和标签,以任何model.fit()
支持的格式!但是,如果您想在 Keras 方法之外使用第二种格式,例如在使用 KerasFunctional
API 创建自己的层或模型时,您可以使用三种可能性来收集所有输入张量:
input_ids
的单个张量,没有其他内容:model(input_ids)
model([input_ids, attention_mask])
或model([input_ids, attention_mask, token_type_ids])
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像将输入传递给任何其他 Python 函数一样传递输入!
call
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)- 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 来获取索引。查看 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()获取详细信息。
输入 ID 是什么?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)- 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]
之间:
未屏蔽
的标记,
已屏蔽
的标记。
注意力掩码是什么?
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]
中选择:
什么是标记类型 ID?
input_mask
(形状为 batch_size, sequence_length
的 torch.FloatTensor
,可选) — 避免在填充标记索引上执行注意力的掩码。与原始代码库兼容性保留填充标记的 attention_mask
的负值,即对于真实标记为 0,对于填充为 1。
掩码值在 [0, 1]
中选择:
masked
掩盖的标记,
只能使用 input_mask
和 attention_mask
中的一个。
head_mask
(形状为 (num_heads,)
或 (num_layers, num_heads)
的 torch.FloatTensor
,可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值在 [0, 1]
中选择:
masked
。
inputs_embeds
(形状为 (batch_size, sequence_length, hidden_size)
的 torch.FloatTensor
,可选) — 可选地,可以直接传递嵌入表示,而不是传递 input_ids
。如果您想要更多控制如何将 input_ids
索引转换为相关向量,而不是使用模型的内部嵌入查找矩阵,则这很有用。
output_attentions
(bool
,可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
。
output_hidden_states
(bool
,可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
。
return_dict
(bool
,可选) — 是否返回 ModelOutput 而不是普通元组。
labels
(形状为 (batch_size, sequence_length)
的 tf.Tensor
,可选) — 用于计算标记分类损失的标签。索引应在 [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
(形状为 (1,)
的 tf.Tensor
,可选,在提供 labels
时返回) — 分类损失。
logits
(形状为 (batch_size, sequence_length, config.num_labels)
的 tf.Tensor
) — 分类分数(SoftMax 之前)。
mems
(长度为config.n_layers
的List[tf.Tensor]
) - 包含预先计算的隐藏状态。可以使用(参见mems
输入)以加速顺序解码。将其过去传递给该模型的标记 id 不应作为input_ids
传递,因为它们已经计算过。
hidden_states
(tuple(tf.Tensor)
,可选,当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) - 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出 + 一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
,可选,当传递output_attentions=True
或config.output_attentions=True
时返回) - 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
在注意力 softmax 之后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForTokenClassification 的前向方法重写了__call__
特殊方法。
尽管前向传递的步骤需要在此函数内定义,但应该在此之后调用Module
实例,而不是在此处调用,因为前者会负责运行预处理和后处理步骤,而后者会默默地忽略它们。
示例:
class transformers.TFXLNetForQuestionAnsweringSimple
参数
config
(XLNetConfig) - 包含模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,只会加载配置。查看 from_pretrained()方法以加载模型权重。XLNet 模型在顶部带有一个跨度分类头,用于提取式问答任务,如 SQuAD(在隐藏状态输出的顶部添加线性层以计算“跨度起始 logits”和“跨度结束 logits”)。
该模型继承自 TFPreTrainedModel。查看超类文档,了解库为所有模型实现的通用方法(如下载或保存、调整输入嵌入、修剪头等)。
该模型也是一个tf.keras.Model子类。将其用作常规的 TF 2.0 Keras 模型,并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。
transformers
中的 TensorFlow 模型和层接受两种格式的输入:
支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于有了这种支持,当使用model.fit()
等方法时,应该“只需工作” - 只需以model.fit()
支持的任何格式传递输入和标签即可!但是,如果您想在 Keras 方法之外使用第二种格式,比如在使用 KerasFunctional
API 创建自己的层或模型时,有三种可能性可以用来收集第一个位置参数中的所有输入张量:
input_ids
的单个张量,没有其他内容:model(input_ids)
model([input_ids, attention_mask])
或model([input_ids, attention_mask, token_type_ids])
model({"input_ids": input_ids, "token_type_ids": token_type_ids})
请注意,当使用子类化创建模型和层时,您无需担心任何这些,因为您可以像对待任何其他 Python 函数一样传递输入!
call
参数
input_ids
(形状为(batch_size, sequence_length)
的torch.LongTensor
)— 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息,请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call
()。
什么是输入 ID?
attention_mask
(形状为(batch_size, sequence_length)
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]
中选择:
masked
的标记为 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
,则 i 在批次 k 中关注 j;
perm_mask[k, i, j] = 1
,则 i 在批次 k 中不参与 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]
中选择:
什么是标记类型 ID?
input_mask
(形状为batch_size, sequence_length
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。负的attention_mask
,即对于真实标记为 0,对于保留与原始代码库兼容性的填充为 1。
掩码值在[0, 1]
中选择:
masked
的标记为 1。
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:
masked
。
inputs_embeds
(torch.FloatTensor
of shape (batch_size, 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 而不是普通元组。
start_positions
(tf.Tensor
of shape (batch_size,)
, optional) — 用于计算标记范围开始位置的位置(索引)标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length
)。超出序列范围的位置不会被考虑在内以计算损失。
end_positions
(tf.Tensor
of shape (batch_size,)
, optional) — 用于计算标记分类损失的标记范围结束位置的位置(索引)标签。位置被夹紧到序列的长度(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
of shape (1,)
, optional, 当提供labels
时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
start_logits
(tf.Tensor
of shape (batch_size, sequence_length,)
) — 跨度开始分数(SoftMax 之前)。
end_logits
(tf.Tensor
of shape (batch_size, sequence_length,)
) — 跨度结束分数(SoftMax 之前)。
mems
(List[tf.Tensor]
of length config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(见mems
输入)。将其过去传递给此模型的标记 id 不应作为input_ids
传递,因为它们已经被计算过。
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出,一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForQuestionAnsweringSimple 的前向方法,覆盖__call__
特殊方法。
尽管前向传播的配方需要在这个函数内定义,但应该在此之后调用Module
实例,而不是这个函数,因为前者负责运行预处理和后处理步骤,而后者则会默默地忽略它们。
示例:
择:
input_mask
(形状为batch_size, sequence_length
的torch.FloatTensor
,可选)— 用于避免在填充标记索引上执行注意力的掩码。负的attention_mask
,即对于真实标记为 0,对于保留与原始代码库兼容性的填充为 1。
掩码值在[0, 1]
中选择:
masked
的标记为 1。
您只能使用input_mask
和attention_mask
中的一个。
head_mask
(形状为(num_heads,)
或(num_layers, num_heads)
的torch.FloatTensor
,可选)— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]
中选择:
masked
。
inputs_embeds
(torch.FloatTensor
of shape (batch_size, 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 而不是普通元组。
start_positions
(tf.Tensor
of shape (batch_size,)
, optional) — 用于计算标记范围开始位置的位置(索引)标签,以计算标记分类损失。位置被夹紧到序列的长度(sequence_length
)。超出序列范围的位置不会被考虑在内以计算损失。
end_positions
(tf.Tensor
of shape (batch_size,)
, optional) — 用于计算标记分类损失的标记范围结束位置的位置(索引)标签。位置被夹紧到序列的长度(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
of shape (1,)
, optional, 当提供labels
时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
start_logits
(tf.Tensor
of shape (batch_size, sequence_length,)
) — 跨度开始分数(SoftMax 之前)。
end_logits
(tf.Tensor
of shape (batch_size, sequence_length,)
) — 跨度结束分数(SoftMax 之前)。
mems
(List[tf.Tensor]
of length config.n_layers
) — 包含预先计算的隐藏状态。可以用于加速顺序解码(见mems
输入)。将其过去传递给此模型的标记 id 不应作为input_ids
传递,因为它们已经被计算过。
hidden_states
(tuple(tf.Tensor)
, optional, 当传递output_hidden_states=True
或config.output_hidden_states=True
时返回) — 形状为(batch_size, sequence_length, hidden_size)
的tf.Tensor
元组(一个用于嵌入的输出,一个用于每一层的输出)。
模型在每一层输出的隐藏状态加上初始嵌入输出。
attentions
(tuple(tf.Tensor)
, optional, 当传递output_attentions=True
或config.output_attentions=True
时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)
的tf.Tensor
元组(每层一个)。
注意力 softmax 后的注意力权重,用于计算自注意力头中的加权平均值。
TFXLNetForQuestionAnsweringSimple 的前向方法,覆盖__call__
特殊方法。
尽管前向传播的配方需要在这个函数内定义,但应该在此之后调用Module
实例,而不是这个函数,因为前者负责运行预处理和后处理步骤,而后者则会默默地忽略它们。
示例: