Transformers

( vocab_file do_lower_case = False split_by_punct = False bos_token = '[CLS]' eos_token = '[SEP]' unk_token = '[UNK]' sep_token = '[SEP]' pad_token = '[PAD]' cls_token = '[CLS]' mask_token = '[MASK]' sp_model_kwargs: Optional = None **kwargs )

参数

vocab_file (str) — 包含实现分词器所必需词汇的 SentencePiece 文件（通常具有 .spm 扩展名）。
do_lower_case (bool, 可选, 默认为 False) — 在分词时是否将输入转换为小写。
bos_token (字符串, 可选, 默认为 "[CLS]") — 预训练过程中使用的序列开始标记。可以用作序列分类标记。当使用特殊标记构建序列时，这不是序列开始时所使用的标记。使用的标记是 cls_token。
eos_token (字符串, 可选, 默认为 "[SEP]") — 序列结束标记。当使用特殊标记构建序列时，这不是序列结束时所使用的标记。使用的标记是 sep_token。
unk_token (字符串, 可选, 默认为 "[UNK]") — 未知标记。不在词汇表中的标记不能转换为ID，因此将其设置为此标记。
sep_token (str, 可选，默认为 "[SEP]") — 分隔符标记，在从多个序列构建序列时使用，例如两个序列用于序列分类或用于文本和问题进行问答。它也被用作使用特殊标记构建的序列的最后一个标记。
pad_token (str, 可选，默认为 "[PAD]") — 扩充标记，用于不同长度序列的批处理，例如。
cls_token (str, 可选，默认为 "[CLS]") — 分类标记，在执行序列分类（对整个序列而不是按标记分类）时使用。它是在使用特殊标记构建的序列中的第一个标记。
mask_token （str，可选，默认为"[MASK]"）—用于遮蔽值的标记。这是在训练本模型时用于遮蔽语言建模的标记。这是模型将试图预测的标记。
sp_model_kwargs （dict，可选）—将被传递给SentencePieceProcessor.__init__()方法。除了其他用途之外，可以使用SentencePiece的Python封装器来设置：

构建DeBERTa-v2标记器。基于SentencePiece。

build_inputs_with_special_tokens

( token_ids_0 token_ids_1 = None ) → List[int]

参数

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

返回值

List[int]

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

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

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

get_special_tokens_mask

( token_ids_0 token_ids_1 = None already_has_special_tokens = False ) → 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 token_ids_1 = None ) → List[int]

参数

token_ids_0 (列表[int]) — ID列表。
token_ids_1 (列表[int] (可选)) — 可选的第二个ID序列，用于顺序对。

返回值

List[int]

根据给定的序列(s)，返回token类型ID列表。

从传递给序列-pair分类任务的两个序列创建掩码。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）。

save_vocabulary

( save_directory: str filename_prefix: Optional = None )

DebertaV2TokenizerFast

类 transformers.DebertaV2TokenizerFast

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

参数

vocab_file (str) — 存储创建分词器所需语料库的 SentencePiece 文件（通常具有 .spm 扩展名）。
do_lower_case (bool, 可选, 默认为 False) — 在标记化时是否将输入转换为小写。
bos_token (字符串，可选，默认为"[CLS]") —— 在预训练过程中使用的序列开头标记。可以用作序列分类标记。当使用特殊标记构建序列时，这不是用作序列开头的标记。用作的标记是cls_token。
eos_token (字符串，可选，默认为"[SEP]") —— 序列结束标记。当使用特殊标记构建序列时，这不是用作序列结束的标记。用作的标记是sep_token。
unk_token (字符串，可选，默认为"[UNK]") —— 未知标记。不在词汇表中的标记不能转换为ID，将被设置为该标记。
sep_token （str，可选，默认为"[SEP]"）— 分隔符标记，在从多个序列构建序列时使用，例如用于序列分类（对整个序列的分类而不是按标记分类）的两个序列，或用于问答的文本和问题。它也是用特殊标记构建的序列的最后一个标记。
pad_token （str，可选，默认为"[PAD]"）— 用于填充的标记，例如在处理不同长度的序列批处理时使用。
cls_token （str，可选，默认为"[CLS]"）— 用于序列分类（整序列分类而非按标记分类）的分类器标记。当与特殊标记一起构建序列时，它是序列的第一个标记。
mask_token (str, 可选, 默认为 "[MASK]") — 用于遮蔽值的标记。这是在用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法。除了其他目的之外，可以使用 SentencePiece 的 Python 封装器来设置：
- enable_sampling: 启用子词正则化。
- nbest_size: 单词采样参数。对于 BPE-Dropout 无效。
  - nbest_size = {0,1}: 不进行采样。
  - nbest_size > 1: 从 nbest_size 个结果中采样。
  - nbest_size < 0: 假设 nbest_size 为无穷大，并使用前向滤波和后向采样算法从所有假设（图灵机）中采样。
