<a id="Header1_HeaderTitle" class="headermaintitle HeaderMainTitle" href="https://www.cnblogs.com/apachecn">龙哥盟

( hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 16384 type_vocab_size = 16 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 0 bos_token_id = 57344 eos_token_id = 57345 downsampling_rate = 4 upsampling_kernel_size = 4 num_hash_functions = 8 num_hash_buckets = 16384 local_transformer_stride = 128 **kwargs )

参数

hidden_size (int, optional, defaults to 768) — 编码器层和池化器层的维度。
num_hidden_layers (int, optional, defaults to 12) — 深度 Transformer 编码器中的隐藏层数量。
num_attention_heads (int, optional, defaults to 12) — Transformer 编码器中每个注意力层的注意力头数量。
intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（即前馈）层的维度。
hidden_act (str or function, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, optional, defaults to 16384) — 此模型可能使用的最大序列长度。
type_vocab_size (int, optional, defaults to 16) — 在调用 CanineModel 时传递的token_type_ids的词汇大小。
initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
pad_token_id (int, optional, defaults to 0) — 填充标记的 id。
bos_token_id (int, optional, defaults to 57344) — 流的开始标记的 id。
eos_token_id (int, optional, defaults to 57345) — 流的结束标记的 id。
downsampling_rate (int, optional, defaults to 4) — 在应用深度 Transformer 编码器之前对原始字符序列长度进行下采样的速率。
upsampling_kernel_size (int, optional, defaults to 4) — 当从hidden_size*2 投影回hidden_size时，卷积投影层的内核大小（即每个窗口中的字符数）。
num_hash_functions (int, optional, defaults to 8) — 要使用的哈希函数数量。每个哈希函数都有自己的嵌入矩阵。
num_hash_buckets (int, optional, defaults to 16384) — 要使用的哈希桶数量。
local_transformer_stride (int, optional, defaults to 128) — 第一个浅 Transformer 编码器的局部注意力的步幅。默认为 128，以获得良好的 TPU/XLA 内存对齐。

这是用于存储 CanineModel 配置的配置类。根据指定的参数实例化一个 CANINE 模型，定义模型架构。使用默认值实例化配置将产生类似于 CANINE google/canine-s 架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import CanineConfig, CanineModel

>>> # Initializing a CANINE google/canine-s style configuration
>>> configuration = CanineConfig()

>>> # Initializing a model (with random weights) from the google/canine-s style configuration
>>> model = CanineModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

CanineTokenizer

`class transformers.CanineTokenizer`

( bos_token = '\ue000' eos_token = '\ue001' sep_token = '\ue001' cls_token = '\ue000' pad_token = '\x00' mask_token = '\ue003' add_prefix_space = False model_max_length = 2048 **kwargs )

参数

model_max_length (int, optional, defaults to 2048) — 模型接受的最大句子长度。

构建一个 CANINE 分词器（即字符分割器）。它将文本转换为字符序列，然后将每个字符转换为其 Unicode 代码点。

CanineTokenizer 继承自 PreTrainedTokenizer。

参考超类 PreTrainedTokenizer 以获取用法示例和有关参数的文档。

`build_inputs_with_special_tokens`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— 将添加特殊标记的 ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

List[int]

带有适当特殊标记的 input IDs 列表。

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

单个序列：[CLS] X [SEP]
序列对：[CLS] A [SEP] B [SEP]

`get_special_tokens_mask`

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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 token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

List[int]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。CANINE

序列对掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，此方法仅返回掩码的第一部分（0s）。

CANINE 特定输出

`class transformers.models.canine.modeling_canine.CanineModelOutputWithPooling`

( last_hidden_state: FloatTensor = None pooler_output: FloatTensor = None hidden_states: Optional = None attentions: Optional = None )

参数

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层（即最终浅层 Transformer 编码器的输出）的隐藏状态序列。
pooler_output（形状为(batch_size, hidden_size)的torch.FloatTensor）— 模型最后一层的第一个标记（分类标记）的隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层的权重是通过预训练期间的下一个句子预测（分类）目标进行训练的。
hidden_states (tuple(torch.FloatTensor)，可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 形状为 (batch_size, sequence_length, hidden_size) 和 (batch_size, sequence_length // config.downsampling_rate, hidden_size) 的模型隐藏状态的元组。每个编码器的输入和每个编码器每层的输出的 torch.FloatTensor（一个）。模型在每层的输出的隐藏状态加上每个变压器编码器的初始输入。浅编码器的隐藏状态长度为 sequence_length，但深编码器的隐藏状态长度为 sequence_length // config.downsampling_rate。
attentions (tuple(torch.FloatTensor)，可选，当传递 output_attentions=True 或 config.output_attentions=True 时返回) — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 和 (batch_size, num_heads, sequence_length // config.downsampling_rate, sequence_length // config.downsampling_rate) 的 3 个变压器编码器的 torch.FloatTensor 元组。注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

CanineModel 的输出类型。基于 BaseModelOutputWithPooling，但 hidden_states 和 attentions 稍有不同，因为这些还包括浅变压器编码器的隐藏状态和注意力。

CanineModel

`class transformers.CanineModel`

( config add_pooling_layer = True )

参数

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

裸的 CANINE 模型变压器输出原始隐藏状态，没有任何特定的头部。这个模型是一个 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.canine.modeling_canine.CanineModelOutputWithPooling 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] 中选择：
- 对于未被 masked 的标记为 1，
- 对于被 masked 的标记为 0。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 指示输入的第一部分和第二部分的段标记索引。索引在 [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 表示头部未被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 而不是普通元组。

transformers.models.canine.modeling_canine.CanineModelOutputWithPooling 或 tuple(torch.FloatTensor)

transformers.models.canine.modeling_canine.CanineModelOutputWithPooling 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False）包含根据配置（CanineConfig）和输入的各种元素。

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列（即最终浅层 Transformer 编码器的输出）。
pooler_output (torch.FloatTensor of shape (batch_size, hidden_size)) — 序列第一个标记（分类标记）在深层 Transformer 编码器的最后一层的隐藏状态，进一步由线性层和 Tanh 激活函数处理。线性层的权重是在预训练期间从下一个句子预测（分类）目标中训练的。
hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)和(batch_size, sequence_length // config.downsampling_rate, hidden_size)的模型每层输出的torch.FloatTensor元组（每个编码器的输入和每个编码器每层的输出一个）。每层的隐藏状态加上每个 Transformer 编码器的初始输入。浅编码器的隐藏状态长度为sequence_length，但深编码器的隐藏状态长度为sequence_length // config.downsampling_rate。
attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)和(batch_size, num_heads, sequence_length // config.downsampling_rate, sequence_length // config.downsampling_rate)的 3 个 Transformer 编码器的torch.FloatTensor元组（每层一个）。注意力 softmax 后的注意力权重，用于计算自注意力头部中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, CanineModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineModel.from_pretrained("google/canine-s")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

CanineForSequenceClassification

`class transformers.CanineForSequenceClassification`

( config )

参数

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

CANINE 模型变压器，顶部带有序列分类/回归头（池化输出的线性层），例如用于 GLUE 任务。

此模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput 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, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请查看返回张量下的hidden_states。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为(batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。如果config.num_labels == 1，则计算回归损失（均方损失），如果config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

transformers.modeling_outputs.SequenceClassifierOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（CanineConfig）和输入的各种元素。

loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果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), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, CanineForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, CanineForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CanineForSequenceClassification.from_pretrained(
...     "google/canine-s", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

CanineForMultipleChoice

`class transformers.CanineForMultipleChoice`

( config )

参数

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

CANINE 模型在顶部具有多选分类头（池化输出上的线性层和 softmax），例如用于 RocStories/SWAG 任务。

此模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

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]范围内：
- 1 表示未被masked的标记，
- 0 表示被masked的标记。
什么是注意力掩码？
token_type_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]范围内选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
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]范围内：
- 1 表示头部未被masked，
- 0 表示头部被masked。
inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算多项选择分类损失的标签。索引应在[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时）包含根据配置（CanineConfig）和输入的不同元素。

loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 分类损失。
logits (torch.FloatTensor of shape (batch_size, num_choices)) — num_choices是输入张量的第二维度。（参见上面的input_ids）。

分类得分（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, CanineForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForMultipleChoice.from_pretrained("google/canine-s")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

CanineForTokenClassification

`class transformers.CanineForTokenClassification`

( config )

参数

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

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

这个模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput 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, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在 [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 时）包含根据配置（CanineConfig）和输入的不同元素。

loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 分类损失。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。
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 后的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, CanineForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForTokenClassification.from_pretrained("google/canine-s")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes

>>> labels = predicted_token_class_ids
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)

CanineForQuestionAnswering

`class transformers.CanineForQuestionAnswering`

( config )

参数

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

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

这个模型是 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（形状为(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的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]中：
- 0 对应于句子 A的标记，
- 1 对应于句子 B的标记。
什么是标记类型 ID？
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]中：
- 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 而不是一个普通元组。
start_positions（形状为(batch_size,)的torch.LongTensor，可选） — 用于计算标记跨度的起始位置（索引）的标签。位置被夹在序列的长度（sequence_length）上。序列外的位置不会被考虑在内计算损失。
end_positions（形状为(batch_size,)的torch.LongTensor，可选） — 用于计算标记跨度的结束位置（索引）的标签。位置被夹在序列的长度（sequence_length）上。序列外的位置不会被考虑在内计算损失。

transformers.modeling_outputs.QuestionAnsweringModelOutput 或torch.FloatTensor元组

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含各种元素，取决于配置（CanineConfig）和输入。

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

CanineForQuestionAnswering的forward方法，覆盖了__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, CanineForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("Splend1dchan/canine-c-squad")
>>> model = CanineForQuestionAnswering.from_pretrained("Splend1dchan/canine-c-squad")

>>> 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)
'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)
8.81

CodeGen

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/codegen

概述

CodeGen 模型在Erik Nijkamp、Bo Pang、Hiroaki Hayashi、Lifu Tu、Huan Wang、Yingbo Zhou、Silvio Savarese 和 Caiming Xiong 的《程序合成的对话范式》中提出。

CodeGen 是一个自回归语言模型，用于在The Pile、BigQuery 和 BigPython 上顺序训练程序合成。

论文摘要如下：

程序合成旨在生成计算机程序作为给定问题规范的解决方案。我们提出了一种通过大型语言模型进行对话式程序合成的方法，该方法解决了在先前方法中面临的在广泛的程序空间和用户意图规范中搜索的挑战。我们的新方法将编写规范和程序的过程视为用户和系统之间的多轮对话。它将程序合成视为一个序列预测问题，其中规范用自然语言表达，所需程序是有条件地抽样的。我们在自然语言和编程语言数据上训练了一系列大型语言模型，称为 CodeGen。通过数据中的弱监督和数据规模和模型规模的扩大，对话能力从简单的自回归语言建模中出现。为了研究对话式程序合成的模型行为，我们开发了一个多轮编程基准（MTPB），在这个基准中，解决每个问题都需要通过用户和模型之间的多轮对话进行多步合成。我们的研究结果显示了对话能力的出现以及所提出的对话式程序合成范式的有效性。此外，我们的 CodeGen 模型（在 TPU-v4 上训练的参数高达 16B）在 HumanEval 基准测试中优于 OpenAI 的 Codex。我们将包括检查点在内的训练库 JaxFormer 作为开源贡献提供：此链接。

此模型由Hiroaki Hayashi贡献。原始代码可以在这里找到。

检查点命名

CodeGen 模型的检查点可在不同的预训练数据上以不同大小的变量大小获得。
格式为：Salesforce/codegen-{size}-{data}，其中
- size: 350M、2B、6B、16B
- data:
  - nl: 在 The Pile 上预训练
  - multi: 初始化为nl，然后在多种编程语言数据上进一步预训练
  - mono: 初始化为multi，然后在 Python 数据上进一步预训练
例如，Salesforce/codegen-350M-mono提供了一个在 The Pile、多种编程语言和 Python 上顺序预训练的 3.5 亿参数检查点。

使用示例

>>> from transformers import AutoModelForCausalLM, AutoTokenizer

>>> checkpoint = "Salesforce/codegen-350M-mono"
>>> model = AutoModelForCausalLM.from_pretrained(checkpoint)
>>> tokenizer = AutoTokenizer.from_pretrained(checkpoint)

>>> text = "def hello_world():"

>>> completion = model.generate(**tokenizer(text, return_tensors="pt"))

>>> print(tokenizer.decode(completion[0]))
def hello_world():
    print("Hello World")

hello_world()

资源

因果语言建模任务指南

CodeGenConfig

`class transformers.CodeGenConfig`

( vocab_size = 50400 n_positions = 2048 n_ctx = 2048 n_embd = 4096 n_layer = 28 n_head = 16 rotary_dim = 64 n_inner = None activation_function = 'gelu_new' resid_pdrop = 0.0 embd_pdrop = 0.0 attn_pdrop = 0.0 layer_norm_epsilon = 1e-05 initializer_range = 0.02 use_cache = True bos_token_id = 50256 eos_token_id = 50256 tie_word_embeddings = False **kwargs )

参数

