Transformers 4.37 中文文档（二十二）（3）-阿里云开发者社区

Transformers 4.37 中文文档（二十二）（2）https://developer.aliyun.com/article/1563603

BertForQuestionAnswering

`class transformers.BertForQuestionAnswering`

( config )

参数

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

Bert 模型在顶部具有一个用于提取式问答任务（如 SQuAD）的跨度分类头部（在隐藏状态输出的顶部有线性层，用于计算“跨度起始对数”和“跨度结束对数”）。

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

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

`forward`

<来源>

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None head_mask: Optional = None inputs_embeds: Optional = None start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.QuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

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

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

什么是注意力掩码？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，用于指示输入的第一部分和第二部分。索引选择在 [0, 1]：

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

什么是标记类型 ID？
position_ids (torch.LongTensor of shape (batch_size, 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]：

1 表示头部未被“掩码”。
0 表示头部被“掩码”。

inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 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）包括根据配置（BertConfig）和输入的不同元素。

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

BertForQuestionAnswering 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的配方需要在此函数内定义，但应该在此之后调用Module实例，而不是这个，因为前者负责运行预处理和后处理步骤，而后者则默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, BertForQuestionAnswering
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("deepset/bert-base-cased-squad2")
>>> model = BertForQuestionAnswering.from_pretrained("deepset/bert-base-cased-squad2")
>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)
>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
'a nice puppet'
>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
7.41

TensorFlow 隐藏的 TensorFlow 内容

TFBertModel

`class transformers.TFBertModel`

<来源>

( config: BertConfig *inputs **kwargs )

参数

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

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

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

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

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

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

支持第二种格式的原因是，当将输入传递给模型和层时，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: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions or tuple(tf.Tensor)

参数

input_ids（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为（batch_size，sequence_length）） - 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask（形状为（batch_size，sequence_length）的np.ndarray或tf.Tensor，可选） - 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

对于未被masked的标记为 1，
对于被masked的标记为 0。

什么是注意力掩码？
token_type_ids（形状为（batch_size，sequence_length）的np.ndarray或tf.Tensor，可选） - 指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]中选择：

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

什么是标记类型 ID？
position_ids（np.ndarray或tf.Tensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask（np.ndarray或tf.Tensor，形状为(num_heads,)或(num_layers, num_heads)，可选）— 用于使自注意力模块中选择的头部失效的掩码。掩码值选择在[0, 1]中：

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

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式中该值将始终设置为 True。
training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。
encoder_attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于避免在编码器输入的填充标记索引上执行注意力。如果模型配置为解码器，则在交叉注意力中使用。掩码值选择在[0, 1]中：

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

past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）— 包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用了past_key_values，用户可以选择仅输入最后的decoder_input_ids（那些没有将其过去的键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。
use_cache（bool，可选，默认为True）— 如果设置为True，则返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。在训练期间设置为False，在生成期间设置为True。

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（BertConfig）和输入的各种元素。

last_hidden_state (形状为(batch_size, sequence_length, hidden_size)的tf.Tensor`) — 模型最后一层的隐藏状态序列。
pooler_output (形状为(batch_size, hidden_size)的tf.Tensor`) — 序列第一个标记（分类标记）的最后一层隐藏状态，经过线性层和 Tanh 激活函数进一步处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
这个输出通常不是输入语义内容的好摘要，通常更好的方法是对整个输入序列的隐藏状态进行平均或池化。
past_key_values (List[tf.Tensor], 可选的, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。
包含预先计算的隐藏状态（注意力块中的键和值），可以用于加速顺序解码（查看past_key_values输入）。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor), 可选的, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。
解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

TFBertModel 的前向方法，覆盖了__call__特殊方法。

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

示例：

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

TFBertForPreTraining

`class transformers.TFBertForPreTraining`

<来源>

( config: BertConfig *inputs **kwargs )

参数

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

在预训练期间在顶部使用两个头的 Bert 模型：一个掩码语言建模头和一个下一个句子预测（分类）头。

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

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

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

