Transformers 4.37 中文文档（六十三）（4）-阿里云开发者社区

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

XLNetForTokenClassification

`class transformers.XLNetForTokenClassification`

( config )

参数

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

在顶部带有令牌分类头的 XLNet 模型（隐藏状态输出的顶部线性层），例如用于命名实体识别（NER）任务。

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

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

前进

<来源>

( input_ids: Optional = None attention_mask: Optional = None mems: Optional = None perm_mask: Optional = None target_mapping: Optional = None token_type_ids: Optional = None input_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None labels: Optional = None use_mems: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.models.xlnet.modeling_xlnet.XLNetForTokenClassificationOutput or tuple(torch.FloatTensor)

参数

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

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

什么是注意力掩码？
mems（长度为config.n_layers的List[torch.FloatTensor]）— 包含预先计算的隐藏状态（参见下面的mems输出）。可用于加速顺序解码。将其过去传递给此模型的标记 id 不应作为input_ids传递，因为它们已经计算过。
必须将use_mems设置为True才能使用mems。
perm_mask（形状为(batch_size, sequence_length, sequence_length)的torch.FloatTensor，可选）— 用于指示每个输入标记的注意力模式的掩码，值在[0, 1]中选择：

如果perm_mask[k, i, j] = 0，则第 k 批次中的 i 关注 j；
如果perm_mask[k, i, j] = 1，则第 k 批次中的 i 不会关注 j。

如果未设置，则每个标记都关注所有其他标记（完全双向注意力）。仅在预训练期间（用于定义分解顺序）或用于顺序解码（生成）时使用。
target_mapping（形状为(batch_size, num_predict, sequence_length)的torch.FloatTensor，可选）— 用于指示要使用的输出标记的掩码。如果target_mapping[k, i, j] = 1，则第 k 批次中第 i 个预测位于第 j 个标记上。仅在预训练期间用于部分预测或用于顺序解码（生成）。
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：

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

什么是标记类型 ID？
input_mask（形状为batch_size, sequence_length的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。attention_mask的负值，即对于真实标记为 0，对于填充标记为 1，这是为了与原始代码库保持兼容性。掩码值在[0, 1]中选择：

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

您只能使用input_mask和attention_mask中的一个。
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

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

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。
labels（形状为(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实例，而不是在此处调用，因为前者负责运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, XLNetForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet-base-cased")
>>> model = XLNetForTokenClassification.from_pretrained("xlnet-base-cased")
>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss

XLNetForQuestionAnsweringSimple

`class transformers.XLNetForQuestionAnsweringSimple`

<来源>

( config )

参数

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

XLNet 模型在顶部具有一个用于提取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出的顶部有线性层，用于计算 span start logits 和 span end logits）。

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

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

`forward`

< source >

( input_ids: Optional = None attention_mask: Optional = None mems: Optional = None perm_mask: Optional = None target_mapping: Optional = None token_type_ids: Optional = None input_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None use_mems: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringSimpleOutput or tuple(torch.FloatTensor)

参数

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

1 用于未被屏蔽的标记，
0 用于被屏蔽的标记。

什么是注意力掩码？
mems (List[torch.FloatTensor]，长度为 config.n_layers) — 包含预先计算的隐藏状态（参见下面的 mems 输出）。可用于加速顺序解码。将其过去传递给该模型的标记 id 不应作为 input_ids 传递，因为它们已经计算过。
use_mems 必须设置为 True 才能使用 mems。
perm_mask (torch.FloatTensor，形状为 (batch_size, sequence_length, sequence_length)，可选) — 用于指示每个输入标记的注意力模式的掩码，值在 [0, 1] 中选择：

如果 perm_mask[k, i, j] = 0，则 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] 中选择：

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

什么是标记类型 ID？
input_mask (torch.FloatTensor of shape batch_size, sequence_length, optional) — 用于避免在填充标记索引上执行注意力的掩码。attention_mask的负值，即对于真实标记为 0，对于填充为 1，这是为了与原始代码库保持兼容性。在[0, 1]中选择的掩码值：

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

您只能使用input_mask和attention_mask中的一个。
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。在[0, 1]中选择的掩码值：

1 表示头部未被masked，
0 表示头部被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实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, XLNetForQuestionAnsweringSimple
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet-base-cased")
>>> model = XLNetForQuestionAnsweringSimple.from_pretrained("xlnet-base-cased")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss

XLNetForQuestionAnswering

`class transformers.XLNetForQuestionAnswering`

<来源>

( config )

参数

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

XLNet 模型在顶部具有用于提取式问答任务（如 SQuAD）的跨度分类头（在隐藏状态输出的线性层上计算span start logits和span end logits）。

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

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

`forward`

<来源>

( input_ids: Optional = None attention_mask: Optional = None mems: Optional = None perm_mask: Optional = None target_mapping: Optional = None token_type_ids: Optional = None input_mask: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None is_impossible: Optional = None cls_index: Optional = None p_mask: Optional = None use_mems: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.models.xlnet.modeling_xlnet.XLNetForQuestionAnsweringOutput or tuple(torch.FloatTensor)

参数

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

1 表示未被掩码的标记，
0 表示被掩码的标记。

什么是注意力掩码？
mems (List[torch.FloatTensor]，长度为config.n_layers) — 包含预先计算的隐藏状态（见下面的mems输出）。可用于加速顺序解码。将其过去传递给此模型的标记 ID 不应作为input_ids传递，因为它们已经计算过。
use_mems必须设置为True才能使用mems。
perm_mask（形状为(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]中选择：

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

什么是标记类型 ID？
input_mask（形状为batch_size, sequence_length的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。attention_mask的负值，即对于真实标记为 0，对于填充标记为 1，这保持与原始代码库的兼容性。掩码值在[0, 1]中选择：

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

您只能使用input_mask和attention_mask中的一个。
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

1 表示头部未被屏蔽，
0 表示头部被屏蔽。

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。
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 实例，而不是在此处调用，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, XLNetForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet-base-cased")
>>> model = XLNetForQuestionAnswering.from_pretrained("xlnet-base-cased")
>>> input_ids = torch.tensor(tokenizer.encode("Hello, my dog is cute", add_special_tokens=True)).unsqueeze(
...     0
... )  # Batch size 1
>>> start_positions = torch.tensor([1])
>>> end_positions = torch.tensor([3])
>>> outputs = model(input_ids, start_positions=start_positions, end_positions=end_positions)
>>> loss = outputs.loss

TensorFlowHide TensorFlow 内容

TFXLNetModel

`class transformers.TFXLNetModel`

< source >

( config *inputs **kwargs )

参数

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

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

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

此模型也是 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有信息。

TensorFlow 模型和 transformers 中的层接受两种格式作为输入：

将所有输入作为关键字参数（类似于 PyTorch 模型），或者
将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 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`

< source >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: bool = False ) → export const metadata = 'undefined';transformers.models.xlnet.modeling_tf_xlnet.TFXLNetModelOutput or tuple(tf.Tensor)

参数

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

1 表示那些“未被掩码”的标记，
0 表示那些“被掩码”的标记。

什么是注意力掩码？
mems (List[torch.FloatTensor]，长度为 config.n_layers) — 包含预先计算的隐藏状态（参见下面的 mems 输出）。可用于加速顺序解码。将其过去传递给此模型的标记 ID 不应作为 input_ids 传递，因为它们已经计算过。
use_mems 必须设置为 True 才能使用 mems。
perm_mask (torch.FloatTensor，形状为 (batch_size, sequence_length, sequence_length)，可选) — 用于指示每个输入标记的注意力模式的掩码，值选择在 [0, 1]：

如果 perm_mask[k, i, j] = 0，则 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]：

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

什么是标记类型 ID？
input_mask (torch.FloatTensor，形状为 batch_size, sequence_length，可选) — 用于避免在填充标记索引上执行注意力。负的 attention_mask，即对于真实标记为 0，对于填充为 1，这是为了与原始代码库保持兼容性。遮蔽值选择在 [0, 1]：

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

您只能使用 input_mask 和 attention_mask 中的一个。
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1]：

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

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

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实例，而不是在此处调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFXLNetModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet-base-cased")
>>> model = TFXLNetModel.from_pretrained("xlnet-base-cased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> last_hidden_states = outputs.last_hidden_state

TFXLNetLMHeadModel

`class transformers.TFXLNetLMHeadModel`

< source >

( config *inputs **kwargs )

参数

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

在顶部带有语言建模头的 XLNet 模型（线性层，其权重与输入嵌入相关联）。

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

此模型也是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取有关一般用法和行为的所有相关信息。

TensorFlow 模型和层在transformers中接受两种格式的输入：

将所有输入作为关键字参数（类似于 PyTorch 模型），或
将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用model.fit()等方法时，应该“只需传递”您的输入和标签，以任何model.fit()支持的格式！然而，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctionalAPI 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

只有一个包含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: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None mems: np.ndarray | tf.Tensor | None = None perm_mask: np.ndarray | tf.Tensor | None = None target_mapping: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None input_mask: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_mems: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: bool = False ) → export const metadata = 'undefined';transformers.models.xlnet.modeling_tf_xlnet.TFXLNetLMHeadModelOutput or tuple(tf.Tensor)

参数

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

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

什么是注意力掩码？
mems（长度为config.n_layers的List[torch.FloatTensor]）- 包含预先计算的隐藏状态（请参见下面的mems输出）。可用于加速顺序解码。将其过去提供给此模型的标记 id 不应作为input_ids传递，因为它们已经被计算过。
use_mems必须设置为True才能使用mems。
perm_mask（形状为(batch_size, sequence_length, sequence_length)的torch.FloatTensor，可选）- 用于指示每个输入标记的注意力模式的掩码，值选定在[0, 1]中：

如果perm_mask[k, i, j] = 0，则在批次 k 中 i 关注 j;
如果perm_mask[k, i, j] = 1，则在批次 k 中 i 不会关注 j。

如果未设置，则每个标记都会关注其他所有标记（完全双向注意力）。仅在预训练（用于定义分解顺序）或顺序解码（生成）期间使用。
target_mapping（形状为(batch_size, num_predict, sequence_length)的torch.FloatTensor，可选）- 用于指示要使用的输出标记。如果target_mapping[k, i, j] = 1，则批次 k 中的第 i 个预测位于第 j 个标记上。仅在预训练期间用于部分预测或用于顺序解码（生成）。
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引选定在[0, 1]中：

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

什么是标记类型 ID？
input_mask（形状为batch_size, sequence_length的torch.FloatTensor，可选）- 用于避免在填充标记索引上执行注意力。attention_mask的负值，即对于真实标记为 0，对于填充为 1，这是为了与原始代码库保持兼容性。掩码值选定在[0, 1]中：

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

您只能使用input_mask和attention_mask中的一个。
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]中：

1 表示头部未被屏蔽，
0 表示头部被屏蔽。

inputs_embeds (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实例，而不是在此调用，因为前者负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> import tensorflow as tf
>>> import numpy as np
>>> from transformers import AutoTokenizer, TFXLNetLMHeadModel
>>> tokenizer = AutoTokenizer.from_pretrained("xlnet-large-cased")
>>> model = TFXLNetLMHeadModel.from_pretrained("xlnet-large-cased")
>>> # We show how to setup inputs to predict a next token using a bi-directional context.
>>> input_ids = tf.constant(tokenizer.encode("Hello, my dog is very <mask>", add_special_tokens=True))[
...     None, :
... ]  # We will predict the masked token
>>> perm_mask = np.zeros((1, input_ids.shape[1], input_ids.shape[1]))
>>> perm_mask[:, :, -1] = 1.0  # Previous tokens don't see last token
>>> target_mapping = np.zeros(
...     (1, 1, input_ids.shape[1])
... )  # Shape [1, 1, seq_length] => let's predict one token
>>> target_mapping[
...     0, 0, -1
... ] = 1.0  # Our first (and only) prediction will be the last token of the sequence (the masked token)
>>> outputs = model(
...     input_ids,
...     perm_mask=tf.constant(perm_mask, dtype=tf.float32),
...     target_mapping=tf.constant(target_mapping, dtype=tf.float32),
... )
>>> next_token_logits = outputs[
...     0
... ]  # Output has shape [target_mapping.size(0), target_mapping.size(1), config.vocab_size]

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

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

XLNetForTokenClassification

`class transformers.XLNetForTokenClassification`

XLNetForQuestionAnsweringSimple

`class transformers.XLNetForQuestionAnsweringSimple`

`forward`

XLNetForQuestionAnswering

`class transformers.XLNetForQuestionAnswering`

`forward`

TFXLNetModel

`class transformers.TFXLNetModel`

`call`

TFXLNetLMHeadModel

`class transformers.TFXLNetLMHeadModel`

`call`

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

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

XLNetForTokenClassification

class transformers.XLNetForTokenClassification

XLNetForQuestionAnsweringSimple

class transformers.XLNetForQuestionAnsweringSimple

forward

XLNetForQuestionAnswering

class transformers.XLNetForQuestionAnswering

forward

TFXLNetModel

class transformers.TFXLNetModel

call

TFXLNetLMHeadModel

class transformers.TFXLNetLMHeadModel

call

热门文章

最新文章

相关电子书

`class transformers.XLNetForTokenClassification`

`class transformers.XLNetForQuestionAnsweringSimple`

`forward`

`class transformers.XLNetForQuestionAnswering`

`forward`

`class transformers.TFXLNetModel`

`call`

`class transformers.TFXLNetLMHeadModel`

`call`