Transformers 文档

ConvBERT

Transformers

加入 Hugging Face 社区

并获得增强型文档体验

协作模型、数据集和空间

使用加速推理的更快的示例

在文档主题之间切换

开始使用

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 贡献。原始实现可以在以下位置找到：https://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 时传递的 inputs_ids 可以表示的不同标记数量。
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) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
max_position_embeddings (int, 可选, 默认为 512) — 此模型可能使用的最大序列长度。通常将此值设置为一个较大值以防万一（例如，512 或 1024 或 2048）。
type_vocab_size (int, 可选, 默认为 2) — 调用 ConvBertModel 或 TFConvBertModel 时传递的 token_type_ids 的词汇量大小。
initializer_range (float, 可选, 默认为 0.02) — 初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
layer_norm_eps (float, 可选, 默认为 1e-12) — 层归一化层使用的 epsilon。
head_ratio (int, 可选, 默认为 2) — 减少注意力头的比率 gamma。
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 clean_up_tokenization_spaces = True **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, optional, defaults to "[SEP]") — 分隔符，用于在从多个序列构建一个序列时使用，例如用于序列分类的两个序列，或用于问答的文本和问题。它也用作以特殊标记构建的序列的最后一个标记。
pad_token (str, optional, defaults to "[PAD]") — 用于填充的标记，例如在对不同长度的序列进行批处理时。
cls_token (str, optional, defaults to "[CLS]") — 分类标记，用于执行序列分类（对整个序列进行分类，而不是对每个标记进行分类）。它是使用特殊标记构建的序列的第一个标记。
mask_token (str, optional, defaults to "[MASK]") — 用于屏蔽值的标记。这是在使用掩码语言建模训练此模型时使用的标记。这是模型将尝试预测的标记。
tokenize_chinese_chars (bool, optional, defaults to True) — 是否要对汉字进行分词。

这很可能应该对日语禁用（参见此 issue）。
strip_accents (bool, optional) — 是否要剥离所有重音符。如果未指定此选项，则将由lowercase的值决定（与原始 ConvBERT 中一样）。
clean_up_tokenization_spaces (bool, optional, defaults to True) — 是否在解码后清理空格，清理包括删除潜在的伪影，如多余的空格。

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

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

build_inputs_with_special_tokens

< source >

( token_ids_0: List token_ids_1: Optional = None ) → List[int]

参数

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

List[int]

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

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

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

get_special_tokens_mask

< source >

( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = 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 方法添加特殊标记时，会调用此方法。

create_token_type_ids_from_sequences

< source >

( token_ids_0: List token_ids_1: Optional = None ) → 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

< source >

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

create_token_type_ids_from_sequences

< 源代码 >

( token_ids_0: List token_ids_1: Optional = None ) → 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）。

Pytorch

隐藏 Pytorch 内容

ConvBertModel

class transformers.ConvBertModel

< 源代码 >

参数

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

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

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 后的注意力权重，用于计算自注意力头中的加权平均值。
cross_attentions (tuple(torch.FloatTensor), 可选, 当传递了 output_attentions=True 和 config.add_cross_attention=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组 (每一层一个) 形状为 (batch_size, num_heads, sequence_length, sequence_length)。

解码器交叉注意力层的注意力权重，在注意力 softmax 之后，用于计算交叉注意力头中的加权平均值。

ConvBertModel 的 forward 方法覆盖了 __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 (ConvBertConfig) — 模型配置类，包含模型的所有参数。使用配置文件初始化不会加载与模型相关的权重，只会加载配置。查看 from_pretrained() 方法来加载模型权重。

在 ConvBERT 模型上添加了 语言建模 头部。此模型是 PyTorch torch.nn.Module 的子类。将其用作常规 PyTorch 模块，并参考 PyTorch 文档以获取有关一般使用和行为的所有事项。

forward

< source >

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

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 输入序列token在词表中的索引。

索引可以通过 AutoTokenizer 获得。详细信息请参见 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。

什么是输入 ID?
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免对填充token索引进行注意的掩码。掩码值选择在 [0, 1] 中：

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

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

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

The ConvBertForMaskedLM forward method, overrides the __call__ special method.

示例

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

< source >

参数

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

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

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

forward

< source >

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

参数

input_ids (torch.LongTensor 形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
attention_mask (torch.FloatTensor 形状为 (batch_size, sequence_length), 可选) — 掩码以避免对填充标记索引执行注意力操作。掩码值选择在 [0, 1] 中：

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

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

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

The ConvBertForSequenceClassification 正向方法，覆盖 __call__ 特殊方法。

单标签分类示例

>>> 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 (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 ) → transformers.modeling_outputs.MultipleChoiceModelOutput 或 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 时返回) — 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 后的注意力权重，用于计算自注意力头中的加权平均值。

该 ConvBertForMultipleChoice 正向方法覆盖了 __call__ 特殊方法。

示例

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

< source >

参数

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

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

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

forward

< source >

( 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 ) → transformers.modeling_outputs.TokenClassifierOutput 或 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 形状为 (1,)，可选，当提供 labels 时返回) — 分类损失。
logits (torch.FloatTensor 形状为 (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)。

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

注意力 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

< source >

参数

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

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

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

forward

< source >

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

A transformers.modeling_outputs.QuestionAnsweringModelOutput 或 torch.FloatTensor 的元组（如果传递了 return_dict=False 或 config.return_dict=False），包含根据配置 (ConvBertConfig) 和输入而不同的各种元素。

loss (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)。

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

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

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

示例

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

Transformers

ConvBERT

概述

使用技巧

资源

ConvBertConfig

class transformers.ConvBertConfig

ConvBertTokenizer

class transformers.ConvBertTokenizer

build_inputs_with_special_tokens

get_special_tokens_mask

create_token_type_ids_from_sequences

save_vocabulary

ConvBertTokenizerFast

class transformers.ConvBertTokenizerFast

build_inputs_with_special_tokens

create_token_type_ids_from_sequences

ConvBertModel

class transformers.ConvBertModel

forward

ConvBertForMaskedLM

class transformers.ConvBertForMaskedLM

forward

ConvBertForSequenceClassification

class transformers.ConvBertForSequenceClassification

forward

ConvBertForMultipleChoice

class transformers.ConvBertForMultipleChoice

forward

ConvBertForTokenClassification

class transformers.ConvBertForTokenClassification

forward

ConvBertForQuestionAnswering

class transformers.ConvBertForQuestionAnswering

forward

TFConvBertModel

class transformers.TFConvBertModel

调用

TFConvBertForMaskedLM

class transformers.TFConvBertForMaskedLM

调用

TFConvBertForSequenceClassification

class transformers.TFConvBertForSequenceClassification

调用

TFConvBertForMultipleChoice

class transformers.TFConvBertForMultipleChoice

调用

TFConvBertForTokenClassification

class transformers.TFConvBertForTokenClassification

调用

TFConvBertForQuestionAnswering

class transformers.TFConvBertForQuestionAnswering

调用