将所有输入作为关键字参数（类似于 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`

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None next_sentence_label: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.models.bert.modeling_tf_bert.TFBertForPreTrainingOutput or tuple(tf.Tensor)

参数

input_ids（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)）— 输入序列标记在词汇表中的索引。
可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是 input IDs？
attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：

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

什么是 attention masks？
token_type_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]之间：

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

什么是 token type IDs？
position_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是 position IDs？
head_mask (np.ndarray or tf.Tensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部无效的掩码。选定的掩码值在 [0, 1] 范围内：

1 表示头部未被掩码，
0 表示头部被掩码。

inputs_embeds (np.ndarray or tf.Tensor 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 而不是一个普通元组。这个参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool, optional, defaults to `False“) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]范围内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]范围内的标记
next_sentence_label (tf.Tensor of shape (batch_size,), optional) — 用于计算下一个序列预测（分类）损失的标签。输入应该是一个序列对（参见input_ids文档字符串）。索引应在 [0, 1] 范围内：

0 表示序列 B 是序列 A 的延续，
1 表示序列 B 是一个随机序列。

kwargs (Dict[str, any], optional, defaults to {}) — 用于隐藏已被弃用的旧参数的字典。

transformers.models.bert.modeling_tf_bert.TFBertForPreTrainingOutput 或 tuple(tf.Tensor)

一个 transformers.models.bert.modeling_tf_bert.TFBertForPreTrainingOutput 或一个 tf.Tensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置（BertConfig）和输入的各种元素。