- alpha: 单词采样平滑参数，以及 BPE-dropout 合并操作的 dropout 概率。

构建 DeBERTa-v2 快速分词器。是基于 SentencePiece。

build_inputs_with_special_tokens

( token_ids_0 token_ids_1 = None ) → List[int]

参数

token_ids_0 (Int列表) — 将添加特殊标记的ID列表。
token_ids_1 (Int列表，可选) — 可选的第二组ID序列对。

返回值

List[int]

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

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

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

create_token_type_ids_from_sequences

( token_ids_0 token_ids_1 = None ) → List[int]

参数

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

返回值

List[int]

根据给定的序列(s)，返回token类型ID列表。

从传递给序列-pair分类任务的两个序列创建掩码。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）。

Pytorch

隐藏Pytorch内容

DebertaV2Model

类 transformers.DebertaV2Model

( config )

参数

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

DeBERTa模型是一个没有在顶部添加任何特定头的裸DeBERTa模型transformer，它输出原始隐藏状态。DeBERTa模型由Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen在DeBERTa: Decoding-enhanced BERT with Disentangled Attention一文中提出。它在BERT/RoBERTa的基础上增加了两个改进，即分离的注意力和增强的掩码解码器。这两个改进使得在大多数任务上，使用80GB预训练数据的DeBERTa模型优于BERT/RoBERTa。

此模型也是PyTorch torch.nn.Module的子类。将其用作常规的PyTorch模块，并请 Refer to the PyTorch documentation for all matters related to general usage and behavior.

正向

( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None inputs_embeds: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.BaseModelOutput 或 tuple(torch.FloatTensor)

参数

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

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

什么是输入ID？
attention_mask (torch.FloatTensor 形状 (batch_size, sequence_length), 可选) — 避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示未进行掩码的标记
- 0 表示进行掩码的标记
什么是注意力掩码？
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 而不是普通元组。

返回值

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

A transformers.modeling_outputs.BaseModelOutput 或一个由 torch.FloatTensor 组成的元组（如果传递了 return_dict=False 或 config.return_dict=False），根据配置（DebertaV2Config）和输入包含不同的元素。

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 时返回) — 一个来自嵌入层输出（如果模型有嵌入层）和每层输出（torch.FloatTensor）的元组，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

尽管前向通过的配方需要在此函数内部定义，但应该在之后调用 Module 实例而不是此（因为前者处理运行预处理和后处理步骤，而后者静默忽略它们）。

示例

>>> from transformers import AutoTokenizer, DebertaV2Model
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v2-xlarge")
>>> model = DebertaV2Model.from_pretrained("microsoft/deberta-v2-xlarge")

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

>>> last_hidden_states = outputs.last_hidden_state

DebertaV2PreTrainedModel

class transformers.DebertaV2PreTrainedModel

( config: PretrainedConfig *inputs **kwargs )

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

_forward_unimplemented

( *input: 任何 )

定义每次调用时的计算操作。

应该由所有子类重写。

虽然需要在函数内部定义前向传递的公式，但是应该在对Module实例进行调用时使用这个函数，而不是加以忽略，因为前者会负责运行已注册的钩子，而后者则会默默地忽略它们。

DebertaV2ForMaskedLM

类 transformers.DebertaV2ForMaskedLM

