Transformers 文档

DeBERTa-v2

Transformers

加入 Hugging Face 社区

并获得增强的文档体验

在模型、数据集和 Spaces 上进行协作

通过加速推理获得更快的示例

切换文档主题

开始使用

DeBERTa-v2

概述

DeBERTa 模型由 Pengcheng He、Xiaodong Liu、Jianfeng Gao、Weizhu Chen 在论文 DeBERTa: Decoding-enhanced BERT with Disentangled Attention 中提出。它基于谷歌于 2018 年发布的 BERT 模型和 Facebook 于 2019 年发布的 RoBERTa 模型。

它在 RoBERTa 的基础上，增加了分离式注意力机制和增强的掩码解码器，并使用了 RoBERTa 一半的训练数据进行训练。

论文摘要如下：

预训练神经语言模型的最新进展显著提升了许多自然语言处理 (NLP) 任务的性能。在本文中，我们提出了一种新的模型架构 DeBERTa (Decoding-enhanced BERT with disentangled attention)，它通过两种新技术改进了 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 的代码和预训练模型将公开发布于 https://github.com/microsoft/DeBERTa。

以下信息直接来自于原始实现仓库。DeBERTa v2 是 DeBERTa 模型的第二个版本。它包括用于 SuperGLUE 单模型提交的 1.5B 参数模型，并取得了 89.9 的分数，而人类基线为 89.8。您可以在作者的博客中找到有关此次提交的更多详细信息。

v2 版本的新特性

词汇表 在 v2 版本中，分词器改为使用一个新的、大小为 128K 的词汇表，该词汇表是根据训练数据构建的。分词器不再是基于 GPT2 的分词器，而是基于 sentencepiece 的分词器。
nGiE(nGram Induced Input Encoding) DeBERTa-v2 模型在第一个 Transformer 层旁边使用了一个额外的卷积层，以更好地学习输入标记的局部依赖性。
在注意力层中共享位置投影矩阵和内容投影矩阵 根据之前的实验，这可以在不影响性能的情况下节省参数。
应用桶来编码相对位置 DeBERTa-v2 模型使用对数桶来编码相对位置，类似于 T5。
900M 和 1.5B 模型 提供了两种额外的模型尺寸：900M 和 1.5B，这显著提高了下游任务的性能。

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

资源

DebertaV2Config

class transformers.DebertaV2Config

< 源 >

( vocab_size = 128100 hidden_size = 1536 num_hidden_layers = 24 num_attention_heads = 24 intermediate_size = 6144 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' legacy = True **kwargs )

参数

vocab_size (int, 可选, 默认为 128100) — DeBERTa-v2 模型的词汇表大小。定义了在调用 DebertaV2Model 时传入的 inputs_ids 可以表示的不同标记的数量。
hidden_size (int, 可选, 默认为 1536) — 编码器层和池化层的维度。
num_hidden_layers (int, 可选, 默认为 24) — Transformer 编码器中的隐藏层数量。
num_attention_heads (int, 可选, 默认为 24) — Transformer 编码器中每个注意力层的注意力头数量。
intermediate_size (int, 可选, 默认为 6144) — Transformer 编码器中“中间层”（通常称为前馈层）的维度。
hidden_act (str 或 Callable, 可选, 默认为 "gelu") — 编码器和池化层中的非线性激活函数（函数或字符串）。如果为字符串，支持 "gelu"、"relu"、"silu"、"gelu"、"tanh"、"gelu_fast"、"mish"、"linear"、"sigmoid" 和 "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, 可选, 默认为 0) — 调用 DebertaModel 或 TFDebertaModel 时传入的 token_type_ids 的词汇表大小。
initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-7) — 层归一化层使用的 epsilon 值。
relative_attention (bool, 可选, 默认为 True) — 是否使用相对位置编码。
max_relative_positions (int, 可选, 默认为 -1) — 相对位置的范围 [-max_position_embeddings, max_position_embeddings]。使用与 max_position_embeddings 相同的值。
pad_token_id (int, 可选, 默认为 0) — 用于填充 input_ids 的值。
position_biased_input (bool, 可选, 默认为 True) — 是否将绝对位置嵌入添加到内容嵌入中。
pos_att_type (list[str], 可选) — 相对位置注意力的类型，可以是 ["p2c", "c2p"] 的组合，例如 ["p2c"]、["p2c", "c2p"]、["p2c", "c2p"]。
layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon 值。
legacy (bool, 可选, 默认为 True) — 模型是否应使用旧版的 LegacyDebertaOnlyMLMHead，该版本在掩码填充任务中无法正常工作。

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

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

示例

>>> from transformers import DebertaV2Config, DebertaV2Model