prediction_logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头部的预测分数（SoftMax 之前每个词汇标记的分数）。
seq_relationship_logits (tf.Tensor of shape (batch_size, 2)) — 下一个序列预测（分类）头部的预测分数（SoftMax 之前的 True/False 继续分数）。
hidden_states (tuple(tf.Tensor), optional, returned when output_hidden_states=True is passed or when 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 之后的注意力权重，用于计算自注意力头中的加权平均值。

TFBertForPreTraining 的前向方法，覆盖了 __call__ 特殊方法。

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFBertForPreTraining
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFBertForPreTraining.from_pretrained("bert-base-uncased")
>>> input_ids = tokenizer("Hello, my dog is cute", add_special_tokens=True, return_tensors="tf")
>>> # Batch size 1
>>> outputs = model(input_ids)
>>> prediction_logits, seq_relationship_logits = outputs[:2]

TFBertModelLMHeadModel

`class transformers.TFBertLMHeadModel`

<来源>

( config: BertConfig *inputs **kwargs )

`call`

<来源>

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None use_cache: 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: Optional[bool] = False **kwargs ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions or tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions 或 tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions 或一个 tf.Tensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含根据配置（BertConfig）和输入的不同元素。

损失 (tf.Tensor 的形状为 (n,)，可选，当提供 labels 时返回，其中 n 是非掩码标签的数量) — 语言建模损失（用于下一个标记预测）。
logits (tf.Tensor 的形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(tf.Tensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 tf.Tensor 元组（每个层一个）。
解码器的交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。
past_key_values (List[tf.Tensor]，可选，当传递 use_cache=True 或 config.use_cache=True 时返回） — 长度为 config.n_layers 的 tf.Tensor 列表，每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head)。
包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码。

encoder_hidden_states（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）：编码器最后一层的隐藏状态序列。如果模型配置为解码器，则在交叉注意力中使用。encoder_attention_mask（形状为(batch_size, sequence_length)的tf.Tensor，可选）：避免对编码器输入的填充标记索引执行注意力。如果模型配置为解码器，则在交叉注意力中使用。选择的掩码值在[0, 1]中：

对于未屏蔽的标记，
对于屏蔽的标记为 0。

past_key_values（长度为config.n_layers的Tuple[Tuple[tf.Tensor]]）包含注意力块的预计算键和值隐藏状态。可用于加速解码。如果使用past_key_values，用户可以选择仅输入最后一个decoder_input_ids（那些没有将其过去键值状态提供给此模型的）的形状为(batch_size, 1)，而不是形状为(batch_size, sequence_length)的所有decoder_input_ids。use_cache（bool，可选，默认为True）：如果设置为True，将返回past_key_values键值状态，并可用于加速解码（请参阅past_key_values）。在训练期间设置为False，在生成标签期间设置为True（tf.Tensor或np.ndarray的形状为(batch_size, sequence_length)，可选）：用于计算交叉熵分类损失的标签。索引应在[0, ..., config.vocab_size - 1]。

示例：

>>> from transformers import AutoTokenizer, TFBertLMHeadModel
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFBertLMHeadModel.from_pretrained("bert-base-uncased")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits

TFBertForMaskedLM

`class transformers.TFBertForMaskedLM`

<来源>

( config: BertConfig *inputs **kwargs )

参数

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

在顶部具有语言建模头的 Bert 模型。

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

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

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

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

支持第二种格式的原因是，当将输入传递给模型和层时，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: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = 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: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

input_ids（np.ndarray，tf.Tensor，List[tf.Tensor] ``Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)`）—输入序列标记在词汇表中的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）—避免在填充令牌索引上执行注意力的掩码。选择的掩码值为[0, 1]：

1 表示未被掩码的令牌，
0 表示被掩码的令牌。

什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）—段令牌索引，指示输入的第一部分和第二部分。选择的索引为[0, 1]：

0 对应于句子 A令牌，
1 对应于句子 B令牌。

什么是令牌类型 ID？
position_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）—每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）—用于使自注意力模块的选定头部无效的掩码。选择的掩码值为[0, 1]：

1 表示头部未被掩码，
0 表示头部被掩码。

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选）—可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions（bool，可选）—是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states（bool，可选）—是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict（bool，可选）—是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
training（bool，可选，默认为`False“）—是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
labels（形状为(batch_size, sequence_length)的tf.Tensor或np.ndarray，可选）— 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（屏蔽），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

transformers.modeling_tf_outputs.TFMaskedLMOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedLMOutput 或者一个tf.Tensor元组（如果传递了return_dict=False或者当config.return_dict=False时）包含各种元素，取决于配置（BertConfig）和输入。

loss（形状为(n,)的tf.Tensor，可选，当提供labels时返回，其中 n 是非屏蔽标签的数量）— 掩码语言建模（MLM）损失。
logits（形状为(batch_size, sequence_length, config.vocab_size)的tf.Tensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
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 后的注意力权重，用于计算自注意力头中的加权平均值。

TFBertForMaskedLM 的前向方法，覆盖__call__特殊方法。

尽管前向传递的方法需要在此函数内定义，但应该在之后调用Module实例，而不是这个，因为前者会负责运行预处理和后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFBertForMaskedLM
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFBertForMaskedLM.from_pretrained("bert-base-uncased")
>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> # retrieve index of [MASK]
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)
>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)
>>> tokenizer.decode(predicted_token_id)
'paris'

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(float(outputs.loss), 2)
0.88

TFBertForNextSentencePrediction

transformers.TFBertForNextSentencePrediction类

<来源>

( config: BertConfig *inputs **kwargs )

参数

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

在顶部具有下一个句子预测（分类）头的 Bert 模型。

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

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

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

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

支持第二种格式的原因是 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: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None next_sentence_label: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFNextSentencePredictorOutput or tuple(tf.Tensor)

参数

input_ids（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, sequence_length)）— 词汇表中输入序列令牌的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 用于避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：

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

什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

0 对应于句子 A令牌，
1 对应于句子 B令牌。

令牌类型 ID 是什么？
position_ids（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 每个输入序列令牌的位置索引在位置嵌入中的索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选）— 用于使自注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：

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