( config )

参数

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

DeBERTa模型顶部添加了语言建模头部。DeBERTa模型由Pengcheng He、Xiaodong Liu、Jianfeng Gao和Weizhu Chen在DeBERTa: Decoding-enhanced BERT with Disentangled Attention一文中提出。它在BERT/RoBERTa的基础上增加了两项改进，即解耦注意力和增强掩码解码器。通过这两项改进，在80GB预训练数据集上，DeBERTa在大多数任务上都优于BERT/RoBERTa。

此模型也是PyTorch torch.nn.Module的子类。将其用作常规的PyTorch模块，并请 Refer to the PyTorch documentation for all matters related to general usage and behavior.

正向

( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None inputs_embeds: 可选 = None labels: 可选 = None output_attentions: 可选 = None output_hidden_states: 可选 = None return_dict: 可选 = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列的词库中的标记索引。

索引可以通过使用 AutoTokenizer 来获取。有关详细信息，请参阅 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.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，形状为(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时），根据配置（DebertaV2Config）和输入包含各种元素。

loss (torch.FloatTensor，形状为(1,)，可选，在提供labels时返回) — 掩码语言建模（MLM）损失。
logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax之前的每个词汇表的分数）。
hidden_states (tuple(torch.FloatTensor), 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个来自嵌入层输出（如果模型有嵌入层）和每层输出（torch.FloatTensor）的元组，形状为 (batch_size, sequence_length, hidden_size)。

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

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

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

示例

>>> from transformers import AutoTokenizer, DebertaV2ForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v2-xlarge")
>>> model = DebertaV2ForMaskedLM.from_pretrained("microsoft/deberta-v2-xlarge")

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

DebertaV2ForSequenceClassification

类 transformers.DebertaV2ForSequenceClassification

( config )

参数

配置 (DebertaV2Config) — 包含所有模型参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重，仅仅是配置。请查看 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模块，并请 Refer to the PyTorch documentation for all matters related to general usage and behavior.

正向

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词库中输入序列标记的索引。

索引可以通过 AutoTokenizer 获取。详情请见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入索引？
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？
inputs_embeds (torch.FloatTensor 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, optional) — 是否返回ModelOutput对象而非普通元组。
labels (torch.LongTensor size为 (batch_size,), optional) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

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

A transformers.modeling_outputs.SequenceClassifierOutput 或一个包含 torch.FloatTensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False 时），包含的元素根据配置（DebertaV2Config）和输入而有所不同。

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

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

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

DebertaV2ForSequenceClassification 的 forward 方法覆盖了特殊方法 __call__。

单标签分类的示例

>>> import torch
>>> from transformers import AutoTokenizer, DebertaV2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v2-xlarge")
>>> model = DebertaV2ForSequenceClassification.from_pretrained("microsoft/deberta-v2-xlarge")

>>> 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 = DebertaV2ForSequenceClassification.from_pretrained("microsoft/deberta-v2-xlarge", num_labels=num_labels)

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

多标签分类的示例

>>> import torch
>>> from transformers import AutoTokenizer, DebertaV2ForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v2-xlarge")
>>> model = DebertaV2ForSequenceClassification.from_pretrained("microsoft/deberta-v2-xlarge", 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 = DebertaV2ForSequenceClassification.from_pretrained(
...     "microsoft/deberta-v2-xlarge", 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

DebertaV2ForTokenClassification

类 transformers.DebertaV2ForTokenClassification

< 源 >

( config )

参数

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

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

此模型也是PyTorch torch.nn.Module的子类。将其用作常规的PyTorch模块，并请 Refer to the PyTorch documentation for all matters related to general usage and behavior.

正向

< 源 >

参数

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), 可选) — 避免在填充token索引处执行attention的掩码。掩码值选择在[0, 1]范围内：
- 1 表示未掩码的token，
- 0 表示掩码的token。
什么是attention掩码？
token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 段token索引，用于指示输入的第一个和第二个部分。索引值选择在[0, 1]范围内：
- 0 表示句A的token，
- 1 表示句B的token。
什么是token类型ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), 可选) — 每个输入序列token在位置嵌入中的索引。选择在范围[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, optional) — 是否返回ModelOutput对象而不是普通元组。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算token分类损失的标签。索引应在[0, ..., config.num_labels - 1]之间。

返回值

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

A transformers.modeling_outputs.TokenClassifierOutput或由torch.FloatTensor组成的元组（如果传递了return_dict=False或当config.return_dict=False时），所包含的元素根据配置(如DebertaV2Config)和输入而不同。

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), 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个来自嵌入层输出（如果模型有嵌入层）和每层输出（torch.FloatTensor）的元组，形状为 (batch_size, sequence_length, hidden_size)。

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

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