vocab_size（int，可选，默认为 50400）—CodeGen 模型的词汇量。定义了在调用 CodeGenModel 时可以表示的不同标记的数量。
n_positions（int，可选，默认为 2048）—此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
n_ctx（int，可选，默认为 2048）—此属性在CodeGenModel.__init__中使用，没有实际效果。
n_embd（int，可选，默认为 4096）—嵌入和隐藏状态的维度。
n_layer (int, optional, defaults to 28) — Transformer 编码器中隐藏层的数量。
n_head (int, optional, defaults to 16) — Transformer 编码器中每个注意力层的注意力头数。
rotary_dim (int, optional, defaults to 64) — 应用旋转位置嵌入的嵌入中的维度数量。
n_inner (int, optional) — 内部前馈层的维度。None 将将其设置为 n_embd 的 4 倍
activation_function (str, optional, defaults to "gelu_new") — 激活函数，在列表 ["relu", "silu", "gelu", "tanh", "gelu_new"] 中选择。
resid_pdrop (float, optional, defaults to 0.0) — 嵌入层、编码器和池化器中所有全连接层的丢弃概率。
embd_pdrop (int, optional, defaults to 0.0) — 嵌入的丢弃比率。
attn_pdrop (float, optional, defaults to 0.0) — 注意力的丢弃比率。
layer_norm_epsilon (float, optional, defaults to 1e-05) — 层归一化层中要使用的 epsilon。
initializer_range (float, optional, defaults to 0.02) — 初始化所有权重矩阵的截断正态初始化器的标准差。
use_cache (bool, optional, defaults to True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。
bos_token_id (int, optional, defaults to 50256) — 流的开始标记 id。
eos_token_id (int, optional, defaults to 50256) — 流的结束标记 id。
tie_word_embeddings (bool, optional, defaults to False) — 模型的输入和输出词嵌入是否应该绑定。请注意，只有在模型具有输出词嵌入层时，这才相关。

这是配置类，用于存储 CodeGenModel 的配置。它用于根据指定的参数实例化 CodeGen 模型，定义模型架构。使用默认值实例化配置将产生类似于 CodeGen Salesforce/codegen-2B-mono 架构的配置。配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import CodeGenConfig, CodeGenModel

>>> # Initializing a CodeGen 6B configuration
>>> configuration = CodeGenConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = CodeGenModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

CodeGenTokenizer

`class transformers.CodeGenTokenizer`

( vocab_file merges_file errors = 'replace' unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' pad_token = None add_prefix_space = False add_bos_token = False **kwargs )

参数

vocab_file (str) — 词汇文件的路径。
merges_file (str) — 合并文件的路径。
errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅 bytes.decode。
unk_token（str，optional，默认为"<|endoftext|>"）--未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。
bos_token（str，optional，默认为"<|endoftext|>"）--序列标记的开头。
eos_token（str，optional，默认为"<|endoftext|>"）--序列结束标记。
pad_token (str, optional) — 用于填充的标记，例如在批处理不同长度的序列时使用。
add_prefix_space (bool, optional, defaults to False) — 是否在输入中添加初始空格。这允许将前导单词视为任何其他单词。（CodeGen 分词器通过前面的空格检测单词的开头）。
add_bos_token (bool, optional, defaults to False) — 是否在序列开头添加一个序列开始标记。

构建一个 CodeGen 分词器。基于字节级字节对编码。

此分词器已经训练过，将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，可能会以不同方式编码：

>>> from transformers import CodeGenTokenizer

>>> tokenizer = CodeGenTokenizer.from_pretrained("Salesforce/codegen-350M-mono")
>>> tokenizer("Hello world")["input_ids"]
[15496, 995]

>>> tokenizer(" Hello world")["input_ids"]
[18435, 995]

当实例化此分词器时或在对某些文本进行调用时，通过传递add_prefix_space=True可以避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当与is_split_into_words=True一起使用时，此分词器将在每个单词之前添加一个空格（甚至是第一个单词）。

此分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。

`save_vocabulary`

( save_directory: str filename_prefix: Optional = None )

CodeGenTokenizerFast

`class transformers.CodeGenTokenizerFast`

( vocab_file = None merges_file = None tokenizer_file = None unk_token = '<|endoftext|>' bos_token = '<|endoftext|>' eos_token = '<|endoftext|>' add_prefix_space = False **kwargs )

参数

vocab_file（str，可选）— 词汇文件的路径。
merges_file（str，可选）— 合并文件的路径。
tokenizer_file（str，可选）— tokenizers文件的路径（通常具有 .json 扩展名），其中包含加载分词器所需的所有内容。
unk_token（str，optional，默认为"<|endoftext|>"）--未知令牌。词汇表中没有的令牌无法转换为 ID，而是设置为该令牌。
bos_token（str，optional，默认为"<|endoftext|>"）--序列标记的开头。
eos_token（str，optional，默认为"<|endoftext|>"）--序列结束标记。
add_prefix_space（bool，可选，默认为False）— 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（CodeGen 分词器通过前面的空格检测单词的开头）。

构建一个“快速”CodeGen 分词器（由 HuggingFace 的tokenizers库支持）。基于字节级字节对编码。

此分词器已经训练成将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，将以不同方式编码：

>>> from transformers import CodeGenTokenizerFast

>>> tokenizer = CodeGenTokenizerFast.from_pretrained("Salesforce/codegen-350M-mono")
>>> tokenizer("Hello world")["input_ids"]
[15496, 995]

>>> tokenizer(" Hello world")["input_ids"]
[18435, 995]

当实例化此分词器时，通过传递add_prefix_space=True可以避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当与is_split_into_words=True一起使用时，此分词器需要使用add_prefix_space=True进行实例化。

此分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。

`decode`

( token_ids: Union skip_special_tokens: bool = False clean_up_tokenization_spaces: bool = None truncate_before_pattern: Optional = None **kwargs ) → export const metadata = 'undefined';str

参数

token_ids（Union[int, List[int], np.ndarray, torch.Tensor, tf.Tensor]）— 标记化输入 id 的列表。可以使用__call__方法获得。
skip_special_tokens（bool，可选，默认为False）— 是否在解码中删除特殊标记。
clean_up_tokenization_spaces（bool，可选）— 是否清理分词空格。如果为None，将默认为self.clean_up_tokenization_spaces（在tokenizer_config中可用）。
truncate_before_patter（List[str]，optional，默认为None）--将用于截断返回字符串的正则表达式字符串的列表。这可用于删除多余的代码段（例如，如果在新行开头观察到注释符号“#”，则截断）。一个示例模式可以是[”^#”, re.escape(”<|endoftext|>”),

str

解码后的句子。

使用分词器和词汇表将 id 序列转换为字符串，具有删除特殊标记和清理分词空格的选项。

类似于执行self.convert_tokens_to_string(self.convert_ids_to_tokens(token_ids))。

”。kwargs（额外的关键字参数，可选）：将传递给底层模型特定的解码方法。

CodeGenModel

`class transformers.CodeGenModel`

( config )

参数

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

裸的 CodeGen 模型变换器输出原始的隐藏状态，没有特定的头部。这个模型是一个 PyTorch torch.nn.Module 的子类。将其用作常规的 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有相关信息。

`forward`

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

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力。掩码值选定在 [0, 1]：
- 1 用于 未被掩码 的标记，
- 0 用于被 掩码 的标记。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引选定在 [0, 1]：
- 0 对应于一个 句子 A 标记，
- 1 对应于一个 句子 B 标记。
什么是标记类型 ID？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选定范围为 [0, config.n_positions - 1]。

什么是位置 ID？
head_mask (torch.FloatTensor，形状为 (num_attention_heads,) 或 (n_layer, num_attention_heads)，可选) — 用于使自注意力模块中的选定头部失效的掩码。掩码值选定在 [0, 1]：
- 1 表示头部 未被掩码，
- 0 表示头部 被掩码。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_dim)，可选) — 可选地，您可以选择直接传递一个嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

transformers.modeling_outputs.BaseModelOutputWithPast 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含根据配置（CodeGenConfig）和输入的不同元素。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）— 模型最后一层的隐藏状态序列。

如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或当config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 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的情况下可选地使用）可用（请参见past_key_values输入）以加快顺序解码的速度。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。

CodeGenModel 前向方法，覆盖__call__特殊方法。

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

示例：

>>> from transformers import AutoTokenizer, CodeGenModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/codegen-2B-mono")
>>> model = CodeGenModel.from_pretrained("Salesforce/codegen-2B-mono")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

CodeGenForCausalLM

`class transformers.CodeGenForCausalLM`

( config )

参数

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

带有语言建模头部的 CodeGen 模型变压器。

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