inputs_embeds（np.ndarray或形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool，可选，默认为`False“) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。

transformers.modeling_tf_outputs.TFNextSentencePredictorOutput 或tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFNextSentencePredictorOutput 或一个tf.Tensor元组（如果传递return_dict=False或config.return_dict=False，则根据配置(BertConfig)和输入包含各种元素。

loss (tf.Tensor，形状为(n,)，可选，当提供next_sentence_label时返回) — 下一个句子预测损失。
logits (tf.Tensor，形状为(batch_size, 2)) — 下一个序列预测（分类）头的预测分数（SoftMax 之前的 True/False 连续性分数）。
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 后。

TFBertForNextSentencePrediction 的前向方法，覆盖__call__特殊方法。

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

示例：

>>> import tensorflow as tf
>>> from transformers import AutoTokenizer, TFBertForNextSentencePrediction
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFBertForNextSentencePrediction.from_pretrained("bert-base-uncased")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> next_sentence = "The sky is blue due to the shorter wavelength of blue light."
>>> encoding = tokenizer(prompt, next_sentence, return_tensors="tf")
>>> logits = model(encoding["input_ids"], token_type_ids=encoding["token_type_ids"])[0]
>>> assert logits[0][0] < logits[0][1]  # the next sentence was random

TFBertForSequenceClassification

class transformers.TFBertForSequenceClassification

< source >

( config: BertConfig *inputs **kwargs )

参数

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

Bert 模型变压器，顶部带有序列分类/回归头（在汇总输出的顶部有一个线性层），例如用于 GLUE 任务。

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

此模型还是tf.keras.Model的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档，了解与一般用法和行为相关的所有事项。

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

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

支持第二种格式的原因是，当将输入传递给模型和层时，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: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = 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: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

input_ids (np.ndarray, tf.Tensor, List[tf.Tensor] ``Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为 (batch_size, sequence_length)`) — 输入序列标记在词汇表中的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。
什么是输入 ID？
attention_mask (np.ndarray 或形状为 (batch_size, sequence_length) 的 tf.Tensor，可选) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

1 用于未掩码的标记，
0 用于掩码的标记。

什么是注意力掩码？
token_type_ids (np.ndarray 或形状为 (batch_size, sequence_length) 的 tf.Tensor，可选) — 指示输入的第一部分和第二部分的段标记索引。索引在[0, 1]中选择：

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

什么是标记类型 ID？
position_ids (np.ndarray 或形状为 (batch_size, sequence_length) 的 tf.Tensor，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选） — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]范围内：

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

inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选） — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为关联向量，而不是模型的内部嵌入查找矩阵，则这很有用。
output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式中将使用配置中的值。
return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。此参数可以在急切模式中使用，在图模式中该值将始终设置为 True。
training（bool，可选，默认为False） — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
labels（形状为(batch_size,)的tf.Tensor或np.ndarray，可选） — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或tuple(tf.Tensor)

transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或一个tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（BertConfig）和输入的不同元素。

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

TFBertForSequenceClassification 的前向方法，覆盖了__call__特殊方法。

尽管前向传递的步骤需要在此函数内定义，但应该在此之后调用Module实例，而不是在此之后调用，因为前者会处理运行前后处理步骤，而后者会默默地忽略它们。

示例：

>>> from transformers import AutoTokenizer, TFBertForSequenceClassification
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("ydshieh/bert-base-uncased-yelp-polarity")
>>> model = TFBertForSequenceClassification.from_pretrained("ydshieh/bert-base-uncased-yelp-polarity")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> logits = model(**inputs).logits
>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
>>> model.config.id2label[predicted_class_id]
'LABEL_1'

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFBertForSequenceClassification.from_pretrained("ydshieh/bert-base-uncased-yelp-polarity", num_labels=num_labels)
>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss
>>> round(float(loss), 2)
0.01

TFBertForMultipleChoice

`class transformers.TFBertForMultipleChoice`

<来源>

( config: BertConfig *inputs **kwargs )

参数

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

在顶部具有多选分类头的 Bert 模型（在汇总输出的顶部有一个线性层和一个 softmax），例如用于 RocStories/SWAG 任务。

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

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

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

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