DebertaV2ForTokenClassification的前向方法重写了特殊方法__call__。

示例

>>> from transformers import AutoTokenizer, DebertaV2ForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v2-xlarge")
>>> model = DebertaV2ForTokenClassification.from_pretrained("microsoft/deberta-v2-xlarge")

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

DebertaV2ForQuestionAnswering

类 transformers.DebertaV2ForQuestionAnswering

( config )

参数

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

在SQuAD（一种包含线性层在隐藏状态输出上用于计算 段开始logits 和 段结束logits 的抽取式问答任务）等抽取式问答任务上具有段分类头的DeBERTa模型。

此模型也是PyTorch torch.nn.Module的子类。将其用作常规的PyTorch模块，并请 Refer to the PyTorch documentation for all matters related to general usage and behavior.

正向

( input_ids: 可选 = None attention_mask: 可选 = None token_type_ids: 可选 = None position_ids: 可选 = None inputs_embeds: 可选 = None start_positions: 可选 = None end_positions: 可选 = None outputAttentions: 可选 = None outputHiddenStates: 可选 = None returnDict: 可选 = None ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

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

索引可以通过使用 AutoTokenizer 获取。请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call() 了解详情。

什么是输入 ID？
attention_mask （形状为 (batch_size, sequence_length) 的 torch.FloatTensor，非必须） —— 避免在 padding token 索引上执行 attention 的掩码。选择的掩码值在 [0, 1] 范围内：
- 1 代表 未掩码 的 tokens，
- 0 代表掩码的 tokens。
什么是 attention 掩码？
token_type_ids （形状为 (batch_size, sequence_length) 的 torch.LongTensor，非必须） —— 段落 token 索引，用于指示输入的第一个和第二个部分。索引在 [0, 1] 范围内：
- 0 代表 句子 A 的 token，
- 1 代表 句子 B 的 token。
什么是 token 类型 ID？
position_ids （形状为 (batch_size, sequence_length) 的 torch.LongTensor，非必须） —— 每个输入序列中 token 的位置索引，在位置嵌入中使用。选择范围在 [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 (torch.LongTensor 形状 (batch_size,), 可选) — 标记跨度起始位置的标签，用于计算token分类损失。位置被限制在序列长度内（sequence_length）。序列外的位置不计入损失计算。
end_positions (torch.LongTensor 形状 (batch_size,), 可选) — 标记跨度结束位置的标签，用于计算token分类损失。位置被限制在序列长度内（sequence_length）。序列外的位置不计入损失计算。

返回值

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

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

损失 (torch.FloatTensor 形状为 (1,)，可选，当 labels 提供时返回) —— 总跨度提取损失是起始位置和结束位置的交叉熵之和。
start_logits (torch.FloatTensor 形状为 (batch_size, sequence_length)) ——跨度起始分数（在 SoftMax 之前）。
end_logits (torch.FloatTensor 形状为 (batch_size, sequence_length)) ——跨度结束分数（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), 可选，当传递 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个来自嵌入层输出（如果模型有嵌入层）和每层输出（torch.FloatTensor）的元组，形状为 (batch_size, sequence_length, hidden_size)。

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

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

DebertaV2ForQuestionAnswering前向方法，重写了__call__特殊方法。

示例

>>> from transformers import AutoTokenizer, DebertaV2ForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v2-xlarge")
>>> model = DebertaV2ForQuestionAnswering.from_pretrained("microsoft/deberta-v2-xlarge")

>>> 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([2])
>>> target_end_index = torch.tensor([9])

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

DebertaV2ForMultipleChoice

类 transformers.DebertaV2ForMultipleChoice

< 源 >

( config )

参数

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

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

此模型也是PyTorch torch.nn.Module的子类。将其用作常规的PyTorch模块，并请 Refer to the PyTorch documentation for all matters related to general usage and behavior.

正向

( 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 ) → transformers.modeling_outputs.MultipleChoiceModelOutput or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 序列中词汇的输入序列标记的索引。

可以使用AutoTokenizer 获取索引。请参阅 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.max_position_embeddings - 1]。