>>> # Initializing a DeBERTa-v2 microsoft/deberta-v2-xlarge style configuration
>>> configuration = DebertaV2Config()

>>> # Initializing a model (with random weights) from the microsoft/deberta-v2-xlarge style configuration
>>> model = DebertaV2Model(configuration)

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

DebertaV2Tokenizer

class transformers.DebertaV2Tokenizer

< 源 >

( 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: typing.Optional[dict[str, typing.Any]] = None **kwargs )

参数

vocab_file (str) — SentencePiece 文件（通常扩展名为 .spm），包含实例化分词器所需的词汇表。
do_lower_case (bool, 可选, 默认为 False) — 是否在分词时将输入转换为小写。
bos_token (string, 可选, 默认为 "[CLS]") — 序列开始标记，在预训练期间使用。可用作序列分类器标记。当使用特殊标记构建序列时，此标记不会用作序列的开头，而是使用 cls_token。
eos_token (string, 可选, 默认为 "[SEP]") — 序列结束标记。当使用特殊标记构建序列时，此标记不会用作序列的结尾，而是使用 sep_token。
unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。词表中不存在的标记无法转换为ID，将被设置为此标记。
sep_token (str, 可选, 默认为 "[SEP]") — 分隔标记，用于从多个序列构建一个序列时，例如用于序列分类的两个序列，或用于问答任务的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。
pad_token (str, 可选, 默认为 "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
cls_token (str, 可选, 默认为 "[CLS]") — 分类器标记，在进行序列分类（对整个序列进行分类，而不是按标记分类）时使用。当使用特殊标记构建序列时，它是序列的第一个标记。
mask_token (str, 可选, 默认为 "[MASK]") — 用于掩盖值的标记。在使用掩码语言建模（masked language modeling）训练此模型时使用此标记。模型将尝试预测此标记。
sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法。可使用 SentencePiece 的 Python 封装来设置以下参数（以及其他参数）：
- enable_sampling: 启用子词正则化（subword regularization）。
- nbest_size: Unigram 的采样参数。对 BPE-Dropout 无效。
  - nbest_size = {0,1}: 不执行采样。
  - nbest_size > 1: 从 nbest_size 个结果中采样。
  - nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤-后向采样算法从所有假设（格）中采样。
- alpha: Unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的丢弃概率。

构建一个 DeBERTa-v2 分词器。基于 SentencePiece。

build_inputs_with_special_tokens

< source >

( 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

< source >

( 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

< source >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]

参数

token_ids_0 (list[int]) — 第一个分词后的序列。
token_ids_1 (list[int], 可选) — 第二个分词后的序列。

list[int]

标记类型 ID。

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

如果模型有特殊的构建方式，应在子类中重写此方法。

save_vocabulary

< source >

( save_directory: str filename_prefix: typing.Optional[str] = None )

DebertaV2TokenizerFast

class transformers.DebertaV2TokenizerFast

< source >

( 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 (string, 可选, 默认为 "[CLS]") — 序列开始标记，在预训练期间使用。可用作序列分类器标记。当使用特殊标记构建序列时，此标记不会用作序列的开头，而是使用 cls_token。
eos_token (string, 可选, 默认为 "[SEP]") — 序列结束标记。当使用特殊标记构建序列时，此标记不会用作序列的结尾，而是使用 sep_token。
unk_token (str, 可选, 默认为 "[UNK]") — 未知标记。词表中不存在的标记无法转换为ID，将被设置为此标记。
sep_token (str, 可选, 默认为 "[SEP]") — 分隔标记，用于从多个序列构建一个序列时，例如用于序列分类的两个序列，或用于问答任务的文本和问题。它也用作使用特殊标记构建的序列的最后一个标记。
pad_token (str, 可选, 默认为 "[PAD]") — 用于填充的标记，例如在批处理不同长度的序列时使用。
cls_token (str, 可选, 默认为 "[CLS]") — 分类器标记，在进行序列分类（对整个序列进行分类，而不是按标记分类）时使用。当使用特殊标记构建序列时，它是序列的第一个标记。
mask_token (str, 可选, 默认为 "[MASK]") — 用于掩盖值的标记。在使用掩码语言建模（masked language modeling）训练此模型时使用此标记。模型将尝试预测此标记。
sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法。可使用 SentencePiece 的 Python 封装来设置以下参数（以及其他参数）：
- enable_sampling: 启用子词正则化（subword regularization）。
- nbest_size: Unigram 的采样参数。对 BPE-Dropout 无效。
  - nbest_size = {0,1}: 不执行采样。
  - nbest_size > 1: 从 nbest_size 个结果中采样。
  - nbest_size < 0: 假设 nbest_size 是无限的，并使用前向过滤-后向采样算法从所有假设（格）中采样。
- alpha: Unigram 采样的平滑参数，以及 BPE-dropout 的合并操作的丢弃概率。

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

build_inputs_with_special_tokens

< source >

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

create_token_type_ids_from_sequences

< source >

( token_ids_0: list token_ids_1: typing.Optional[list[int]] = None ) → list[int]

参数

token_ids_0 (list[int]) — 第一个分词后的序列。
token_ids_1 (list[int], 可选) — 第二个分词后的序列。

list[int]

标记类型 ID。

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

如果模型有特殊的构建方式，应在子类中重写此方法。

Pytorch

隐藏 Pytorch 内容

DebertaV2Model

class transformers.DebertaV2Model

< source >

( config )

参数

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

基础的 Deberta V2 模型，输出没有任何特定头部的原始隐藏状态。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< source >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.BaseModelOutput or tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length), 可选) — 词汇表中输入序列标记的索引。默认情况下将忽略填充。

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

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

什么是 position ID？
inputs_embeds (torch.Tensor，形状为 (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），包含根据配置（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)。

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

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

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

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

DebertaV2PreTrainedModel

class transformers.DebertaV2PreTrainedModel

< 来源 >

( config: PretrainedConfig *inputs **kwargs )

参数

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

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

_forward_unimplemented

< 来源 >

( *input: typing.Any )

定义每次调用时执行的计算。

应由所有子类覆盖。

尽管前向传播的配方需要在该函数中定义，但之后应该调用 Module 实例而不是它，因为前者负责运行注册的钩子，而后者则默默地忽略它们。

DebertaV2ForMaskedLM

class transformers.DebertaV2ForMaskedLM

< 来源 >

( config )

参数

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

Deberta V2 模型，其顶部带有一个 语言建模 头。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< 来源 >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.MaskedLMOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列词元的索引。默认情况下，填充将被忽略。

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

什么是 input ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示词元未被掩码，
- 0 表示词元已被掩码。
什么是 attention mask？
token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一和第二部分的段落词元索引。索引在 [0, 1] 中选择：
- 0 对应于 *A 句* 词元，
- 1 对应于 *B 句* 词元。
什么是 token type ID？
position_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列词元的位置索引。取值范围为 [0, config.n_positions - 1]。

什么是 position ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以不传递 input_ids，而是直接传递嵌入表示。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关联的向量，这会非常有用。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 范围内（参见 input_ids 的文档字符串）。索引设置为 -100 的词元将被忽略（掩码），损失仅针对标签在 [0, ..., config.vocab_size] 范围内的词元计算。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

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

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

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

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

DebertaV2ForMaskedLM 的 forward 方法覆盖了 __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)
>>> tokenizer.decode(predicted_token_id)
...

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

DebertaV2ForSequenceClassification

class transformers.DebertaV2ForSequenceClassification

< 来源 >

( config )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< 来源 >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.SequenceClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列词元的索引。默认情况下，填充将被忽略。

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

什么是 input ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示词元未被掩码，
- 0 表示词元已被掩码。
什么是 attention mask？
token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一和第二部分的段落词元索引。索引在 [0, 1] 中选择：
- 0 对应于 *A 句* 词元，
- 1 对应于 *B 句* 词元。
什么是 token type ID？
position_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列词元的位置索引。取值范围为 [0, config.n_positions - 1]。

什么是 position ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以不传递 input_ids，而是直接传递嵌入表示。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关联的向量，这会非常有用。
labels (torch.LongTensor，形状为 (batch_size,)，可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。如果 config.num_labels == 1，则计算回归损失（均方损失），如果 config.num_labels > 1，则计算分类损失（交叉熵）。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

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

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

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

注意力 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()
>>> model.config.id2label[predicted_class_id]
...

>>> # 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
>>> round(loss.item(), 2)
...

多标签分类示例

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

class transformers.DebertaV2ForTokenClassification

< 来源 >

( config )

参数

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

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

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< 来源 >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None labels: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.TokenClassifierOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列词元的索引。默认情况下，填充将被忽略。

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

什么是 input ID？
attention_mask (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于避免对填充词元索引执行注意力的掩码。掩码值在 [0, 1] 中选择：
- 1 表示词元未被掩码，
- 0 表示词元已被掩码。
什么是 attention mask？
token_type_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 用于指示输入的第一和第二部分的段落词元索引。索引在 [0, 1] 中选择：
- 0 对应于 *A 句* 词元，
- 1 对应于 *B 句* 词元。
什么是 token type ID？
position_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 位置嵌入中每个输入序列词元的位置索引。取值范围为 [0, config.n_positions - 1]。

什么是 position ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以不传递 input_ids，而是直接传递嵌入表示。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为相关联的向量，这会非常有用。
labels (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 用于计算词元分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 范围内。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

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

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

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

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

DebertaV2ForTokenClassification 的 forward 方法覆盖了 __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]]
>>> predicted_tokens_classes
...

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

DebertaV2ForQuestionAnswering

class transformers.DebertaV2ForQuestionAnswering

< 来源 >

( config )

参数

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

Deberta V2 模型，其顶部带有一个用于抽取式问答任务（如 SQuAD）的片段分类头（一个在隐藏状态输出之上的线性层，用于计算 `span start logits` 和 `span end logits`）。

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

该模型也是 PyTorch torch.nn.Module 的子类。可以像常规的 PyTorch Module 一样使用它，并参考 PyTorch 文档了解所有与常规用法和行为相关的事项。

forward

< 来源 >

( input_ids: typing.Optional[torch.Tensor] = None attention_mask: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.Tensor] = None position_ids: typing.Optional[torch.Tensor] = None inputs_embeds: typing.Optional[torch.Tensor] = None start_positions: typing.Optional[torch.Tensor] = None end_positions: typing.Optional[torch.Tensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) → transformers.modeling_outputs.QuestionAnsweringModelOutput 或 tuple(torch.FloatTensor)

参数

input_ids (torch.Tensor，形状为 (batch_size, sequence_length)，可选) — 词汇表中输入序列标记的索引。默认情况下，填充将被忽略。

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

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

什么是位置 ID？
inputs_embeds (torch.Tensor，形状为 (batch_size, sequence_length, hidden_size)，可选) — 可选地，你可以选择直接传递嵌入式表示，而不是传递 input_ids。如果你想比模型内部的嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量，这会很有用。
start_positions (torch.Tensor，形状为 (batch_size,)，可选) — 用于计算标记分类损失的标记范围起点的标签位置（索引）。位置被限制在序列长度 (sequence_length) 内。计算损失时不考虑序列之外的位置。
end_positions (torch.Tensor，形状为 (batch_size,)，可选) — 用于计算标记分类损失的标记范围终点的标签位置（索引）。位置被限制在序列长度 (sequence_length) 内。计算损失时不考虑序列之外的位置。
output_attentions (bool，可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool，可选) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool，可选) — 是否返回一个 ModelOutput 而不是一个普通的元组。

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

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

loss (torch.FloatTensor of shape (1,), 可选, 当提供 labels 时返回) — 总范围提取损失是起始位置和结束位置的交叉熵之和。
start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 范围起始分数（SoftMax 之前）。
end_logits (torch.FloatTensor of shape (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)。

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

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

DebertaV2ForQuestionAnswering 的 forward 方法会覆盖 __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]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
...

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

Transformers

DeBERTa-v2

概述

资源

DebertaV2Config

class transformers.DebertaV2Config

DebertaV2Tokenizer

class transformers.DebertaV2Tokenizer

build_inputs_with_special_tokens

get_special_tokens_mask

create_token_type_ids_from_sequences

save_vocabulary

DebertaV2TokenizerFast

class transformers.DebertaV2TokenizerFast

build_inputs_with_special_tokens

create_token_type_ids_from_sequences

DebertaV2Model

class transformers.DebertaV2Model

forward

DebertaV2PreTrainedModel

class transformers.DebertaV2PreTrainedModel

_forward_unimplemented

DebertaV2ForMaskedLM

class transformers.DebertaV2ForMaskedLM

forward

DebertaV2ForSequenceClassification

class transformers.DebertaV2ForSequenceClassification

forward

DebertaV2ForTokenClassification

class transformers.DebertaV2ForTokenClassification

forward

DebertaV2ForQuestionAnswering

class transformers.DebertaV2ForQuestionAnswering

forward

DebertaV2ForMultipleChoice

class transformers.DebertaV2ForMultipleChoice

forward

TFDebertaV2Model

class transformers.TFDebertaV2Model

调用

TFDebertaV2PreTrainedModel

class transformers.TFDebertaV2PreTrainedModel

调用

TFDebertaV2ForMaskedLM

class transformers.TFDebertaV2ForMaskedLM

调用

TFDebertaV2ForSequenceClassification

class transformers.TFDebertaV2ForSequenceClassification

调用

TFDebertaV2ForTokenClassification

class transformers.TFDebertaV2ForTokenClassification

调用

TFDebertaV2ForQuestionAnswering

class transformers.TFDebertaV2ForQuestionAnswering

调用

TFDebertaV2ForMultipleChoice

class transformers.TFDebertaV2ForMultipleChoice

调用