支持第二种格式的原因是，当将输入传递给模型和层时，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: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = 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: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput or tuple(tf.Tensor)

参数

input_ids（np.ndarray，tf.Tensor，List[tf.Tensor]，Dict[str, tf.Tensor]或Dict[str, np.ndarray]，每个示例的形状必须为(batch_size, num_choices, sequence_length)）— 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()获取详细信息。
什么是输入 ID？
attention_mask（形状为(batch_size, num_choices, sequence_length)的np.ndarray或tf.Tensor，可选） — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

对于未屏蔽的标记，
0 对应于已屏蔽的标记。

什么是注意力掩码？
token_type_ids（形状为(batch_size, num_choices, sequence_length)的np.ndarray或tf.Tensor，可选） — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：

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

什么是标记类型 ID？
position_ids（形状为(batch_size, num_choices, sequence_length)的np.ndarray或tf.Tensor，可选） — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。
什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的np.ndarray或tf.Tensor，可选） — 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：

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

inputs_embeds（形状为(batch_size, num_choices, sequence_length, hidden_size)的np.ndarray或tf.Tensor，可选） — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict（bool，可选） — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可在急切模式下使用，在图模式下该值将始终设置为 True。
training（bool，可选，默认为`False“） — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
labels（形状为(batch_size,)的tf.Tensor或np.ndarray，可选） — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices]中，其中num_choices是输入张量的第二维度的大小。（参见上面的input_ids）

transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或tuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或一个tf.Tensor元组（如果传递了return_dict=False或当config.return_dict=False时）包括根据配置（BertConfig）和输入的各种元素。

loss（形状为*(batch_size, )*的tf.Tensor，可选，当提供labels时返回） — 分类损失。
logits（形状为(batch_size, num_choices)的tf.Tensor） — num_choices 是输入张量的第二维度。（参见上面的input_ids）。
分类分数（SoftMax 之前）。
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 后的注意力权重，用于计算加权平均值。

TFBertForMultipleChoice 的前向方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, TFBertForMultipleChoice
>>> import tensorflow as tf
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFBertForMultipleChoice.from_pretrained("bert-base-uncased")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs)  # batch size is 1
>>> # the linear classifier still needs to be trained
>>> logits = outputs.logits

Transformers 4.37 中文文档（二十二）（4）https://developer.aliyun.com/article/1563605

Transformers 4.37 中文文档（二十二）（3）

BertForQuestionAnswering

`class transformers.BertForQuestionAnswering`

`forward`

TFBertModel

`class transformers.TFBertModel`

`call`

TFBertForPreTraining

`class transformers.TFBertForPreTraining`

`call`

TFBertModelLMHeadModel

`class transformers.TFBertLMHeadModel`

`call`

TFBertForMaskedLM

`class transformers.TFBertForMaskedLM`

`call`

TFBertForNextSentencePrediction

`call`

TFBertForSequenceClassification

`call`

TFBertForMultipleChoice

`class transformers.TFBertForMultipleChoice`

`call`

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（二十二）（3）

BertForQuestionAnswering

class transformers.BertForQuestionAnswering

forward

TFBertModel

class transformers.TFBertModel

call

TFBertForPreTraining

class transformers.TFBertForPreTraining

call

TFBertModelLMHeadModel

class transformers.TFBertLMHeadModel

call

TFBertForMaskedLM

class transformers.TFBertForMaskedLM

call

TFBertForNextSentencePrediction

call

TFBertForSequenceClassification

call

TFBertForMultipleChoice

class transformers.TFBertForMultipleChoice

call

热门文章

最新文章

相关课程

相关电子书

`class transformers.BertForQuestionAnswering`

`forward`

`class transformers.TFBertModel`

`call`

`class transformers.TFBertForPreTraining`

`call`

`class transformers.TFBertLMHeadModel`

`call`

`class transformers.TFBertForMaskedLM`

`call`

`call`

`call`

`class transformers.TFBertForMultipleChoice`

`call`