什么是位置 ID？
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, 可选) — 是否返回一个ModelOutput而不是一个普通的元组。
labels (torch.LongTensor 形状为 (batch_size,), 可选) — 用于计算多选分类损失的标签。索引应该为 [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时），包含根据配置（DebertaV2Config）和输入的各种元素。

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 时返回) — 一个来自嵌入层输出（如果模型有嵌入层）和每层输出（torch.FloatTensor）的元组，形状为 (batch_size, sequence_length, hidden_size)。

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

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

DebertaV2ForMultipleChoice的forward方法覆盖了__call__特殊方法。

示例

>>> from transformers import AutoTokenizer, DebertaV2ForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta-v2-xlarge")
>>> model = DebertaV2ForMultipleChoice.from_pretrained("microsoft/deberta-v2-xlarge")

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

TensorFlow

隐藏TensorFlow内容

TFDebertaV2Model

类 transformers.TFDebertaV2Model

( config: DebertaV2Config *inputs **kwargs )

参数

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

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解有关一般使用和行为的所有问题。

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

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

支持第二种格式的原因是，Keras方法在向模型和层传递输入时更喜欢这种格式。正因为这种支持，当使用如model.fit()这样的方法时，对于您来说事情应该“照常进行”——只需以任何model.fit()支持的数据格式传递您的输入和标签即可！不过，如果您想在如fit()和predict()之类的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函数传递输入一样传递输入！

调用

( 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 ) → transformers.modeling_tf_outputs.TFBaseModelOutput 或 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 表示未掩码的标记，
- 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 或 shape 为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor，可选）—— 您可以选择直接传递嵌入表示而不是传递 input_ids。如果您想对比特表索引转换为关联向量的方法有更多的控制，而不是模型内部嵌入查找矩阵，这种方法非常有用。
output_attentions （bool，可选）—— 是否返回所有注意力层的注意力张量。有关更多详细信息，请参返回张量下的 attentions。
output_hidden_states （bool，可选）—— 是否返回所有层的隐藏状态。有关更多详细信息，请参返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回一个 ~utils.ModelOutput 的字典而不是一个普通的元组。

返回值

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

A transformers.modeling_tf_outputs.TFBaseModelOutput 或一个包含 tf.Tensor 的元组（如果传递了 return_dict=False 或当 config.return_dict=False）构成各种元素，这些元素取决于配置（DebertaV2Config）和输入。

last_hidden_state （形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor） — 模型最后一层的输出序列的隐藏状态。
hidden_states （tuple(tf.FloatTensor)，可选，当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回） — 一个包含 tf.Tensor 的元组（一个用于嵌入的输出，一个用于每个层的输出），形状为 (batch_size, sequence_length, hidden_size)。

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

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

TFDebertaV2Model 的 forward 方法重写了 __call__ 特殊方法。

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-v2-xlarge")
>>> model = TFDebertaV2Model.from_pretrained("kamalkraj/deberta-v2-xlarge")

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

>>> last_hidden_states = outputs.last_hidden_state

TFDebertaV2PreTrainedModel

类 transformers.TFDebertaV2PreTrainedModel

( *args **kwargs )

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

调用

( inputs training = None mask = None )

调用模型对新输入进行处理并返回输出张量。

在这种情况下，call() 方法只是对图中的所有操作在新的输入上重新应用（例如，从提供的输入构建一个新的计算图）。