`forward`

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

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
- 1 表示未被masked的标记，
- 0 表示被masked的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A的标记。
- 1 对应于句子 B的标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.n_positions - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_attention_heads,)或(n_layer, num_attention_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未被masked，
- 0 表示头部被masked。
inputs_embeds（形状为(batch_size, sequence_length, hidden_dim)的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，可选）— 用于语言建模的标签。请注意，标签在模型内部被移位，即您可以设置labels = input_ids。在[-100, 0, ..., config.vocab_size]中选择索引。所有设置为-100的标签都被忽略（掩码），损失仅计算在[0, ..., config.vocab_size]中的标签。

transformers.modeling_outputs.CausalLMOutputWithPast 或者tuple(torch.FloatTensor)。

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者config.return_dict=False时）包含不同的元素，取决于配置（CodeGenConfig）和输入。

loss（形状为(1,)的torch.FloatTensor，可选，当提供了labels时返回） — 语言建模损失（用于下一个标记预测）。
logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor） — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或者config.use_cache=True时返回） — 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。

包含预先计算的隐藏状态（自注意力块中的键和值），可以用来加速顺序解码（参见past_key_values输入）。
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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, CodeGenForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/codegen-2B-mono")
>>> model = CodeGenForCausalLM.from_pretrained("Salesforce/codegen-2B-mono")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

CodeLlama

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/code_llama

概述

Code Llama 模型是由 Baptiste Rozière，Jonas Gehring，Fabian Gloeckle，Sten Sootla，Itai Gat，Xiaoqing Ellen Tan，Yossi Adi，Jingyu Liu，Tal Remez，Jérémy Rapin，Artyom Kozhevnikov，Ivan Evtimov，Joanna Bitton，Manish Bhatt，Cristian Canton Ferrer，Aaron Grattafiori，Wenhan Xiong，Alexandre Défossez，Jade Copet，Faisal Azhar，Hugo Touvron，Louis Martin，Nicolas Usunier，Thomas Scialom，Gabriel Synnaeve 提出的，详见Code Llama: Open Foundation Models for Code。

论文摘要如下：

我们发布了 Code Llama，这是基于 Llama 2 的一系列大型代码语言模型，提供了在开放模型中最先进的性能，填充能力，支持大型输入上下文以及编程任务的零-shot 指令跟随能力。我们提供多种风格以涵盖广泛的应用：基础模型（Code Llama），Python 专业化模型（Code Llama - Python）和指令跟随模型（Code Llama - Instruct），分别具有 7B，13B 和 34B 参数。所有模型都是在 16k 标记序列上训练的，并在最多 100k 标记的输入上显示出改进。7B 和 13B 的 Code Llama 和 Code Llama - Instruct 变体支持基于周围内容的填充。Code Llama 在几个代码基准测试中达到了开放模型的最先进性能，分别在 HumanEval 和 MBPP 上达到了 53%和 55%的分数。值得注意的是，Code Llama - Python 7B 在 HumanEval 和 MBPP 上优于 Llama 2 70B，而我们所有的模型都优于 MultiPL-E 上的其他任何公开可用模型。我们以一种允许研究和商业使用的宽松许可证发布了 Code Llama。

查看所有 Code Llama 模型检查点这里，以及在codellama org上正式发布的模型。

此模型由ArthurZucker贡献。作者的原始代码可以在这里找到。

用法提示和示例

Code Llama 基于的Llama2系列模型是使用bfloat16训练的，但原始推断使用float16。让我们看看不同的精度：

float32：PyTorch 在模型初始化时的惯例是以float32加载模型，无论模型权重存储时使用的是哪种dtype。transformers也遵循这种惯例，以保持与 PyTorch 的一致性。这将被默认选择。如果您希望AutoModel API 将加载检查点时的存储权重类型转换为dtype，则必须指定torch_dtype="auto"，例如model = AutoModelForCausalLM.from_pretrained("path", torch_dtype = "auto")。
bfloat16：Code Llama 是使用这种精度训练的，因此我们建议在进一步训练或微调时使用它。
float16：我们建议使用这种精度来运行推断，因为通常比bfloat16更快，并且评估指标显示与bfloat16相比没有明显的降级。您也可以使用bfloat16来运行推断，我们建议您在微调后使用float16和bfloat16检查推断结果。

如上所述，存储权重的dtype大多数情况下并不重要，除非您在初始化模型时使用torch_dtype="auto"。原因是模型将首先被下载（使用在线检查点的dtype），然后将被转换为torch的默认dtype（变为torch.float32）。如果有指定的torch_dtype，则将使用该指定值。

提示：

填充任务是开箱即用的。您应该在想要填充输入的地方使用tokenizer.fill_token。
模型转换脚本与Llama2系列相同：

以下是一个示例用法：

python src/transformers/models/llama/convert_llama_weights_to_hf.py \
    --input_dir /path/to/downloaded/llama/weights --model_size 7B --output_dir /output/path

请注意，执行脚本需要足够的 CPU RAM 来承载整个模型的 float16 精度（即使最大版本分为几个检查点，每个检查点都包含模型的每个权重的一部分，因此我们需要将它们全部加载到 RAM 中）。

转换后，可以通过以下方式加载模型和分词器：

>>> from transformers import LlamaForCausalLM, CodeLlamaTokenizer

>>> tokenizer = CodeLlamaTokenizer.from_pretrained("codellama/CodeLlama-7b-hf")
>>> model = LlamaForCausalLM.from_pretrained("codellama/CodeLlama-7b-hf")
>>> PROMPT = '''def remove_non_ascii(s: str) -> str:
    """ <FILL_ME>
    return result
'''
>>> input_ids = tokenizer(PROMPT, return_tensors="pt")["input_ids"]
>>> generated_ids = model.generate(input_ids, max_new_tokens=128)

>>> filling = tokenizer.batch_decode(generated_ids[:, input_ids.shape[1]:], skip_special_tokens = True)[0]
>>> print(PROMPT.replace("<FILL_ME>", filling))
def remove_non_ascii(s: str) -> str:
    """ Remove non-ASCII characters from a string.

    Args:
        s: The string to remove non-ASCII characters from.

    Returns:
        The string with non-ASCII characters removed.
    """
    result = ""
    for c in s:
        if ord(c) < 128:
            result += c
    return result

如果只想要填充部分：

>>> from transformers import pipeline
>>> import torch

>>> generator = pipeline("text-generation",model="codellama/CodeLlama-7b-hf",torch_dtype=torch.float16, device_map="auto")
>>> generator('def remove_non_ascii(s: str) -> str:\n    """ <FILL_ME>\n    return result', max_new_tokens = 128, return_type = 1)

在底层，分词器自动通过<FILL_ME>进行拆分以创建一个格式化的输入字符串，遵循原始训练模式。这比自己准备模式更加健壮：它避免了很难调试的诸如标记粘合等问题。要查看此模型或其他模型所需的 CPU 和 GPU 内存量，请尝试使用此计算器，该计算器可以帮助确定该值。

LLaMA 分词器是基于sentencepiece的 BPE 模型。SentencePiece 的一个特点是，在解码序列时，如果第一个标记是单词的开头（例如“Banana”），分词器不会在字符串前面添加前缀空格。

Code Llama 与Llama2模型具有相同的架构，请参考 Llama2 的文档页面获取 API 参考。以下是 Code Llama 分词器的参考。

CodeLlamaTokenizer

`class transformers.CodeLlamaTokenizer`

( vocab_file unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' prefix_token = '▁<PRE>' middle_token = '▁<MID>' suffix_token = '▁<SUF>' eot_token = '▁<EOT>' fill_token = '<FILL_ME>' suffix_first = False sp_model_kwargs: Optional = None add_bos_token = True add_eos_token = False clean_up_tokenization_spaces = False additional_special_tokens = None use_default_system_prompt = False **kwargs )

参数

vocab_file（str）— 词汇表文件的路径。
unk_token（str，可选，默认为"<unk>"）— 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
bos_token（str，可选，默认为"<s>"）— 在预训练期间使用的序列开始标记。可用作序列分类器标记。
eos_token（str，可选，默认为"</s>"）— 序列结束标记。

在构建使用特殊标记的序列时，这不是用于表示序列结束的标记。使用的标记是sep_token。
prefix_token（str，可选，默认为"▁<PRE>"）— 用于填充的前缀标记。
middle_token（str，可选，默认为"▁<MID>"）— 用于填充的中间标记。
suffix_token（str，可选，默认为"▁<SUF>"）— 用于填充的后缀标记。
eot_token（str，可选，默认为"▁<EOT>"）— 用于填充的文本结束标记。
fill_token（str，可选，默认为"<FILL_ME>"）— 用于在前缀和后缀之间拆分输入的标记。
suffix_first（bool，可选，默认为False）— 输入提示和后缀是否应该首先格式化后缀。
sp_model_kwargs（dict，可选）— 将传递给SentencePieceProcessor.__init__()方法。SentencePiece 的 Python 包装器可用于设置：
- enable_sampling：启用子词规范化。
- nbest_size：unigram 的抽样参数。对于 BPE-Dropout 无效。
  - nbest_size = {0,1}：不执行抽样。
  - nbest_size > 1：从 nbest_size 结果中进行抽样。
  - nbest_size < 0：假设 nbest_size 是无限的，并使用前向过滤和后向抽样算法从所有假设（格子）中进行抽样。
- alpha：unigram 抽样的平滑参数，以及 BPE-dropout 合并操作的丢弃概率。
add_bos_token（bool，可选，默认为True）— 是否在序列开头添加一个序列开始标记。
add_eos_token（bool，可选，默认为False）— 是否在序列末尾添加一个序列结束标记。
clean_up_tokenization_spaces（bool，可选，默认为False）— 是否清除分词空格。
additional_special_tokens（List[str]，可选）— 分词器使用的额外特殊标记。
use_default_system_prompt（bool，可选，默认为False）— 是否应使用 Llama 的默认系统提示。

构建一个 CodeLlama 分词器。基于字节级字节对编码。默认填充标记未设置，因为原始模型中没有填充标记。

默认配置与sentencepiece/CodeLlama-7b-Instruct-hf匹配，支持提示填充。

build_inputs_with_special_tokens

( token_ids_0 token_ids_1 = None )

`get_special_tokens_mask`

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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 token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 ALBERT

序列对掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则仅返回掩码的第一部分（0s）。

`save_vocabulary`

( save_directory filename_prefix: Optional = None ) → export const metadata = 'undefined';Tuple(str)

参数

save_directory（str）— 保存词汇表的目录。

Tuple(str)

保存的文件路径。

将词汇表和特殊标记文件保存到目录中。

CodeLlamaTokenizerFast

`class transformers.CodeLlamaTokenizerFast`

( vocab_file = None tokenizer_file = None clean_up_tokenization_spaces = False unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' prefix_token = '▁<PRE>' middle_token = '▁<MID>' suffix_token = '▁<SUF>' eot_token = '▁<EOT>' fill_token = '<FILL_ME>' additional_special_tokens = None add_bos_token = True add_eos_token = False use_default_system_prompt = False **kwargs )

参数

vocab_file（str，可选）— SentencePiece文件（通常具有.model扩展名），其中包含实例化分词器所需的词汇表。
tokenizer_file（str，可选）— tokenizers文件（通常具有.json扩展名），其中包含加载分词器所需的所有内容。
clean_up_tokenization_spaces（str，可选，默认为False）— 解码后是否清除空格，清除包括删除额外的空格等潜在工件。
unk_token（str，可选，默认为"<unk>"）— 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
bos_token（str，可选，默认为"<s>"）— 在预训练期间使用的序列开始标记。可以用作序列分类器标记。
eos_token (str, optional, defaults to "</s>") — 序列结束标记。
prefix_token (str, optional, defaults to "▁<PRE>") — 用于填充的前缀标记。
middle_token (str, optional, defaults to "▁<MID>") — 用于填充的中间标记。
suffix_token (str, optional, defaults to "▁<SUF>") — 用于填充的后缀标记。
eot_token (str, optional, defaults to "▁<EOT>") — 用于填充的文本结束标记。
fill_token (str, optional, defaults to "<FILL_ME>") — 用于在前缀和后缀之间分割输入的标记。
additional_special_tokens (List[str], optional) — 分词器使用的额外特殊标记。
add_bos_token (bool, optional, defaults to True) — 是否在序列开头添加一个起始标记。
add_eos_token (bool, optional, defaults to False) — 是否在序列末尾添加一个序列结束标记。
use_default_system_prompt (bool, optional, defaults to False) — 是否使用 Llama 的默认系统提示。

构建一个 Llama 分词器。基于字节级字节对编码。

这里特别使用了 ByteFallback 和无规范化。

>>> from transformers import CodeLlamaTokenizerFast

>>> tokenizer = CodeLlamaTokenizerFast.from_pretrained("hf-internal-testing/llama-tokenizer")
>>> tokenizer.encode("Hello this is a test")
[1, 15043, 445, 338, 263, 1243]

如果要更改 bos_token 或 eos_token，请确保在初始化模型时指定它们，或调用 tokenizer.update_post_processor() 确保后处理正确完成（否则编码序列的第一个标记和最后一个标记的值将不正确）。有关更多详细信息，请查看 [post-processors] (huggingface.co/docs/tokenizers/api/post-processors) 文档。

这个分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。默认配置与 codellama/CodeLlama-7b-Instruct-hf 匹配，支持提示填充。

`build_inputs_with_special_tokens`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
token_ids_1 (List[int], optional) — 第二个序列的可选 ID 列表。

List[int]

带有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记，为序列分类任务构建模型输入的序列或序列对。特殊标记取决于调用 set_lang。

NLLB 序列具有以下格式，其中 X 表示序列：

input_ids（用于编码器）X [eos, src_lang_code]
decoder_input_ids: (用于解码器) X [eos, tgt_lang_code]

BOS 从不使用。序列对不是预期的用例，但它们将在没有分隔符的情况下处理。

`get_special_tokens_mask`

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';A list of integers in the range [0, 1]

参数

token_ids_0 (List[int]) — 第一个序列的 ID 列表。
token_ids_1 (List[int], optional) — 第二个序列的 ID 列表。
already_has_special_tokens (bool, optional, defaults to False) — 标记列表是否已经使用模型的特殊标记格式化。

一个在范围[0, 1]内的整数列表

1 表示特殊标记，0 表示序列标记。

从没有添加特殊标记的标记列表中检索序列 ID。当使用分词器的 prepare_for_model 或 encode_plus 方法添加特殊标记时，将调用此方法。

`create_token_type_ids_from_sequences`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — 第一个标记化序列。
token_ids_1 (List[int], optional) — 第二个标记化序列。

List[int]

标记类型 ID。

创建与传递的序列相对应的标记类型 ID。什么是标记类型 ID？

如果模型有一种特殊的构建方式，则应该在子类中重写这个方法。

`update_post_processor`

( )

使用当前的bos_token和eos_token更新底层后处理器。

`save_vocabulary`

( save_directory: str filename_prefix: Optional = None )

ConvBERT

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/convbert

概述

ConvBERT 模型由 Zihang Jiang、Weihao Yu、Daquan Zhou、Yunpeng Chen、Jiashi Feng、Shuicheng Yan 在ConvBERT: Improving BERT with Span-based Dynamic Convolution中提出。

该论文的摘要如下：

最近，像 BERT 及其变种这样的预训练语言模型在各种自然语言理解任务中取得了令人印象深刻的性能。然而，BERT 严重依赖全局自注意力块，因此存在较大的内存占用和计算成本。尽管所有的注意力头都在整个输入序列上查询，以从全局视角生成注意力图，但我们观察到一些头部只需要学习局部依赖关系，这意味着存在计算冗余。因此，我们提出了一种新颖的基于跨度的动态卷积，以替换这些自注意力头，直接建模局部依赖关系。这种新颖的卷积头，与其余的自注意力头一起，形成了一个新的混合注意力块，更有效地学习全局和局部上下文。我们将 BERT 配备了这种混合注意力设计，并构建了一个 ConvBERT 模型。实验证明，ConvBERT 在各种下游任务中明显优于 BERT 及其变种，训练成本更低，模型参数更少。值得注意的是，ConvBERTbase 模型的 GLUE 得分为 86.4，比 ELECTRAbase 高 0.7，同时使用不到 1/4 的训练成本。代码和预训练模型将会发布。

此模型由abhishek贡献。原始实现可在此处找到：github.com/yitu-opensource/ConvBert

使用提示

ConvBERT 训练提示与 BERT 类似。有关使用提示，请参阅 BERT 文档。

资源

文本分类任务指南
标记分类任务指南
问答任务指南
掩码语言建模任务指南
多项选择任务指南

ConvBertConfig

`class transformers.ConvBertConfig`

( vocab_size = 30522 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 pad_token_id = 1 bos_token_id = 0 eos_token_id = 2 embedding_size = 768 head_ratio = 2 conv_kernel_size = 9 num_groups = 1 classifier_dropout = None **kwargs )

参数

vocab_size (int，可选，默认为 30522）— ConvBERT 模型的词汇大小。定义了在调用 ConvBertModel 或 TFConvBertModel 时可以表示的不同标记数量。
hidden_size (int，可选，默认为 768）— 编码器层和池化器层的维度。
num_hidden_layers (int，可选，默认为 12）— Transformer 编码器中的隐藏层数量。
num_attention_heads (int，可选，默认为 12）— Transformer 编码器中每个注意力层的注意力头数量。
intermediate_size (int，可选，默认为 3072）— Transformer 编码器中“中间”（即前馈）层的维度。
hidden_act (str或function，可选，默认为"gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"selu"和"gelu_new"。
hidden_dropout_prob（float，可选，默认为 0.1）— 嵌入、编码器和池化器中所有全连接层的丢失概率。
attention_probs_dropout_prob（float，可选，默认为 0.1）— 注意力概率的丢失比率。
max_position_embeddings（int，可选，默认为 512）— 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如 512、1024 或 2048）。
type_vocab_size（int，可选，默认为 2）— 在调用 ConvBertModel 或 TFConvBertModel 时传递的token_type_ids的词汇表大小。
initializer_range（float，可选，默认为 0.02）— 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps（float，可选，默认为 1e-12）— 层归一化层使用的 epsilon。
head_ratio（int，可选，默认为 2）— 用于减少注意力头数的比例 gamma。
num_groups（int，可选，默认为 1）— ConvBert 模型的分组线性层的组数
conv_kernel_size（int，可选，默认为 9）— 卷积核的大小。
classifier_dropout（float，可选）— 分类头的丢失比率。

这是用于存储 ConvBertModel 配置的配置类。它用于根据指定的参数实例化 ConvBERT 模型，定义模型架构。使用默认值实例化配置将产生类似于 ConvBERT YituTech/conv-bert-base架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读来自 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import ConvBertConfig, ConvBertModel

>>> # Initializing a ConvBERT convbert-base-uncased style configuration
>>> configuration = ConvBertConfig()

>>> # Initializing a model (with random weights) from the convbert-base-uncased style configuration
>>> model = ConvBertModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

ConvBertTokenizer

`class transformers.ConvBertTokenizer`

( vocab_file do_lower_case = True do_basic_tokenize = True never_split = None unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

vocab_file（str）— 包含词汇表的文件。
do_lower_case（bool，可选，默认为True）— 在标记化时是否将输入转换为小写。
do_basic_tokenize（bool，可选，默认为True）— 在 WordPiece 之前是否进行基本标记化。
never_split（Iterable，可选）— 在标记化过程中永远不会被分割的标记集合。仅在do_basic_tokenize=True时有效
unk_token（str，可选，默认为"[UNK]"）— 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
sep_token（str，可选，默认为"[SEP]"）— 分隔符标记，在构建来自多个序列的序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。
pad_token（str，可选，默认为"[PAD]"）— 用于填充的标记，例如在批处理不同长度的序列时使用。
cls_token（str，可选，默认为"[CLS]"）— 分类器标记，用于进行序列分类（对整个序列而不是每个标记进行分类）。在使用特殊标记构建时，它是序列的第一个标记。
mask_token (str, 可选, 默认为 "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
tokenize_chinese_chars (bool, 可选, 默认为 True) — 是否标记化中文字符。

这可能应该在日语中停用（请参阅此问题）。
strip_accents (bool, 可选) — 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 ConvBERT 相同）。

构建一个 ConvBERT 分词器。基于 WordPiece。

此分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

`build_inputs_with_special_tokens`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — 要添加特殊标记的 ID 列表。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

List[int]

具有适当特殊标记的输入 ID 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。ConvBERT 序列具有以下格式：

单个序列：[CLS] X [SEP]
序列对：[CLS] A [SEP] B [SEP]

`get_special_tokens_mask`

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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 token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

List[int]

根据给定序列的标记类型 ID 列表。

从传递的两个序列创建用于序列对分类任务的掩码。ConvBERT 序列

序列掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

`save_vocabulary`

( save_directory: str filename_prefix: Optional = None )

ConvBertTokenizerFast

`class transformers.ConvBertTokenizerFast`

( vocab_file = None tokenizer_file = None do_lower_case = True unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' tokenize_chinese_chars = True strip_accents = None **kwargs )

参数

vocab_file (str) — 包含词汇表的文件。
do_lower_case (bool, 可选, 默认为 True) — 在标记化时是否将输入转换为小写。
unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
sep_token（str，可选，默认为"[SEP]"）— 分隔符标记，用于从多个序列构建序列，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。
pad_token（str，可选，默认为"[PAD]"）— 用于填充的标记，例如在批处理不同长度的序列时使用。
cls_token（str，可选，默认为"[CLS]"）— 在进行序列分类（对整个序列而不是每个标记进行分类）时使用的分类器标记。当使用特殊标记构建序列时，它是序列的第一个标记。
mask_token（str，可选，默认为"[MASK]"）— 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
clean_text（bool，可选，默认为True）— 是否在标记化之前清理文本，通过删除所有控制字符并将所有空格替换为经典空格。
tokenize_chinese_chars（bool，可选，默认为True）— 是否对中文字符进行标记化。这可能应该在日语中停用（参见此问题）。
strip_accents（bool，可选）— 是否去除所有重音符号。如果未指定此选项，则将由lowercase的值确定（与原始 ConvBERT 中的情况相同）。
wordpieces_prefix（str，可选，默认为"##"）— 用于子词的前缀。

根据给定序列构造“快速”ConvBERT 分词器（由 HuggingFace 的tokenizers库支持）。基于 WordPiece。

此分词器继承自 PreTrainedTokenizerFast，其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息。

`build_inputs_with_special_tokens`

( token_ids_0 token_ids_1 = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— 要添加特殊标记的 ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

List[int]

具有适当特殊标记的 input IDs 列表。

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

单个序列：[CLS] X [SEP]
序列对：[CLS] A [SEP] B [SEP]

`create_token_type_ids_from_sequences`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。

List[int]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 ConvBERT 序列

序列对掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1是None，则此方法仅返回掩码的第一部分（0s）。

PytorchHide Pytorch 内容

ConvBertModel

`class transformers.ConvBertModel`

( config )

参数

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

裸的 ConvBERT 模型变压器输出原始隐藏状态，没有特定的头部。这个模型是 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 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), 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：

transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithCrossAttentions 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含各种元素，取决于配置（ConvBertConfig）和输入。

last_hidden_state (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
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 之后，用于计算交叉注意力头中的加权平均值。

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

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

示例:

>>> from transformers import AutoTokenizer, ConvBertModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = ConvBertModel.from_pretrained("YituTech/conv-bert-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

ConvBertForMaskedLM

`class transformers.ConvBertForMaskedLM`

( config )

参数

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

ConvBERT 模型在顶部有一个语言建模头。此模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput 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)，optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

transformers.modeling_outputs.MaskedLMOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置(ConvBertConfig)和输入的各种元素。

loss (torch.FloatTensor，形状为(1,)，optional, 当提供labels时返回) — 掩码语言建模（MLM）损失。
logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, ConvBertForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = ConvBertForMaskedLM.from_pretrained("YituTech/conv-bert-base")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)

ConvBertForSequenceClassification

`class transformers.ConvBertForSequenceClassification`

( config )

参数

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

ConvBERT 模型变压器，顶部带有序列分类/回归头（顶部的线性层在池化输出之上），例如用于 GLUE 任务。

此模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput 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]中：

transformers.modeling_outputs.SequenceClassifierOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或当config.return_dict=False时）包含各种元素，具体取决于配置（ConvBertConfig）和输入。

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, ConvBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = ConvBertForSequenceClassification.from_pretrained("YituTech/conv-bert-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ConvBertForSequenceClassification.from_pretrained("YituTech/conv-bert-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, ConvBertForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = ConvBertForSequenceClassification.from_pretrained("YituTech/conv-bert-base", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = ConvBertForSequenceClassification.from_pretrained(
...     "YituTech/conv-bert-base", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

ConvBertForMultipleChoice

`class transformers.ConvBertForMultipleChoice`

( config )

参数

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

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

这个模型是一个 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

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

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

什么是输入 ID？
attention_mask (torch.FloatTensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在 [0, 1] 之间：

transformers.modeling_outputs.MultipleChoiceModelOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MultipleChoiceModelOutput 或一个 torch.FloatTensor 元组（如果传递了 return_dict=False 或当 config.return_dict=False 时）包含根据配置 (ConvBertConfig) 和输入的各种元素。

loss (torch.FloatTensor，形状为 (1,)，可选，当提供 labels 时返回) — 分类损失。
logits (torch.FloatTensor，形状为 (batch_size, num_choices)) — 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, ConvBertForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = ConvBertForMultipleChoice.from_pretrained("YituTech/conv-bert-base")

>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

ConvBertForTokenClassification

`class transformers.ConvBertForTokenClassification`

( config )

参数

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

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

此模型是 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 labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput 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]：

transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False 时）包含根据配置（ConvBertConfig）和输入而异的各种元素。

loss (torch.FloatTensor of shape (1,)，可选，当提供labels时返回） — 分类损失。
logits (torch.FloatTensor of shape (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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

示例：

>>> from transformers import AutoTokenizer, ConvBertForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = ConvBertForTokenClassification.from_pretrained("YituTech/conv-bert-base")

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

ConvBertForQuestionAnswering

`class transformers.ConvBertForQuestionAnswering`

( config )

参数

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

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

该模型是 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)，可选) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：

transformers.modeling_outputs.QuestionAnsweringModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（ConvBertConfig）和输入的各种元素。

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 之后。

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

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

示例：

>>> from transformers import AutoTokenizer, ConvBertForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = ConvBertForQuestionAnswering.from_pretrained("YituTech/conv-bert-base")

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

TensorFlow 隐藏 TensorFlow 内容

TFConvBertModel

`class transformers.TFConvBertModel`

( config *inputs **kwargs )

参数

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

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

这个模型继承自 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: Optional[Union[np.array, tf.Tensor]] = None token_type_ids: Optional[Union[np.array, tf.Tensor]] = None position_ids: Optional[Union[np.array, tf.Tensor]] = None head_mask: Optional[Union[np.array, tf.Tensor]] = None inputs_embeds: tf.Tensor | None = 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.modeling_tf_outputs.TFBaseModelOutput or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor）- 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值选定在[0, 1]之间：
- 1 表示“未被屏蔽”的标记，
- 0 表示“被屏蔽”的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 指示输入的第一部分和第二部分的段标记索引。索引选定在[0, 1]中：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy 数组或tf.Tensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：
- 1 表示头部未被“屏蔽”，
- 0 表示头部被“屏蔽”。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅在急切模式下可用，在图模式下将使用配置中的值。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。这个参数只能在急切模式下使用，在图模式下将使用配置中的值。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通的元组。这个参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间有不同的行为）。

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

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

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor） — 模型最后一层的隐藏状态序列。
hidden_states (tuple(tf.FloatTensor), 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFConvBertModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = TFConvBertModel.from_pretrained("YituTech/conv-bert-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFConvBertForMaskedLM

`class transformers.TFConvBertForMaskedLM`

( config *inputs **kwargs )

参数

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

ConvBERT 模型顶部带有一个语言建模头。

这个模型继承自 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: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMaskedLMOutput or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor）- 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
- 1 表示未被“masked”的标记，
- 对于被masked的标记，使用 0。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）- 每个输入序列标记在位置嵌入中的位置的索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy 数组或tf.Tensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未被“masked”,
- 0 表示头部被masked。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递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, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。索引应在[-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）包含根据配置（ConvBertConfig）和输入的各种元素。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TFConvBertForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = TFConvBertForMaskedLM.from_pretrained("YituTech/conv-bert-base")

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

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

TFConvBertForSequenceClassification

`class transformers.TFConvBertForSequenceClassification`

( config *inputs **kwargs )

参数

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

ConvBERT 模型变换器，顶部带有序列分类/回归头，例如 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: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor）—词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）—遮罩，以避免在填充标记索引上执行注意力。选择的掩码值在[0, 1]中：
- 对于未屏蔽的标记，
- 0 对应于被屏蔽的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的Numpy 数组或tf.Tensor，可选）—段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids (Numpy array 或 tf.Tensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围在[0, config.max_position_embeddings - 1]之间。

什么是位置 ID？
head_mask (Numpy array 或 tf.Tensor of shape (num_heads,) 或 (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选定在[0, 1]之间：
- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
inputs_embeds (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, 默认为False) — 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。
labels (tf.Tensor of shape (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在[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时）包含根据配置（ConvBertConfig）和输入而异的各种元素。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TFConvBertForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = TFConvBertForSequenceClassification.from_pretrained("YituTech/conv-bert-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFConvBertForSequenceClassification.from_pretrained("YituTech/conv-bert-base", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

TFConvBertForMultipleChoice

`class transformers.TFConvBertForMultipleChoice`

( config *inputs **kwargs )

参数

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

ConvBERT 模型在顶部具有多选分类头（在池化输出的顶部和 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: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput or tuple(tf.Tensor)

参数

input_ids (Numpy array or tf.Tensor of shape (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask (Numpy array 或 tf.Tensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在 [0, 1] 范围内：
- 1 表示未被 masked 的标记，
- 0 表示被 masked 的标记。
什么是注意力掩码？
token_type_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 指示输入的第一部分和第二部分的段标记索引。索引在 [0, 1] 范围内选择：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是标记类型 ID？
position_ids (Numpy array 或 tf.Tensor，形状为 (batch_size, num_choices, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
head_mask (Numpy array 或 tf.Tensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块的选定头部失效的掩码。选择的掩码值在 [0, 1] 范围内：
- 1 表示头部是 not masked,
- 0 表示头部是 masked。
inputs_embeds (tf.Tensor，形状为 (batch_size, num_choices, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。该参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回的张量下的 hidden_states。该参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict (bool，可选) — 是否返回 ModelOutput 而不是普通元组。该参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool，可选，默认为 False) — 是否在训练模式下使用模型（一些模块，如丢弃模块，在训练和评估之间具有不同的行为）。
labels (tf.Tensor，形状为 (batch_size,)，可选) — 用于计算多项选择分类损失的标签。索引应在 [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）包含根据配置（ConvBertConfig）和输入的各种元素。

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

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

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

示例：

>>> from transformers import AutoTokenizer, TFConvBertForMultipleChoice
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = TFConvBertForMultipleChoice.from_pretrained("YituTech/conv-bert-base")

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

TFConvBertForTokenClassification

`class transformers.TFConvBertForTokenClassification`

( config *inputs **kwargs )

参数

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

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

这个模型继承自 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: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 输入序列标记在词汇表中的索引。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
- 1 表示未被masked的标记，
- 0 表示被masked的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A的标记，
- 1 对应于句子 B的标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy数组或tf.Tensor，可选）- 用于使自注意力模块的选定头部无效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未被masked，
- 0 表示头部被masked。
inputs_embeds（形状为(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 模块在训练和评估之间有不同的行为）。
labels（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于计算标记分类损失的标签。索引应在[0, ..., config.num_labels - 1]范围内。

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

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

loss（形状为(n,)的tf.Tensor，可选，当提供labels时返回，其中 n 是未屏蔽标签的数量）— 分类损失。
logits（形状为(batch_size, sequence_length, config.num_labels)的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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFConvBertForTokenClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = TFConvBertForTokenClassification.from_pretrained("YituTech/conv-bert-base")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]

>>> labels = predicted_token_class_ids
>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)

TFConvBertForQuestionAnswering

`class transformers.TFConvBertForQuestionAnswering`

( config *inputs **kwargs )

参数

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

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

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

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

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

将所有输入作为关键字参数（类似于 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 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: tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: tf.Tensor | None = None end_positions: tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor）- 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
- 1 对应于未被masked的标记，
- 对于被masked的标记，值为 0。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的Numpy数组或tf.Tensor，可选）- 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的Numpy数组或tf.Tensor，可选）- 用于使自注意力模块中的特定头部失效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未被masked，
- 0 表示头部被masked。
inputs_embeds (tf.Tensor，形状为(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, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
start_positions (tf.Tensor，形状为(batch_size,)，optional) — 用于计算标记跨度的开始位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。
end_positions (tf.Tensor，形状为(batch_size,)，optional) — 用于计算标记分类损失的标记跨度结束位置（索引）的标签。位置被夹紧到序列的长度（sequence_length）。序列外的位置不会被考虑在内以计算损失。

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

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

loss (tf.Tensor，形状为(batch_size,)，optional, 当提供start_positions和end_positions时返回) — 总跨度提取损失是开始和结束位置的交叉熵之和。
start_logits (tf.Tensor，形状为(batch_size, sequence_length)) — 跨度开始分数（SoftMax 之前）。
end_logits (tf.Tensor，形状为(batch_size, sequence_length)) — 跨度结束分数（SoftMax 之前）。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFConvBertForQuestionAnswering
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("YituTech/conv-bert-base")
>>> model = TFConvBertForQuestionAnswering.from_pretrained("YituTech/conv-bert-base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)

>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]

>>> # target is "nice puppet"
>>> target_start_index = tf.constant([14])
>>> target_end_index = tf.constant([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = tf.math.reduce_mean(outputs.loss)

CPM

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/cpm

概述

CPM 模型是由张政彦、韩旭、周浩、柯培、顾宇贤、叶德明、秦宇佳、苏玉生、季浩哲、关健、齐凡超、王晓智、郑亚楠、曾国阳、曹焕琦、陈胜奇、李代轩、孙振波、刘知远、黄民烈、韩文涛、唐杰、李娟姿、朱小燕、孙茂松在CPM: A Large-scale Generative Chinese Pre-trained Language Model中提出的。

论文摘要如下：

预训练语言模型（PLMs）已被证明对各种下游 NLP 任务有益。最近，拥有 1750 亿参数和 570GB 训练数据的 GPT-3 因其少样本（甚至零样本）学习能力而引起了很多关注。然而，将 GPT-3 应用于解决中文 NLP 任务仍然具有挑战性，因为 GPT-3 的训练语料主要是英文，参数也不是公开的。在这份技术报告中，我们发布了在大规模中文训练数据上进行生成式预训练的中文预训练语言模型（CPM）。据我们所知，CPM 拥有 26 亿参数和 100GB 中文训练数据，是目前最大的中文预训练语言模型，可以促进多个下游中文 NLP 任务，如对话、文章生成、填空测试和语言理解。大量实验证明，CPM 在少样本（甚至零样本）学习的情况下在许多 NLP 任务上取得了强大的性能。

该模型由canwenxu贡献。原始实现可在此处找到：github.com/TsinghuaAI/CPM-Generate

CPM 的架构与 GPT-2 相同，除了分词方法。有关 API 参考信息，请参阅 GPT-2 文档。

CpmTokenizer

`class transformers.CpmTokenizer`

( vocab_file do_lower_case = False remove_space = True keep_accents = False bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' sep_token = '<sep>' pad_token = '<pad>' cls_token = '<cls>' mask_token = '<mask>' additional_special_tokens = ['<eop>', '<eod>'] sp_model_kwargs: Optional = None **kwargs )

使用结巴分词工具进行预分词。用于 CPM 模型。

`build_inputs_with_special_tokens`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

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>

`convert_tokens_to_string`

( tokens )

将一系列标记（子词的字符串）转换为单个字符串。

`create_token_type_ids_from_sequences`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], 可选) — 第二个序列对应的 ID 列表（可选）。

List[int]

根据给定序列的 token 类型 ID 列表。

从传递的两个序列创建一个掩码，用于在序列对分类任务中使用。一个 XLNet

序列对掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，则此方法仅返回掩码的第一部分（0）。

`get_special_tokens_mask`

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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方法添加特殊标记时，将调用此方法。

CpmTokenizerFast

`class transformers.CpmTokenizerFast`

( vocab_file = None tokenizer_file = None do_lower_case = False remove_space = True keep_accents = False bos_token = '<s>' eos_token = '</s>' unk_token = '<unk>' sep_token = '<sep>' pad_token = '<pad>' cls_token = '<cls>' mask_token = '<mask>' additional_special_tokens = ['<eop>', '<eod>'] **kwargs )

使用结巴分词工具进行预分词。用于 CPM 模型。

`build_inputs_with_special_tokens`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

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 token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], 可选) — 序列对的可选第二个 ID 列表。

List[int]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 XLNet

序列对掩码具有以下格式：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 是 None，则此方法仅返回掩码的第一部分（0s）。

CPMAnt

原始文本：huggingface.co/docs/transformers/v4.37.2/en/model_doc/cpmant

概述

CPM-Ant 是一个拥有 10B 参数的开源中文预训练语言模型（PLM）。它也是 CPM-Live 实时训练过程的第一个里程碑。训练过程具有成本效益且环保。CPM-Ant 在 CUGE 基准测试中通过增量调整取得了令人满意的结果。除了完整模型，我们还提供各种压缩版本以满足不同硬件配置的要求。查看更多

该模型由OpenBMB贡献。原始代码可在此处找到。

资源

一个关于CPM-Live的教程。

CpmAntConfig

`class transformers.CpmAntConfig`

( vocab_size: int = 30720 hidden_size: int = 4096 num_attention_heads: int = 32 dim_head: int = 128 dim_ff: int = 10240 num_hidden_layers: int = 48 dropout_p: int = 0.0 position_bias_num_buckets: int = 512 position_bias_max_distance: int = 2048 eps: int = 1e-06 init_std: float = 1.0 prompt_types: int = 32 prompt_length: int = 32 segment_types: int = 32 use_cache: bool = True **kwargs )

参数

vocab_size (int, 可选, 默认为 30720) — CPMAnt 模型的词汇量。定义调用 CpmAntModel 时传递的input中可以表示的不同标记数量。
hidden_size (int, 可选, 默认为 4096) — 编码器层的维度。
num_attention_heads (int, 可选, 默认为 32) — Transformer 编码器中的注意力头数。
dim_head (int, 可选, 默认为 128) — Transformer 编码器中每个注意力层的注意力头维度。
dim_ff (int, 可选, 默认为 10240) — Transformer 编码器中“中间”（即前馈）层的维度。
num_hidden_layers (int, 可选, 默认为 48) — Transformer 编码器的层数。
dropout_p (float, 可选, 默认为 0.0) — 嵌入层、编码器中所有全连接层的 dropout 概率。
position_bias_num_buckets (int, 可选, 默认为 512) — 位置偏置桶的数量。
position_bias_max_distance (int, 可选, 默认为 2048) — 该模型可能被使用的最大序列长度。通常设置为一个较大的值以防万一（例如 512、1024 或 2048）。
eps (float, 可选, 默认为 1e-06) — 层归一化层使用的 epsilon。
init_std (float, 可选, 默认为 1.0) — 使用 std = init_std 初始化参数。
prompt_types (int, 可选, 默认为 32) — 提示类型。
prompt_length (int, 可选, 默认为 32) — 提示的长度。
segment_types (int, 可选, 默认为 32) — 分段类型。
use_cache (bool, 可选, 默认为True) — 是否使用缓存。

这是一个配置类，用于存储 CpmAntModel 的配置。根据指定的参数实例化一个 CPMAnt 模型，定义模型架构。使用默认值实例化配置将产生类似于 CPMAnt openbmb/cpm-ant-10b架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import CpmAntModel, CpmAntConfig

>>> # Initializing a CPMAnt cpm-ant-10b style configuration
>>> configuration = CpmAntConfig()

>>> # Initializing a model from the cpm-ant-10b style configuration
>>> model = CpmAntModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

CpmAntTokenizer

`class transformers.CpmAntTokenizer`

( vocab_file bod_token = '<d>' eod_token = '</d>' bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' unk_token = '<unk>' line_token = '</n>' space_token = '</_>' padding_side = 'left' **kwargs )

参数

vocab_file (str) — 词汇文件的路径。
bod_token（str，可选，默认为"<d>"）— 文档起始标记。
eod_token（str，可选，默认为"</d>"）— 文档结束标记。
bos_token（str，可选，默认为"<s>"）— 序列起始标记。
eos_token（str，可选，默认为"</s>"）— 序列结束标记。
pad_token（str，可选，默认为"<pad>"）— 用于填充的标记。
unk_token（str，可选，默认为"<unk>"）— 未知标记。
line_token（str，可选，默认为"</n>"）— 行标记。
space_token（str，可选，默认为"</_>"）— 空格标记。

构建一个 CPMAnt 分词器。基于字节级字节对编码。

`build_inputs_with_special_tokens`

( token_ids_0: List token_ids_1: List = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0（List[int]）— 将添加特殊标记的第一个标记化序列。
token_ids_1（List[int]）— 将添加特殊标记的可选第二个标记化序列。

List[int]

带有特殊标记的模型输入。

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

单个序列：[BOS] Sequence。

`get_special_tokens_mask`

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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方法添加特殊标记时调用此方法。

CpmAntModel

`class transformers.CpmAntModel`

( config: CpmAntConfig )

裸 CPMAnt 模型输出原始隐藏状态，没有特定的头部。此模型是 PyTorch torch.nn.Module子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般用法和行为的所有信息。

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

`forward`

( input_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None past_key_values: Optional = None use_cache: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids（形状为(batch_size, seq_len)的torch.Tensor）— 词汇表中输入序列标记的索引。

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

什么是输入 ID？
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或者当config.use_cache=True时返回） — 包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。
use_cache（bool，可选） — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。
output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。
return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或者tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或者一个torch.FloatTensor的元组（如果传递了return_dict=False或者当config.return_dict=False时），包括各种元素，取决于配置（CpmAntConfig）和输入。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor） — 模型最后一层的隐藏状态序列。

如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或者当config.use_cache=True时返回） — 长度为config.n_layers的元组tuple(torch.FloatTensor)，每个元组有 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，则包含交叉注意力块中的键和值），可用于加速顺序解码。
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 后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, CpmAntModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("openbmb/cpm-ant-10b")
>>> model = CpmAntModel.from_pretrained("openbmb/cpm-ant-10b")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

CpmAntForCausalLM

`class transformers.CpmAntForCausalLM`

( config: CpmAntConfig )

CPMAnt 模型在顶部带有语言建模头（线性层，其权重与输入嵌入绑定）。

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

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

`forward`

( input_ids: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None attention_mask: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

input_ids（形状为（batch_size，seq_len）的torch.Tensor） - 词汇表中输入序列标记的索引。

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

什么是输入 ID？
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） - 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。
use_cache（bool，可选） - 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
output_attentions（bool，可选） - 是否返回所有注意力层的注意力张量。
output_hidden_states（bool，可选） - 是否返回所有层的隐藏状态。
return_dict（bool，可选） - 是否返回 ModelOutput 而不是普通元组。

参数 - 输入 ID（形状为（batch_size，seq_len）的torch.Tensor）：词汇表中输入序列标记的索引。

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

什么是输入 ID？ past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回：包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。 use_cache (bool, optional): 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 output_attentions (bool, optional): 是否返回所有注意力层的注意力张量。 output_hidden_states (bool, optional): 是否返回所有层的隐藏状态。 labels (torch.Tensor，形状为(batch_size, sequence_length)，optional): 用于计算掩码语言建模损失的标签。 return_dict (bool，optional): 是否返回 ModelOutput 而不是普通元组。 attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，optional): CPMAnt 将自动处理注意力掩码，此参数是文本生成流水线的虚拟参数。

示例 —
使用 CpmAntForCausalLM 进行文本生成。 —

transformers.modeling_outputs.CausalLMOutputWithPast 或torch.FloatTensor元组。

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False）包含根据配置（CpmAntConfig）和输入的不同元素。

loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。

包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。

模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, CpmAntForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("openbmb/cpm-ant-10b")
>>> model = CpmAntForCausalLM.from_pretrained("openbmb/cpm-ant-10b")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> loss = outputs.loss
>>> logits = outputs.logits

CTRL

原文链接: huggingface.co/docs/transformers/v4.37.2/en/model_doc/ctrl

概述

CTRL 模型是由 Nitish Shirish Keskar, Bryan McCann, Lav R. Varshney, Caiming Xiong 和 Richard Socher 在CTRL: A Conditional Transformer Language Model for Controllable Generation中提出的。它是一个因果(单向)变压器，使用语言建模在一个约 140GB 的文本数据语料库上进行预训练，第一个标记保留为控制代码(如链接、书籍、维基百科等)。

论文摘要如下:

大规模语言模型展示了有希望的文本生成能力，但用户无法轻松控制生成文本的特定方面。我们发布了 CTRL，一个拥有 16.3 亿参数的条件变压器语言模型，训练以控制代码为条件，控制风格、内容和任务特定行为。控制代码源自与原始文本自然共现的结构，保留了无监督学习的优势，同时提供了对文本生成更明确的控制。这些代码还允许 CTRL 预测在给定序列的情况下训练数据的哪些部分最有可能。这提供了一种通过基于模型的源归因来分析大量数据的潜在方法。

这个模型由keskarnitishr贡献。原始代码可以在这里找到。

使用提示

CTRL 使用控制代码生成文本: 它要求以某些单词、句子或链接开始生成连贯的文本。有关更多信息，请参考原始实现。
CTRL 是一个带有绝对位置嵌入的模型，因此通常建议在右侧而不是左侧填充输入。
CTRL 是通过因果语言建模(CLM)目标进行训练的，因此在预测序列中的下一个标记方面非常强大。利用这一特性使 CTRL 能够生成句法连贯的文本，正如在run_generation.py示例脚本中所观察到的那样。
PyTorch 模型可以将past_key_values作为输入，这是先前计算的键/值注意力对。TensorFlow 模型接受past作为输入。使用past_key_values值可以防止模型在文本生成的上下文中重新计算预先计算的值。有关此参数的使用更多信息，请参见forward方法。

资源

文本分类任务指南
因果语言建模任务指南

CTRLConfig

`class transformers.CTRLConfig`

( vocab_size = 246534 n_positions = 256 n_embd = 1280 dff = 8192 n_layer = 48 n_head = 16 resid_pdrop = 0.1 embd_pdrop = 0.1 layer_norm_epsilon = 1e-06 initializer_range = 0.02 use_cache = True **kwargs )

参数

vocab_size (int, 可选, 默认为 246534) — CTRL 模型的词汇量。定义了在调用 CTRLModel 或 TFCTRLModel 时可以由inputs_ids表示的不同标记数量。
n_positions (int, 可选, 默认为 256) — 此模型可能会使用的最大序列长度。通常将其设置为较大的值以防万一(例如 512、1024 或 2048)。
n_embd (int, 可选, 默认为 1280) — 嵌入和隐藏状态的维度。
dff (int, 可选, 默认为 8192) — 前馈网络(FFN)内部维度的维度。
n_layer (int, optional, 默认为 48) — Transformer 编码器中的隐藏层数。
n_head (int, optional, 默认为 16) — Transformer 编码器中每个注意力层的注意力头数。
resid_pdrop (float, optional, 默认为 0.1) — 嵌入层、编码器和池化器中所有全连接层的丢失概率。
embd_pdrop (int, optional, 默认为 0.1) — 用于嵌入的丢失比率。
layer_norm_epsilon (float, optional, 默认为 1e-06) — 在层归一化层中使用的 epsilon
initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
use_cache (bool, optional, 默认为True) — 模型是否应返回最后的键/值注意力（并非所有模型都使用）。

这是用于存储 CTRLModel 或 TFCTRLModel 配置的配置类。它用于根据指定的参数实例化 CTRL 模型，定义模型架构。使用默认值实例化配置将产生与 SalesForce 的Salesforce/ctrl架构类似的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import CTRLConfig, CTRLModel

>>> # Initializing a CTRL configuration
>>> configuration = CTRLConfig()

>>> # Initializing a model (with random weights) from the configuration
>>> model = CTRLModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

CTRLTokenizer

`class transformers.CTRLTokenizer`

( vocab_file merges_file unk_token = '<unk>' **kwargs )

参数

vocab_file (str) — 词汇文件的路径。
merges_file (str) — 合并文件的路径。
unk_token (str, optional, 默认为"<unk>") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。

构建一个 CTRL 分词器。基于字节对编码。

这个分词器继承自 PreTrainedTokenizer，其中包含大多数主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

`save_vocabulary`

( save_directory: str filename_prefix: Optional = None )

PytorchHide Pytorch content

CTRLModel

`class transformers.CTRLModel`

( config )

参数

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

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

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

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

`forward`

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

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length=sequence_length，否则past_key_values[0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。

如果使用了past_key_values，则只应将未计算其过去的输入 ID 作为input_ids传递。

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

什么是输入 ID？
past_key_values（长度为config.n_layers的Tuple[Tuple[torch.FloatTensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的past_key_values输出）。可用于加速顺序解码。已经计算过其过去的input_ids不应作为输入 ID 传递给此模型。
attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]之间：
- 1 表示未被masked的标记，
- 0 表示被masked的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 指示输入的第一部分和第二部分的段标记索引。选择的索引在[0, 1]中：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
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]之间：
- 1 表示头部未被masked，
- 0 表示头部被masked。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor，可选）— 可选地，您可以选择直接传递嵌入表示而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
use_cache（bool，可选）— 如果设置为True，则返回past_key_values关键值状态，并可用于加速解码（请参阅past_key_values）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的attentions。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的hidden_states。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。

transformers.modeling_outputs.BaseModelOutputWithPast 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPast 或一个torch.FloatTensor元组（如果传递return_dict=False或config.return_dict=False时）包含根据配置（CTRLConfig）和输入不同元素。

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）-模型最后一层的隐藏状态序列输出。

如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)序列的最后一个隐藏状态。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）-长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 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，可以使用的）（请参见past_key_values输入）以加速顺序解码。
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 之后，用于计算自注意力头中的加权平均值。

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

示例：

>>> from transformers import AutoTokenizer, CTRLModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
>>> model = CTRLModel.from_pretrained("Salesforce/ctrl")

>>> # CTRL was trained with control codes as the first token
>>> inputs = tokenizer("Opinion My dog is cute", return_tensors="pt")
>>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()

>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state
>>> list(last_hidden_states.shape)
[1, 5, 1280]

CTRLLMHeadModel

`class transformers.CTRLLMHeadModel`

( config )

参数

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

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

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

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

`forward`

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

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 如果 past_key_values 为 None，则 input_ids_length = sequence_length，否则为 past_key_values[0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。

如果使用了 past_key_values，则只应将未计算其过去的输入 ID 作为 input_ids 传递。

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

什么是 input IDs?
past_key_values (Tuple[Tuple[torch.FloatTensor]] of length config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参见下面的 past_key_values 输出）。可用于加速顺序解码。已给出其过去的 input_ids 不应作为输入 ID 传递给此模型，因为它们已经计算过。
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
- 1 表示 not masked 的标记，
- 0 表示 masked 的标记。
什么是 attention masks?
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1]：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是 token type IDs?
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。

什么是 position IDs?
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在 [0, 1]：
- 1 表示头部是 not masked，
- 0 表示头部是 masked。
inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，您可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
use_cache (bool, optional) — 如果设置为 True，则返回 past_key_values 键值状态，并可用于加速解码（请参见 past_key_values）。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 语言建模的标签。注意标签在模型内部被移动，即可以设置labels = input_ids。索引在[-100, 0, ..., config.vocab_size]中选择。所有设置为-100的标签都被忽略（掩码），损失仅计算标签在[0, ..., config.vocab_size]中的标签。

transformers.modeling_outputs.CausalLMOutputWithPast 或者tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.CausalLMOutputWithPast 或者一个torch.FloatTensor元组（如果传递了return_dict=False或者当config.return_dict=False时）包括根据配置（CTRLConfig）和输入的不同元素。

loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 语言建模损失（用于下一个标记预测）。
logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或者当config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。

包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。
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 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> import torch
>>> from transformers import AutoTokenizer, CTRLLMHeadModel

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
>>> model = CTRLLMHeadModel.from_pretrained("Salesforce/ctrl")

>>> # CTRL was trained with control codes as the first token
>>> inputs = tokenizer("Wikipedia The llama is", return_tensors="pt")
>>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()

>>> sequence_ids = model.generate(inputs["input_ids"])
>>> sequences = tokenizer.batch_decode(sequence_ids)
>>> sequences
['Wikipedia The llama is a member of the family Bovidae. It is native to the Andes of Peru,']

>>> outputs = model(**inputs, labels=inputs["input_ids"])
>>> round(outputs.loss.item(), 2)
9.21

>>> list(outputs.logits.shape)
[1, 5, 246534]

CTRLForSequenceClassification

`class transformers.CTRLForSequenceClassification`

( config )

参数

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

带有顶部序列分类头（线性层）的 CTRL 模型变压器。CTRLForSequenceClassification 使用最后一个标记来进行分类，就像其他因果模型（例如 GPT-2）一样。由于它在最后一个标记上进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了 pad_token_id，则找到每行中不是填充标记的最后一个标记。如果没有定义 pad_token_id，则简单地取批处理中每行的最后一个值。由于在传递 inputs_embeds 而不是 input_ids 时无法猜测填充标记，因此它执行相同操作（取批处理中每行的最后一个值）。

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

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

`forward`

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

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — input_ids_length = sequence_length 如果 past_key_values 是 None，否则 past_key_values[0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。

如果使用了 past_key_values，则只能传递那些没有计算过其过去的输入 ID 作为 input_ids。

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

什么是输入 ID？
past_key_values (Tuple[Tuple[torch.FloatTensor]]，长度为 config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值），如下面的 past_key_values 输出所示。可用于加速顺序解码。将其过去传递给该模型的 input_ids 不应作为输入 ID 传递，因为它们已经计算过。
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
- 1 表示标记是 未掩盖的，
- 0 表示标记是 被掩盖的。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1]：
- 0 对应于一个 句子 A 的标记，
- 1 对应于一个 句子 B 的标记。
什么是标记类型 ID？
position_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为 [0, config.max_position_embeddings - 1]。

什么是位置 ID？
head_mask (torch.FloatTensor，形状为 (num_heads,) 或 (num_layers, num_heads)，可选) — 用于使自注意力模块中的特定头部失效的掩码。掩码值选择在 [0, 1]：
- 1 表示头部是 未掩盖的，
- 0 表示头部是 被掩盖的。
inputs_embeds (torch.FloatTensor，形状为 (batch_size, sequence_length, hidden_size)，optional) — 可选地，可以直接传递嵌入表示而不是传递 input_ids。如果您想要更多控制如何将 input_ids 索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
use_cache (bool，optional) — 如果设置为 True，则返回 past_key_values 键值状态，可用于加速解码（参见 past_key_values）。
output_attentions (bool，optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回的张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor，形状为 (batch_size,)，optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 元组（如果传递 return_dict=False 或 config.return_dict=False）包含各种元素，具体取决于配置（CTRLConfig）和输入。

loss (torch.FloatTensor，形状为 (1,)，optional，当提供 labels 时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
logits (torch.FloatTensor，形状为 (batch_size, config.num_labels)) — 分类（如果 config.num_labels==1 则为回归）分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor)，optional，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回） — 形状为 (batch_size, sequence_length, hidden_size) 的 torch.FloatTensor 元组（如果模型具有嵌入层，则为嵌入的输出 + 每层的输出）。

模型在每层输出的隐藏状态加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor)，optional，当传递 output_attentions=True 或 config.output_attentions=True 时返回） — 形状为 (batch_size, num_heads, sequence_length, sequence_length) 的 torch.FloatTensor 元组（每层一个）。

注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, CTRLForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
>>> model = CTRLForSequenceClassification.from_pretrained("Salesforce/ctrl")

>>> # CTRL was trained with control codes as the first token
>>> inputs = tokenizer("Opinion My dog is cute", return_tensors="pt")
>>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'LABEL_0'

>>> import torch

>>> torch.manual_seed(42)
>>> # 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 = CTRLForSequenceClassification.from_pretrained("Salesforce/ctrl", num_labels=num_labels)

>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
0.35

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, CTRLForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
>>> model = CTRLForSequenceClassification.from_pretrained(
...     "Salesforce/ctrl", problem_type="multi_label_classification"
... )

>>> # CTRL was trained with control codes as the first token
>>> inputs = tokenizer("Opinion My dog is cute", return_tensors="pt")
>>> assert inputs["input_ids"][0, 0].item() in tokenizer.control_codes.values()

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'LABEL_0'

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CTRLForSequenceClassification.from_pretrained("Salesforce/ctrl", num_labels=num_labels)

>>> num_labels = len(model.config.id2label)
>>> labels = torch.nn.functional.one_hot(torch.tensor([predicted_class_id]), num_classes=num_labels).to(
...     torch.float
... )
>>> loss = model(**inputs, labels=labels).loss
>>> loss.backward()

TensorFlowHide TensorFlow 内容

TFCTRLModel

`class transformers.TFCTRLModel`

( config *inputs **kwargs )

参数

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

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

此模型继承自 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 past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = 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 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.TFBaseModelOutputWithPast or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, input_ids_length)的Numpy数组或tf.Tensor） — input_ids_length = sequence_length，如果past为None，则为past[0].shape[-2]（输入过去键值状态的序列长度）。

输入序列标记在词汇表中的索引。

如果使用past，则只能将未计算其过去的输入 ID 作为input_ids传递。

可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()获取详细信息。

什么是输入 ID？
past（长度为config.n_layers的List[tf.Tensor]） — 包含由模型计算的预先计算的隐藏状态（注意块中的键和值），如下面的past输出所示。可用于加速顺序解码。已经计算过其过去的令牌 ID 不应作为输入 ID 传递给此模型。
attention_mask（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
- 1 表示未被masked的标记，
- 0 表示被masked的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A的标记，
- 1 对应于句子 B的标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未被masked，
- 0 表示头部被masked。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor或Numpy array，可选）— 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
use_cache（bool，可选）— 如果设置为True，则返回past键值状态，并可用于加速解码（参见past）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。此参数仅可在急切模式下使用，在图模式中将使用配置中的值。
return_dict（bool，可选）— 是否返回 ModelOutput 而不是普通元组。此参数可在急切模式下使用，在图模式中该值将始终设置为 True。
training（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块，如 dropout 模块，在训练和评估之间具有不同的行为）。

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

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

last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。

如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。
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 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFCTRLModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
>>> model = TFCTRLModel.from_pretrained("Salesforce/ctrl")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFCTRLLMHeadModel

`class transformers.TFCTRLLMHeadModel`

( config *inputs **kwargs )

参数

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

带有语言建模头的 CTRL 模型变压器（线性层，其权重与输入嵌入绑定）。

此模型继承自 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 past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = 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 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutputWithPast or tuple(tf.Tensor)

参数

input_ids（形状为(batch_size, input_ids_length)的Numpy array或tf.Tensor）- 如果past为None，则input_ids_length = sequence_length，否则为past[0].shape[-2]（输入过去键值状态的sequence_length）。

词汇表中输入序列令牌的索引。

如果使用past，则只能将未计算其过去的输入 ID 作为input_ids传递。

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

什么是输入 ID？
past（长度为config.n_layers的List[tf.Tensor]）- 包含由模型计算的预先计算的隐藏状态（注意力块中的键和值），如模型计算的past输出所示。可用于加速顺序解码。已经计算过其过去的令牌 ID 不应作为输入 ID 传递给此模型。
attention_mask（tf.Tensor或形状为(batch_size, sequence_length)的Numpy array，可选）- 用于避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：
- 1 表示未被掩盖的令牌，
- 0 表示被掩盖的令牌。
什么是注意力掩码？
token_type_ids（tf.Tensor或形状为(batch_size, sequence_length)的Numpy array，可选）- 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于一个句子 A的标记，
- 1 对应于一个句子 B的标记。
什么是令牌类型 ID？
position_ids（tf.Tensor或形状为(batch_size, sequence_length)的Numpy array，可选）- 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）- 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未被掩盖，
- 0 表示头部被掩盖。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor或Numpy array，可选）- 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您希望更多地控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
use_cache（bool，可选）- 如果设置为True，则返回past键值状态，并可用于加速解码（参见past）。
output_attentions（bool，可选）- 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states（bool，可选）- 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict (bool, optional) — 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
training (bool, optional, 默认为False) — 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
labels (tf.Tensor of shape (batch_size, sequence_length), optional) — 用于计算交叉熵分类损失的标签。索引应在[0, ..., config.vocab_size - 1]范围内。

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

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

loss (tf.Tensor of shape (n,), optional, 当提供labels时返回，其中 n 是未屏蔽标签的数量) — 语言建模损失（用于下一个标记的预测）。
logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
past_key_values (List[tf.Tensor], optional, 当传递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), 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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFCTRLLMHeadModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
>>> model = TFCTRLLMHeadModel.from_pretrained("Salesforce/ctrl")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)
>>> logits = outputs.logits

TFCTRLForSequenceClassification

`class transformers.TFCTRLForSequenceClassification`

( config *inputs **kwargs )

参数

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

带有顶部序列分类头（线性层）的 CTRL 模型变换器。

TFCTRLForSequenceClassification 使用最后一个标记进行分类，就像其他因果模型（例如 GPT-1，GPT-2）一样。

由于它对最后一个标记进行分类，因此需要知道最后一个标记的位置。如果在配置中定义了 pad_token_id，则会找到每行中不是填充标记的最后一个标记。如果没有定义 pad_token_id，则会简单地取每行批次的最后一个值。由于在传递 inputs_embeds 而不是 input_ids 时无法猜测填充标记，因此会执行相同操作（取每行批次的最后一个值）。

这个模型继承自 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 past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = 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 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 ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

input_ids（形状为 (batch_size, input_ids_length) 的 Numpy 数组或 tf.Tensor）— input_ids_length = sequence_length（如果 past 为 None）否则为 past[0].shape[-2]（输入过去键值状态的序列长度）。

词汇表中输入序列标记的索引。

如果使用了 past，则只有那些尚未计算其过去的输入 ID 应作为 input_ids 传递。

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

什么是输入 ID？
past（长度为config.n_layers的List[tf.Tensor]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。已将其过去给予此模型的标记 ID 不应作为输入 ID 传递，因为它们已经计算过。
attention_mask（形状为(batch_size, sequence_length)的tf.Tensor或Numpy 数组，可选）— 避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：
- 对于未屏蔽的标记，
- 0 表示屏蔽的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy 数组，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy 数组，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
head_mask（形状为(num_heads,)或(num_layers, num_heads)的torch.FloatTensor，可选）— 用于使自注意力模块的选定头部失效的掩码。掩码值在[0, 1]中选择：
- 1 表示头部未屏蔽，
- 0 表示头部被屏蔽。
inputs_embeds（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor或Numpy 数组，可选）— 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
use_cache（bool，可选）— 如果设置为True，则返回past键值状态，并可用于加速解码（参见past）。
output_attentions（bool，可选）— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
output_hidden_states（bool，可选）— 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。此参数仅在急切模式下使用，在图模式下将使用配置中的值。
return_dict（bool，可选）— 是否返回一个 ModelOutput 而不是一个普通元组。此参数可以在急切模式下使用，在图模式下该值将始终设置为 True。
训练（bool，可选，默认为False）— 是否在训练模式下使用模型（一些模块如 dropout 模块在训练和评估之间有不同的行为）。
标签（形状为(batch_size, sequence_length)的tf.Tensor，可选）— 用于计算交叉熵分类损失的标签。索引应在[0, ..., config.vocab_size - 1]内。

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, TFCTRLForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("Salesforce/ctrl")
>>> model = TFCTRLForSequenceClassification.from_pretrained("Salesforce/ctrl")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFCTRLForSequenceClassification.from_pretrained("Salesforce/ctrl", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

DeBERTa

原文：huggingface.co/docs/transformers/v4.37.2/en/model_doc/deberta

概述

DeBERTa 模型是由何鹏程、刘晓东、高建峰、陈伟柱在DeBERTa: 具有解耦注意力的解码增强 BERT中提出的，基于 2018 年发布的 Google 的 BERT 模型和 2019 年发布的 Facebook 的 RoBERTa 模型。

它在 RoBERTa 的基础上使用解耦注意力和增强的掩码解码器训练，使用 RoBERTa 一半的数据。

论文摘要如下：

最近，在预训练神经语言模型方面取得了显著进展，大大提高了许多自然语言处理（NLP）任务的性能。在本文中，我们提出了一种新的模型架构 DeBERTa（具有解耦注意力的解码增强 BERT），利用两种新技术改进了 BERT 和 RoBERTa 模型。第一种是解耦注意力机制，其中每个单词使用两个向量表示，分别编码其内容和位置，单词之间的注意力权重是通过解耦矩阵在它们的内容和相对位置上计算的。其次，使用增强的掩码解码器来替换输出 softmax 层，以预测模型预训练的掩码标记。我们展示了这两种技术显著提高了模型预训练的效率和下游任务的性能。与 RoBERTa-Large 相比，DeBERTa 模型在一半训练数据上训练，对各种 NLP 任务表现出更好的一致性，MNLI 提高了+0.9%（90.2% vs. 91.1%），SQuAD v2.0 提高了+2.3%（88.4% vs. 90.7%），RACE 提高了+3.6%（83.2% vs. 86.8%）。DeBERTa 的代码和预训练模型将在github.com/microsoft/DeBERTa上公开提供。

这个模型是由DeBERTa贡献的。这个模型 TF 2.0 实现是由kamalkraj贡献的。原始代码可以在这里找到。

资源

列出了官方 Hugging Face 和社区（由🌎表示）资源的清单，以帮助您开始使用 DeBERTa。如果您有兴趣提交资源以包含在此处，请随时打开一个 Pull Request，我们将进行审查！资源最好展示一些新内容，而不是重复现有资源。

文本分类

一篇关于如何使用 DeepSpeed 加速大型模型训练的博客文章，使用 DeBERTa。
一篇关于如何使用机器学习提升客户服务的博客文章，使用 DeBERTa。
DebertaForSequenceClassification 由这个示例脚本和笔记本支持。
TFDebertaForSequenceClassification 由这个示例脚本和笔记本支持。
文本分类任务指南

标记分类

DebertaForTokenClassification 可以通过这个示例脚本和笔记本支持。
TFDebertaForTokenClassification 可以通过这个示例脚本和笔记本支持。
🤗 Hugging Face 课程的 Token classification 章节。
Byte-Pair Encoding tokenization 章节。
Token classification 任务指南

填充-遮蔽

DebertaForMaskedLM 可以通过这个示例脚本和笔记本支持。
TFDebertaForMaskedLM 可以通过这个示例脚本和笔记本支持。
🤗 Hugging Face 课程的 Masked language modeling 章节。
遮蔽语言建模任务指南

问答

DebertaForQuestionAnswering 可以通过这个示例脚本和笔记本支持。
TFDebertaForQuestionAnswering 可以通过这个示例脚本和笔记本支持。
🤗 Hugging Face 课程的问答章节。
问答任务指南

DebertaConfig

`class transformers.DebertaConfig`

( vocab_size = 50265 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 512 type_vocab_size = 0 initializer_range = 0.02 layer_norm_eps = 1e-07 relative_attention = False max_relative_positions = -1 pad_token_id = 0 position_biased_input = True pos_att_type = None pooler_dropout = 0 pooler_hidden_act = 'gelu' **kwargs )

参数

vocab_size (int, 可选, 默认为 30522) — DeBERTa 模型的词汇表大小。定义了在调用 DebertaModel 或 TFDebertaModel 时可以表示的不同 token 数量。
hidden_size (int, 可选, 默认为 768) — 编码器层和池化层的维度。
num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
intermediate_size (int, optional, defaults to 3072) — Transformer 编码器中“中间”（通常称为前馈）层的维度。
hidden_act (str or Callable, optional, defaults to "gelu") — 编码器和池化器中的非线性激活函数（函数或字符串）。如果是字符串，支持"gelu"、"relu"、"silu"、"gelu"、"tanh"、"gelu_fast"、"mish"、"linear"、"sigmoid"和"gelu_new"。
hidden_dropout_prob (float, optional, defaults to 0.1) — 嵌入层、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, optional, defaults to 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, optional, defaults to 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一（例如，512 或 1024 或 2048）。
type_vocab_size (int, optional, defaults to 2) — 在调用 DebertaModel 或 TFDebertaModel 时传递的token_type_ids的词汇表大小。
initializer_range (float, optional, defaults to 0.02) — 用于初始化所有权重矩阵的截断正态初始化器的标准差。
layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。
relative_attention (bool, optional, defaults to False) — 是否使用相对位置编码。
max_relative_positions (int, optional, defaults to 1) — 相对位置范围[-max_position_embeddings, max_position_embeddings]。使用与max_position_embeddings相同的值。
pad_token_id (int, optional, defaults to 0) — 用于填充 input_ids 的值。
position_biased_input (bool, optional, defaults to True) — 是否将绝对位置嵌入添加到内容嵌入中。
pos_att_type (List[str], optional) — 相对位置注意力的类型，可以是["p2c", "c2p"]的组合，例如["p2c"]、["p2c", "c2p"]。
layer_norm_eps (float, optional, defaults to 1e-12) — 层归一化层使用的 epsilon。

这是用于存储 DebertaModel 或 TFDebertaModel 配置的配置类。它用于根据指定的参数实例化一个 DeBERTa 模型，定义模型架构。使用默认值实例化配置将产生类似于 DeBERTa microsoft/deberta-base架构的配置。

配置对象继承自 PretrainedConfig，可用于控制模型输出。阅读 PretrainedConfig 的文档以获取更多信息。

示例：

>>> from transformers import DebertaConfig, DebertaModel

>>> # Initializing a DeBERTa microsoft/deberta-base style configuration
>>> configuration = DebertaConfig()

>>> # Initializing a model (with random weights) from the microsoft/deberta-base style configuration
>>> model = DebertaModel(configuration)

>>> # Accessing the model configuration
>>> configuration = model.config

DebertaTokenizer

`class transformers.DebertaTokenizer`

( vocab_file merges_file errors = 'replace' bos_token = '[CLS]' eos_token = '[SEP]' sep_token = '[SEP]' cls_token = '[CLS]' unk_token = '[UNK]' pad_token = '[PAD]' mask_token = '[MASK]' add_prefix_space = False add_bos_token = False **kwargs )

参数

vocab_file (str) — 词汇表文件的路径。
merges_file (str) — 合并文件的路径。
errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅bytes.decode。
bos_token (str, optional, defaults to "[CLS]") — 序列开始标记。
eos_token (str, optional, defaults to "[SEP]") — 序列结束标记。
sep_token (str, 可选, 默认为 "[SEP]") — 用于从多个序列构建序列时使用的分隔符标记，例如用于序列分类的两个序列或用于文本和问题的问题回答。它也用作使用特殊标记构建的序列的最后一个标记。
cls_token (str, 可选, 默认为 "[CLS]") — 用于序列分类时使用的分类器标记（对整个序列进行分类，而不是对每个标记进行分类）。当使用特殊标记构建序列时，它是序列的第一个标记。
unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。词汇表中没有的标记无法转换为 ID，而是设置为此标记。
pad_token (str, 可选, 默认为 "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
mask_token (str, 可选, 默认为 "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
add_prefix_space (bool, 可选, 默认为 False) — 是否在输入前添加一个初始空格。这允许将前导单词视为任何其他单词。（Deberta 分词器通过前面的空格检测单词的开头）。
add_bos_token（bool，optional，默认为False）--是否向输入中添加首字母<|endoftext|>。这样就可以像对待其他单词一样对待前导词。

构建一个 DeBERTa 分词器。基于字节级字节对编码。

这个分词器已经训练过，将空格视为标记的一部分（有点像 sentencepiece），所以一个单词会

在句子开头（无空格）或不在句子开头时，将被编码为不同的方式：

>>> from transformers import DebertaTokenizer

>>> tokenizer = DebertaTokenizer.from_pretrained("microsoft/deberta-base")
>>> tokenizer("Hello world")["input_ids"]
[1, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[1, 20920, 232, 2]

您可以通过在实例化此分词器时或在对某些文本调用它时传递 add_prefix_space=True 来避免这种行为，但由于模型不是以这种方式进行预训练的，可能会导致性能下降。

当与 is_split_into_words=True 一起使用时，此分词器将在每个单词之前添加一个空格（甚至第一个单词）。

这个分词器继承自 PreTrainedTokenizer，其中包含大部分主要方法。用户应参考这个超类以获取有关这些方法的更多信息。

build_inputs_with_special_tokens函数

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — 将添加特殊标记的 ID 列表。
token_ids_1 (List[int], 可选) — 第二个序列的 ID 列表（可选）。

List[int]

带有适当特殊标记的 input IDs 列表。

通过连接和添加特殊标记从序列或序列对构建用于序列分类任务的模型输入。DeBERTa 序列的格式如下：

单个序列：[CLS] X [SEP]
序列对：[CLS] A [SEP] B [SEP]

get_special_tokens_mask函数

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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 或 encode_plus 方法添加特殊标记时，将调用此方法。

create_token_type_ids_from_sequences函数

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], optional) — 序列对的可选第二个 ID 列表。

List[int]

根据给定序列的 token 类型 ID 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。DeBERTa

序列对掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果 token_ids_1 为 None，则此方法仅返回掩码的第一部分（0）。

`save_vocabulary`

( save_directory: str filename_prefix: Optional = None )

DebertaTokenizerFast

`class transformers.DebertaTokenizerFast`

( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '[CLS]' eos_token = '[SEP]' sep_token = '[SEP]' cls_token = '[CLS]' unk_token = '[UNK]' pad_token = '[PAD]' mask_token = '[MASK]' add_prefix_space = False **kwargs )

参数

vocab_file (str, optional) — 词汇文件的路径。
merges_file (str, optional) — 合并文件的路径。
tokenizer_file (str, optional) — 要使用的分词器文件的路径，而不是词汇文件。
errors (str, optional, defaults to "replace") — 解码字节为 UTF-8 时要遵循的范例。有关更多信息，请参阅 bytes.decode。
bos_token (str, optional, defaults to "[CLS]") — 序列开始标记。
eos_token (str, optional, defaults to "[SEP]") — 序列结束标记。
sep_token (str, optional, defaults to "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类的两个序列或用于文本和问题的问题回答。它还用作使用特殊标记构建的序列的最后一个标记。
cls_token (str, optional, defaults to "[CLS]") — 分类器标记，用于进行序列分类（对整个序列进行分类，而不是每个标记进行分类）。在使用特殊标记构建时，它是序列的第一个标记。
unk_token (str, optional, defaults to "[UNK]") — 未知标记。词汇表中不存在的标记无法转换为 ID，而是设置为此标记。
pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
add_prefix_space (bool, optional, defaults to False) — 是否将初始空格添加到输入。这允许将前导单词视为任何其他单词。（Deberta 分词器通过前面的空格检测单词的开头）。

构建一个“快速” DeBERTa 分词器（由 HuggingFace 的 tokenizers 库支持）。基于字节级字节对编码。

此分词器经过训练，将空格视为标记的一部分（有点像 sentencepiece），因此一个单词将

在句子开头（无空格）或不在句子开头时，将被编码为不同的方式：

>>> from transformers import DebertaTokenizerFast

>>> tokenizer = DebertaTokenizerFast.from_pretrained("microsoft/deberta-base")
>>> tokenizer("Hello world")["input_ids"]
[1, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[1, 20920, 232, 2]

您可以通过在实例化此分词器时传递 add_prefix_space=True 来避免该行为，但由于模型不是以这种方式进行预训练的，因此可能会导致性能下降。

当与 is_split_into_words=True 一起使用时，需要使用 add_prefix_space=True 实例化此分词器。

此分词器继承自 PreTrainedTokenizerFast，其中包含大部分主要方法。用户应参考此超类以获取有关这些方法的更多信息。

`build_inputs_with_special_tokens`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — 要添加特殊标记的 ID 列表。
token_ids_1 (List[int], optional) — 可选的第二个序列对应的 ID 列表。

List[int]

具有适当特殊标记的 input IDs 列表。

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

单个序列：[CLS] X [SEP]
序列对：[CLS] A [SEP] B [SEP]

`create_token_type_ids_from_sequences`

( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

token_ids_0 (List[int]) — ID 列表。
token_ids_1 (List[int], optional) — 可选的第二个序列对应的 ID 列表。

List[int]

根据给定序列的 token type IDs 列表。

从传递的两个序列创建一个用于序列对分类任务的掩码。一个 DeBERTa

序列对掩码的格式如下：

0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

如果token_ids_1为None，此方法只返回掩码的第一部分（0s）。

PytorchHide Pytorch 内容

DebertaModel

`class transformers.DebertaModel`

( config )

参数

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

裸的 DeBERTa 模型变压器，输出原始隐藏状态，没有特定的头部。DeBERTa 模型是由 Pengcheng He，Xiaodong Liu，Jianfeng Gao，Weizhu Chen 在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出的，它建立在 BERT/RoBERTa 之上，具有两个改进，即解耦的注意力和增强的掩码解码器。通过这两个改进，它在 80GB 的预训练数据上胜过 BERT/RoBERTa 的大多数任务。

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

forward

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

参数

input_ids (torch.LongTensor，形状为(batch_size, sequence_length)） — 词汇表中输入序列标记的索引。

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

什么是 input IDs?
attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
- 1 表示未被掩码的标记，
- 0 表示被掩码的标记。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，optional) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是 token type IDs?
position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选的) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
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.modeling_outputs.BaseModelOutput 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含各种元素，取决于配置（DebertaConfig）和输入。

last_hidden_state (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态的序列。
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 之后的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, DebertaModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-base")
>>> model = DebertaModel.from_pretrained("microsoft/deberta-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)

>>> last_hidden_states = outputs.last_hidden_state

DebertaPreTrainedModel

`class transformers.DebertaPreTrainedModel`

( config: PretrainedConfig *inputs **kwargs )

一个处理权重初始化和下载和加载预训练模型的简单接口的抽象类。

DebertaForMaskedLM

`class transformers.DebertaForMaskedLM`

( config )

参数

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

在顶部带有语言建模头的 DeBERTa 模型。DeBERTa 模型由何鹏程、刘晓东、高建峰、陈伟铸在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出。它在 BERT/RoBERTa 的基础上进行了两项改进，即解耦注意力和增强掩码解码器。通过这两项改进，它在 80GB 预训练数据上优于 BERT/RoBERTa 的大多数任务。

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

`forward`

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.MaskedLMOutput 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 代表not masked的标记。
- 0 代表masked的标记。
什么是注意力掩码？
token_type_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 段标记索引，指示输入的第一部分和第二部分。索引选择在[0, 1]：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids（torch.LongTensor，形状为(batch_size, sequence_length)，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

什么是位置 ID？
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 of shape (batch_size, sequence_length), 可选的) — 用于计算掩码语言建模损失的标签。索引应在[-100, 0, ..., config.vocab_size]内（参见input_ids文档字符串）。索引设置为-100的标记将被忽略（掩码），损失仅计算具有标签在[0, ..., config.vocab_size]中的标记。

transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MaskedLMOutput 或一个torch.FloatTensor元组（如果传递return_dict=False或当config.return_dict=False时）包含各种元素，取决于配置（DebertaConfig）和输入。

loss (torch.FloatTensor of shape (1,), 可选的，当提供labels时返回) — 掩码语言建模（MLM）损失。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, DebertaForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("lsanochkin/deberta-large-feedback")
>>> model = DebertaForMaskedLM.from_pretrained("lsanochkin/deberta-large-feedback")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> # retrieve index of [MASK]
>>> mask_token_index = (inputs.input_ids == tokenizer.mask_token_id)[0].nonzero(as_tuple=True)[0]

>>> predicted_token_id = logits[0, mask_token_index].argmax(axis=-1)
>>> tokenizer.decode(predicted_token_id)
' Paris'

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-[MASK] tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
0.54

DebertaForSequenceClassification

`class transformers.DebertaForSequenceClassification`

( config )

参数

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

DeBERTa 模型变换器，顶部带有序列分类/回归头（池化输出顶部的线性层），例如用于 GLUE 任务。

DeBERTa 模型是由 Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen 在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出的。它是在 BERT/RoBERTa 的基础上进行了两项改进，即解缠注意力和增强掩码解码器。通过这两项改进，它在 80GB 预训练数据上的大多数任务中表现优于 BERT/RoBERTa。

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

`forward`

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: Optional = None inputs_embeds: Optional = None labels: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.modeling_outputs.SequenceClassifierOutput 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]范围内：
- 对于未被“masked”掉的标记为 1，
- 对于被masked掉的标记。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]范围内选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。

什么是位置 ID？
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 或tuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个torch.FloatTensor元组（如果传递了return_dict=False或config.return_dict=False时）包含各种元素，具体取决于配置（DebertaConfig）和输入。

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

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, DebertaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-base")
>>> model = DebertaForSequenceClassification.from_pretrained("microsoft/deberta-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_id = logits.argmax().item()

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = DebertaForSequenceClassification.from_pretrained("microsoft/deberta-base", num_labels=num_labels)

>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, DebertaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-base")
>>> model = DebertaForSequenceClassification.from_pretrained("microsoft/deberta-base", problem_type="multi_label_classification")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")

>>> with torch.no_grad():
...     logits = model(**inputs).logits

>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = DebertaForSequenceClassification.from_pretrained(
...     "microsoft/deberta-base", num_labels=num_labels, problem_type="multi_label_classification"
... )

>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

DebertaForTokenClassification

`class transformers.DebertaForTokenClassification`

( config )

参数

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

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

DeBERTa 模型是由 Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen 在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出的。它在 BERT/RoBERTa 的基础上进行了两项改进，即解耦的注意力和增强的掩码解码器。通过这两项改进，它在 80GB 的预训练数据上优于 BERT/RoBERTa 的大多数任务。

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

`forward`

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

参数

input_ids（形状为(batch_size, sequence_length)的torch.LongTensor） — 输入序列标记在词汇表中的索引。

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

什么是输入 ID？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), 可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在[0, 1]之间：
- 对于未被masked的标记为 1，
- 对于被masked的标记为 0。
什么是注意力掩码？
token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
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，可选）— 用于计算标记分类损失的标签。索引应在[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时）包含根据配置（DebertaConfig）和输入的各种元素。

loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 分类损失。
logits（形状为(batch_size, sequence_length, config.num_labels)的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 之后的注意力权重。

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

示例：

>>> from transformers import AutoTokenizer, DebertaForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-base")
>>> model = DebertaForTokenClassification.from_pretrained("microsoft/deberta-base")

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

DebertaForQuestionAnswering

`class transformers.DebertaForQuestionAnswering`

( config )

参数

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

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

DeBERTa 模型由 Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen 在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出。它在 BERT/RoBERTa 的基础上进行了两项改进，即解耦注意力和增强掩码解码器。通过这两项改进，它在 80GB 预训练数据上的大多数任务中表现优于 BERT/RoBERTa。

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

`forward`

( input_ids: Optional = None attention_mask: Optional = None token_type_ids: Optional = None position_ids: 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，形状为(batch_size, sequence_length)) — 词汇表中输入序列标记的索引。

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

什么是输入 ID？
attention_mask (torch.FloatTensor，形状为(batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。选择在[0, 1]范围内的掩码值：
- 1 表示未被masked的标记，
- 0 表示被masked的标记。
什么是注意力掩码？
token_type_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A标记，
- 1 对应于句子 B标记。
什么是标记类型 ID？
position_ids (torch.LongTensor，形状为(batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
inputs_embeds (torch.FloatTensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权，以便将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，则这很有用。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通元组。
start_positions（形状为(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）包含根据配置（DebertaConfig）和输入的各种元素。

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

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

示例：

>>> from transformers import AutoTokenizer, DebertaForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("Palak/microsoft_deberta-large_squad")
>>> model = DebertaForQuestionAnswering.from_pretrained("Palak/microsoft_deberta-large_squad")

>>> 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([12])
>>> target_end_index = torch.tensor([14])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
0.14

TensorFlow 隐藏 TensorFlow 内容

TFDebertaModel

`class transformers.TFDebertaModel`

( config: DebertaConfig *inputs **kwargs )

参数

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

裸 DeBERTa 模型变压器输出没有特定头部的原始隐藏状态。DeBERTa 模型是由 Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen 在 DeBERTa: Decoding-enhanced BERT with Disentangled Attention 中提出的。它在 BERT/RoBERTa 的基础上进行了两项改进，即解缠注意力和增强掩码解码器。通过这两项改进，它在使用 80GB 预训练数据的大多数任务上优于 BERT/RoBERTa。

该模型也是 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 inputs_embeds: np.ndarray | tf.Tensor | None = 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.TFBaseModelOutput 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.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 用于未被 masked 的标记，
- 0 用于被 masked 的标记。
什么是注意力掩码？
token_type_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 分段标记索引，指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是标记类型 ID？
position_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
inputs_embeds (np.ndarray 或 tf.Tensor，形状为(batch_size, sequence_length, hidden_size)，可选) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多细节，请参阅返回张量中的attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多细节，请参阅返回张量中的hidden_states。
return_dict (bool, optional) — 是否返回一个[~utils.ModelOutput]而不是一个普通的元组。

返回值

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

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

last_hidden_state (tf.Tensor，形状为(batch_size, sequence_length, hidden_size)) — 模型最后一层的隐藏状态序列。
hidden_states (tuple(tf.FloatTensor)，可选，当传递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 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, TFDebertaModel
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-base")
>>> model = TFDebertaModel.from_pretrained("kamalkraj/deberta-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")
>>> outputs = model(inputs)

>>> last_hidden_states = outputs.last_hidden_state

TFDebertaPreTrainedModel

`class transformers.TFDebertaPreTrainedModel`

( *args **kwargs )

一个处理权重初始化和下载和加载预训练模型的简单接口的抽象类。

`call`

( inputs training = None mask = None )

对新输入调用模型并将输出作为张量返回。

在这种情况下，call()只是重新应用图中的所有操作到新的输入上（例如，从提供的输入构建一个新的计算图）。

注意：不应直接调用此方法。只有在子类化tf.keras.Model时才应该被覆盖。要在输入上调用模型，始终使用__call__()方法，即model(inputs)，它依赖于底层的call()方法。

TFDebertaForMaskedLM

`class transformers.TFDebertaForMaskedLM`

( config: DebertaConfig *inputs **kwargs )

参数

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

DeBERTa 模型在顶部带有一个语言建模头。DeBERTa 模型是由 Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen 在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出的。它是在 BERT/RoBERTa 的基础上进行了两项改进，即解耦注意力和增强掩码解码器。通过这两项改进，它在 80GB 预训练数据上的大多数任务中表现优于 BERT/RoBERTa。

这个模型也是一个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 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.encode()和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask（形状为(batch_size, sequence_length)的np.ndarray或tf.Tensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]中：
- 对于未被掩码的标记为 1，
- 对于被掩码的标记为 0。
什么是注意力掩码？
token_type_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：
- 0 对应于 句子 A 标记，
- 1 对应于 句子 B 标记。
什么是标记类型 ID？
position_ids (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

什么是位置 ID？
inputs_embeds (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，您可以选择直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权，以便将 input_ids 索引转换为相关向量，而不是模型的内部嵌入查找矩阵。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回一个 [`~utils.ModelOutput“] 而不是一个普通元组。
标签 (tf.Tensor 或 np.ndarray，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-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）包含根据配置（DebertaConfig）和输入的不同元素。

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

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

示例：

>>> from transformers import AutoTokenizer, TFDebertaForMaskedLM
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-base")
>>> model = TFDebertaForMaskedLM.from_pretrained("kamalkraj/deberta-base")

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

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

TFDebertaForSequenceClassification

`class transformers.TFDebertaForSequenceClassification`

( config: DebertaConfig *inputs **kwargs )

参数

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

DeBERTa 模型变压器，顶部带有序列分类/回归头（池化输出的线性层），例如用于 GLUE 任务。

DeBERTa 模型是由 Pengcheng He，Xiaodong Liu，Jianfeng Gao，Weizhu Chen 在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出的。它在 BERT/RoBERTa 的基础上进行了两项改进，即解缠注意力和增强掩码解码器。通过这两项改进，它在 80GB 预训练数据上的大多数任务上表现优于 BERT/RoBERTa。

该模型也是一个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 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.encode()和 PreTrainedTokenizer.call()。

什么是输入 ID？
attention_mask (np.ndarray 或 tf.Tensor of shape (batch_size, sequence_length), 可选) — 用于避免在填充令牌索引上执行注意力的掩码。选择的掩码值为[0, 1]：
- 1 表示未被掩盖的令牌，
- 0 表示被masked的令牌。
什么是注意力掩码？
token_type_ids (np.ndarray 或 tf.Tensor of shape (batch_size, sequence_length), 可选) — 段令牌索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
- 0 对应于句子 A令牌，
- 1 对应于句子 B令牌。
什么是令牌类型 ID？
position_ids (np.ndarray 或 tf.Tensor of shape (batch_size, sequence_length), 可选) — 每个输入序列令牌在位置嵌入中的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是位置 ID？
inputs_embeds (np.ndarray 或 tf.Tensor of shape (batch_size, sequence_length, hidden_size), 可选) — 可选地，您可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
output_attentions (bool, 可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
return_dict (bool, 可选) — 是否返回[~utils.ModelOutput]而不是普通元组。
labels (tf.Tensor 或 np.ndarray of shape (batch_size,), 可选) — 用于计算序列分类/回归损失的标签。索引应在[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时）包含各种元素，这取决于配置（DebertaConfig）和输入。

loss (tf.Tensor of shape (batch_size, ), 可选, 当提供labels时返回) — 分类（如果 config.num_labels==1 则为回归）损失。
logits (tf.Tensor of shape (batch_size, config.num_labels)) — 分类（如果 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 后的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, TFDebertaForSequenceClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-base")
>>> model = TFDebertaForSequenceClassification.from_pretrained("kamalkraj/deberta-base")

>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="tf")

>>> logits = model(**inputs).logits

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])

>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFDebertaForSequenceClassification.from_pretrained("kamalkraj/deberta-base", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss

TFDebertaForTokenClassification

`class transformers.TFDebertaForTokenClassification`

( config: DebertaConfig *inputs **kwargs )

参数

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

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

DeBERTa 模型是由 Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen 在DeBERTa: Decoding-enhanced BERT with Disentangled Attention中提出的。它在 BERT/RoBERTa 的基础上进行了两项改进，即解缠注意力和增强掩码解码器。通过这两项改进，它在 80GB 预训练数据上的大多数任务上表现优于 BERT/RoBERTa。

这个模型也是一个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`

( 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 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.TFTokenClassifierOutput 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.encode()和 PreTrainedTokenizer.call()。

什么是 input IDs?
attention_mask (np.ndarray或形状为(batch_size, sequence_length)的tf.Tensor，optional) — 避免在填充 token 索引上执行注意力的掩码。掩码值在[0, 1]中选择：
- 1 表示未被masked的 token，
- 0 表示被masked的 token。
什么是 attention masks?
token_type_ids (np.ndarray或形状为(batch_size, sequence_length)的tf.Tensor，optional) — 指示输入的第一部分和第二部分的段 token 索引。索引在[0, 1]中选择：
- 0 对应于sentence A token，
- 1 对应于sentence B token。
什么是 token type IDs?
position_ids (np.ndarray或形状为(batch_size, sequence_length)的tf.Tensor，optional) — 每个输入序列 token 的位置嵌入的位置索引。在范围[0, config.max_position_embeddings - 1]中选择。

什么是 position IDs?
inputs_embeds (np.ndarray或形状为(batch_size, sequence_length, hidden_size)的tf.Tensor，optional) — 可选地，您可以直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，而不是使用模型的内部嵌入查找矩阵，这将非常有用。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
return_dict (bool, optional) — 是否返回[~utils.ModelOutput]而不是普通元组。
labels (tf.Tensor或形状为(batch_size, sequence_length)的np.ndarray，optional) — 用于计算 token 分类损失的标签。索引应在[0, ..., config.num_labels - 1]中。

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

transformers.modeling_tf_outputs.TFTokenClassifierOutput 或包含各种元素的tf.Tensor元组（如果传递return_dict=False或当config.return_dict=False时）取决于配置（DebertaConfig）和输入。

loss (tf.Tensor，形状为(n,)，optional，当提供labels时返回) — 分类损失。
logits (tf.Tensor，形状为(batch_size, sequence_length, config.num_labels)) — SoftMax 之前的分类分数。
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), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。

在自注意力头中用于计算加权平均值的注意力 softmax 之后的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, TFDebertaForTokenClassification
>>> import tensorflow as tf

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-base")
>>> model = TFDebertaForTokenClassification.from_pretrained("kamalkraj/deberta-base")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]

>>> labels = predicted_token_class_ids
>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)

TFDebertaForQuestionAnswering

`class transformers.TFDebertaForQuestionAnswering`

( config: DebertaConfig *inputs **kwargs )

参数

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

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

该模型也是一个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`