注意：此方法不应直接调用。它仅在子类化 tf.keras.Model 时重写。要对输入调用模型，始终使用 __call__() 方法，即 model(inputs)，该方法依赖于底层的 call() 方法。

TFDebertaV2ForMaskedLM

类 transformers.TFDebertaV2ForMaskedLM

( config: DebertaV2Config *inputs **kwargs )

参数

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

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解有关一般使用和行为的所有问题。

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

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

单个包含只含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函数传递输入一样传递输入！

调用

( 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 ) → 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（形状为 (batch_size, sequence_length) 的 np.ndarray 或 tf.Tensor，可选）— 段标记索引，用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择：‘
- 0 对应于 句子 A 标记；
- 1 对应于 句子 B 标记。
什么是标记类型ID？
position_ids (np.ndarray or tf.Tensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的索引。在范围 [0, config.max_position_embeddings - 1] 内选择。

什么是位置ID？
inputs_embeds (np.ndarray or tf.Tensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选，而不是传递 input_ids，您可以直接传递一个嵌入表示。如果您想要比模型的内部嵌入查找矩阵有更多控制权来将 input_ids 索引转换为相关向量，这非常有用。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的 attentions。
output_hidden_states (bool, 可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的 hidden_states。
return_dict (bool, 可选) — 是否返回一个 `~utils.ModelOutput“` 而不是纯元组。
labels (tf.Tensor 或形状为 (batch_size, sequence_length) 的 np.ndarray，可选) — 用于计算掩码语言模型损失的标签。索引应该为 [-100, 0, ..., config.vocab_size]（参见 input_ids 的文档字符串）。索引设置为 -100 的标记将被忽略（掩码），仅计算具有 [0, ..., config.vocab_size] 标签的标记的损失。

返回值

或 `tuple(tf.Tensor)`

transformers.modeling_tf_outputs.TFMaskedLMOutput 或 `tuple(tf.Tensor)`（如果传递了 `return_dict=False` 或当 `config.return_dict=False` 时）包含根据配置（DebertaV2Config）和输入的配置而定的各种元素。

loss （tf.Tensor 类型的 shape 为 (n,)，可选，其中 n 是非掩码标签的数量，当提供 `labels` 时返回） — 掩码语言模型 (MLM) 损失。
logits （shape 为 (batch_size, sequence_length, config.vocab_size) 的 tf.Tensor） — 语言模型头的预测分数（SoftMax 之前的每个词汇标记的分数）。
hidden_states (tuple(tf.Tensor), 可选，当传入 output_hidden_states=True 或 config.output_hidden_states=True 时返回) — 一个形状为 (batch_size, sequence_length, hidden_size) 的 tf.Tensor 的元组（一个是嵌入层的输出，一个是每一层的输出）。

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

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

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-v2-xlarge")
>>> model = TFDebertaV2ForMaskedLM.from_pretrained("kamalkraj/deberta-v2-xlarge")

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

TFDebertaV2ForSequenceClassification

类 transformers.TFDebertaV2ForSequenceClassification

( config: DebertaV2Config *inputs **kwargs )

参数

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

DeBERTa 模型，具有序列分类/回归头（位于池化输出之上的线性层），例如用于 GLUE 任务。

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解有关一般使用和行为的所有问题。

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

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

单个包含只含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函数传递输入一样传递输入！

调用

( 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 ) → transformers.modeling_tf_outputs.TFSequenceClassifierOutput 或 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()。
attention_mask (np.ndarray 或 tf.Tensor，形状为 (batch_size, sequence_length)，可选)：该掩码用于避免在填充标记索引上执行注意力操作。掩码值选择在 [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, 可选) — 是否返回一个字典类型的结果而不是普通的元组类型。
labels (tf.Tensor 或 np.ndarray 形状为 (batch_size,)，可选) — 计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。

返回值

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

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

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

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-v2-xlarge")
>>> model = TFDebertaV2ForSequenceClassification.from_pretrained("kamalkraj/deberta-v2-xlarge")

>>> 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 = TFDebertaV2ForSequenceClassification.from_pretrained("kamalkraj/deberta-v2-xlarge", num_labels=num_labels)

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

TFDebertaV2ForTokenClassification

类名 transformers.TFDebertaV2ForTokenClassification

( config: DebertaV2Config *inputs **kwargs )

参数

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

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

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解有关一般使用和行为的所有问题。

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

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

单个包含只含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函数传递输入一样传递输入！

调用

( 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 ) → transformers.modeling_tf_outputs.TFTokenClassifierOutput or tuple(tf.Tensor)

参数

input_ids（《numpy.ndarray》或《tf.Tensor》或《List[tf.Tensor]》或《Dict[str, tf.Tensor]》或《Dict[str, numpy.ndarray]》）和每个示例必须具有形状（batch_size, sequence_length）输入序列标记的词汇表中的索引。

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

什么是输入ID？
attention_mask（《numpy.ndarray》或《tf.Tensor》，形状为(batch_size, sequence_length)，可选）— 用于避免对padding标记索引执行注意力计算的掩码。掩码值在[0, 1]中选择：
- 1表示未掩码的标记，
- 0表示掩码的标记。
什么是注意力掩码？
token_type_ids（《numpy.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而不是纯元组。
labels (tf.Tensor或形状为(batch_size, sequence_length)的np.ndarray，可选) — 用于计算分词损失函数的标签。索引应在[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时），由配置（DebertaV2Config）和输入确定。

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

TFDebertaV2ForTokenClassification 类的前向方法覆盖了 __call__ 特殊方法。请参考

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-v2-xlarge")
>>> model = TFDebertaV2ForTokenClassification.from_pretrained("kamalkraj/deberta-v2-xlarge")

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

TFDebertaV2ForQuestionAnswering

class transformers.TFDebertaV2ForQuestionAnswering

( config: DebertaV2Config *inputs **kwargs )

参数

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

在SQuAD（一种包含线性层在隐藏状态输出上用于计算 段开始logits 和 段结束logits 的抽取式问答任务）等抽取式问答任务上具有段分类头的DeBERTa模型。

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解有关一般使用和行为的所有问题。

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

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

单个包含只含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函数传递输入一样传递输入！

调用

参数

input_ids (np.ndarray, tf.Tensor, List[tf.Tensor] `Dict[str, tf.Tensor] or Dict[str, np.ndarray] and each example must have the shape (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 对应于掩码的令牌。
什么是注意力掩码？
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 形状为 (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。如果您希望比模型内部嵌入查找矩阵有更多控制，这种做法很有用。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选）— 是否返回所有层的隐藏状态。有关详细信息，请参阅返回的张力中下的hidden_states。
return_dict (bool，可选）— 是否返回`~utils.ModelOutput“`而不是纯元组。
start_positions (tf.Tensor或np.ndarray形状(batch_size,)，可选）— 标记起始（索引）位置的标签，用于计算标记分类损失。位置限制在序列长度（`sequence_length`）内。序列外的位置不考虑计算损失。
end_positions (tf.Tensor 或 np.ndarray 形状为 (batch_size,)，可选) — 标记的跨度末尾位置的标签，用于计算标记分类损失。位置限制在序列长度（sequence_length）内。序列之外的位置不用于计算损失。

返回值

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

A transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutput 或一个 tf.Tensor 的元组（如果 return_dict=False 被传递或当 config.return_dict=False）由配置（DebertaV2Config）和输入组成。

loss (tf.Tensor 形状为 (batch_size, )，可选，当提供 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), 可选，当传入 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 后使用，用于在自注意力头中计算加权平均值。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("kamalkraj/deberta-v2-xlarge")
>>> model = TFDebertaV2ForQuestionAnswering.from_pretrained("kamalkraj/deberta-v2-xlarge")

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

TFDebertaV2ForMultipleChoice

类 transformers.TFDebertaV2ForMultipleChoice

( config: DebertaV2Config *inputs **kwargs )

参数

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

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

此模型也是 keras.Model 的子类。将其作为常规 TF 2.0 Keras 模型使用，并参考 TF 2.0 文档了解有关一般使用和行为的所有问题。

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

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

单个包含只含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函数传递输入一样传递输入！

调用