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

原文：huggingface.co/docs/transformers

CANINE

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

概述

CANINE 模型是由 Jonathan H. Clark、Dan Garrette、Iulia Turc、John Wieting 在CANINE: Pre-training an Efficient Tokenization-Free Encoder for Language Representation中提出的。这是第一篇在训练 Transformer 时不使用显式分词步骤（如字节对编码（BPE）、WordPiece 或 SentencePiece）的论文之一。相反，该模型直接在 Unicode 字符级别进行训练。在字符级别进行训练不可避免地会导致更长的序列长度，CANINE 通过高效的下采样策略解决了这个问题，然后应用深度 Transformer 编码器。

论文中的摘要如下：

流水线式 NLP 系统在很大程度上已被端到端的神经建模所取代，然而几乎所有常用的模型仍需要显式的分词步骤。最近基于数据衍生的子词词汇的分词方法比手工设计的分词器更加灵活，但这些技术并不适用于所有语言，并且任何固定词汇的使用可能会限制模型的适应能力。在本文中，我们提出了 CANINE，一个神经编码器，直接在字符序列上操作，无需显式的分词或词汇表，并且一个预训练策略，可以直接在字符上操作，或者可选地使用子词作为软归纳偏差。为了有效和高效地使用其更精细的输入，CANINE 结合了下采样（减少输入序列长度）和深度 Transformer 堆栈（编码上下文）。尽管模型参数少了 28%，但 CANINE 在具有挑战性的多语言基准测试 TyDi QA 上比可比的 mBERT 模型表现出 2.8 F1 的优势。

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

使用提示

CANINE 在内部使用不少于 3 个 Transformer 编码器：2 个“浅层”编码器（仅包含一个单层）和 1 个“深层”编码器（正常的 BERT 编码器）。首先，使用“浅层”编码器对字符嵌入进行上下文化，使用局部注意力。接下来，在下采样后，应用“深层”编码器。最后，在上采样后，使用“浅层”编码器创建最终的字符嵌入。有关上采样和下采样的详细信息可以在论文中找到。
CANINE 默认使用最大序列长度为 2048 个字符。可以使用 CanineTokenizer 为模型准备文本。
分类可以通过在特殊[CLS]标记的最终隐藏状态上放置一个线性层来完成（该标记具有预定义的 Unicode 代码点）。然而，对于标记分类任务，需要将下采样的标记序列再次上采样，以匹配原始字符序列的长度（为 2048）。关于这一点的详细信息可以在论文中找到。

模型检查点：

google/canine-c：预训练使用自回归字符损失，12 层，768 隐藏，12 头，121M 参数（大小约为 500 MB）。
google/canine-s：预训练使用子词损失，12 层，768 隐藏，12 头，121M 参数（大小约为 500 MB）。

使用示例

CANINE 在原始字符上工作，因此可以在不使用分词器的情况下使用：

>>> from transformers import CanineModel
>>> import torch
>>> model = CanineModel.from_pretrained("google/canine-c")  # model pre-trained with autoregressive character loss
>>> text = "hello world"
>>> # use Python's built-in ord() function to turn each character into its unicode code point id
>>> input_ids = torch.tensor([[ord(char) for char in text]])
>>> outputs = model(input_ids)  # forward pass
>>> pooled_output = outputs.pooler_output
>>> sequence_output = outputs.last_hidden_state

然而，对于批量推理和训练，建议使用分词器（将所有序列填充/截断到相同长度）：

>>> from transformers import CanineTokenizer, CanineModel
>>> model = CanineModel.from_pretrained("google/canine-c")
>>> tokenizer = CanineTokenizer.from_pretrained("google/canine-c")
>>> inputs = ["Life is like a box of chocolates.", "You never know what you gonna get."]
>>> encoding = tokenizer(inputs, padding="longest", truncation=True, return_tensors="pt")
>>> outputs = model(**encoding)  # forward pass
>>> pooled_output = outputs.pooler_output
>>> sequence_output = outputs.last_hidden_state

资源

文本分类任务指南
标记分类任务指南
问答任务指南
多选任务指南

CanineConfig

`class transformers.CanineConfig`

< source >

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

参数

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

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

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

示例：

>>> from transformers import CanineConfig, CanineModel
>>> # Initializing a CANINE google/canine-s style configuration
>>> configuration = CanineConfig()
>>> # Initializing a model (with random weights) from the google/canine-s style configuration
>>> model = CanineModel(configuration)
>>> # Accessing the model configuration
>>> configuration = model.config

CanineTokenizer

`class transformers.CanineTokenizer`

< source >

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

参数

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

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

CanineTokenizer 继承自 PreTrainedTokenizer。

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

`build_inputs_with_special_tokens`

<来源>

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

参数

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

List[int]

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

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

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

`get_special_tokens_mask`

<来源>

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

参数

token_ids_0（List[int]）— ID 列表。
token_ids_1（List[int]，可选）— 序列对的可选第二个 ID 列表。
already_has_special_tokens（bool，可选，默认为False）— 标记列表是否已经使用特殊标记格式化为模型。

List[int]

一个整数列表，范围为[0, 1]：1 表示特殊标记，0 表示序列标记。

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

`create_token_type_ids_from_sequences`

<来源>

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

参数

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

List[int]

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

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

序列对掩码的格式如下：

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

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

CANINE 特定输出

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

<来源>

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

参数

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

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

CanineModel

`class transformers.CanineModel`

< source >

( config add_pooling_layer = True )

参数

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

裸的 CANINE 模型变压器输出原始隐藏状态，没有任何特定的头部。这个模型是一个 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 output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) → export const metadata = 'undefined';transformers.models.canine.modeling_canine.CanineModelOutputWithPooling or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

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

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

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

什么是标记类型 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的选定头部失效的掩码。掩码值选择在[0, 1]之间：

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

inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示而不是传递input_ids。如果您想要更多控制如何将input_ids索引转换为相关向量，这将很有用，而不是使用模型的内部嵌入查找矩阵。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量中的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量中的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。

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

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

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

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

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

示例：

>>> from transformers import AutoTokenizer, CanineModel
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineModel.from_pretrained("google/canine-s")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> outputs = model(**inputs)
>>> last_hidden_states = outputs.last_hidden_state

CanineForSequenceClassification

`class transformers.CanineForSequenceClassification`

<来源>

( config )

参数

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

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

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

`forward`

<来源>

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

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode() 和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择：

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

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

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

什么是标记类型 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
什么是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。掩码值在 [0, 1] 中选择：

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

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

返回值

transformers.modeling_outputs.SequenceClassifierOutput 或torch.FloatTensor元组

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

loss (torch.FloatTensor，形状为(1,)，可选，当提供labels时返回) — 分类（如果config.num_labels==1则为回归）损失。
logits (torch.FloatTensor，形状为(batch_size, config.num_labels)) — 分类（如果config.num_labels==1则为回归）得分（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出加上每层的输出）。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

单标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, CanineForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s", num_labels=num_labels)
>>> labels = torch.tensor([1])
>>> loss = model(**inputs, labels=labels).loss

多标签分类示例：

>>> import torch
>>> from transformers import AutoTokenizer, CanineForSequenceClassification
>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForSequenceClassification.from_pretrained("google/canine-s", problem_type="multi_label_classification")
>>> inputs = tokenizer("Hello, my dog is cute", return_tensors="pt")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_ids = torch.arange(0, logits.shape[-1])[torch.sigmoid(logits).squeeze(dim=0) > 0.5]
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CanineForSequenceClassification.from_pretrained(
...     "google/canine-s", num_labels=num_labels, problem_type="multi_label_classification"
... )
>>> labels = torch.sum(
...     torch.nn.functional.one_hot(predicted_class_ids[None, :].clone(), num_classes=num_labels), dim=1
... ).to(torch.float)
>>> loss = model(**inputs, labels=labels).loss

CanineForMultipleChoice

`class transformers.CanineForMultipleChoice`

<来源>

( config )

参数

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

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

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

`forward`

<来源>

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

参数

input_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length)) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask (torch.FloatTensor of shape (batch_size, num_choices, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]范围内：

1 表示未被masked的标记，
0 表示被masked的标记。

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

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

什么是标记类型 ID？
position_ids (torch.LongTensor of shape (batch_size, num_choices, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围为[0, config.max_position_embeddings - 1]。
什么是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块中选择的头部失效的掩码。选择的掩码值在[0, 1]范围内：

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

inputs_embeds (torch.FloatTensor of shape (batch_size, num_choices, sequence_length, hidden_size), optional) — 可选地，您可以选择直接传递嵌入表示，而不是传递input_ids。如果您想要更多控制权来将input_ids索引转换为相关向量，这将非常有用，而不是使用模型的内部嵌入查找矩阵。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参见返回张量下的attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参见返回张量下的hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor of shape (batch_size,), optional) — 用于计算多项选择分类损失的标签。索引应在[0, ..., num_choices-1]范围内，其中num_choices是输入张量第二维的大小。（参见上面的input_ids）

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

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

loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 分类损失。
logits (torch.FloatTensor of shape (batch_size, num_choices)) — num_choices是输入张量的第二维度。（参见上面的input_ids）。
分类得分（在 SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — Tuple of torch.FloatTensor (one for the output of the embeddings, if the model has an embedding layer, + one for the output of each layer) of shape (batch_size, sequence_length, hidden_size)。
模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 元组torch.FloatTensor（每层一个）的形状为(batch_size, num_heads, sequence_length, sequence_length)。
在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

>>> from transformers import AutoTokenizer, CanineForMultipleChoice
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForMultipleChoice.from_pretrained("google/canine-s")
>>> prompt = "In Italy, pizza served in formal settings, such as at a restaurant, is presented unsliced."
>>> choice0 = "It is eaten with a fork and a knife."
>>> choice1 = "It is eaten while held in the hand."
>>> labels = torch.tensor(0).unsqueeze(0)  # choice0 is correct (according to Wikipedia ;)), batch size 1
>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="pt", padding=True)
>>> outputs = model(**{k: v.unsqueeze(0) for k, v in encoding.items()}, labels=labels)  # batch size is 1
>>> # the linear classifier still needs to be trained
>>> loss = outputs.loss
>>> logits = outputs.logits

CanineForTokenClassification

`class transformers.CanineForTokenClassification`

< source >

( config )

参数

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

在顶部带有令牌分类头的 CANINE 模型（在隐藏状态输出的顶部有一个线性层），例如用于命名实体识别（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 ) → export const metadata = 'undefined';transformers.modeling_outputs.TokenClassifierOutput or tuple(torch.FloatTensor)

参数

input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 词汇表中输入序列标记的索引。
可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。
什么是输入 ID？
attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选在[0, 1]之间：

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

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

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

什么是标记类型 ID？
position_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 每个输入序列标记在位置嵌入中的位置索引。选择范围在 [0, config.max_position_embeddings - 1] 中。
什么是位置 ID？
head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于使自注意力模块的特定头部失效的掩码。掩码值选择在 [0, 1] 中：

1 表示头部未被掩盖。
0 表示头部被掩盖。

inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地，可以直接传递嵌入表示，而不是传递 input_ids。如果您想要更多控制权来将 input_ids 索引转换为相关向量，而不是模型的内部嵌入查找矩阵，则这很有用。
output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。有关更多详细信息，请参阅返回张量下的 attentions。
output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。有关更多详细信息，请参阅返回张量下的 hidden_states。
return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通元组。
labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算标记分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

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

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

loss (torch.FloatTensor of shape (1,), optional, returned when labels is provided) — 分类损失。
logits (torch.FloatTensor of shape (batch_size, sequence_length, config.num_labels)) — 分类分数（SoftMax 之前）。
hidden_states (tuple(torch.FloatTensor), optional, returned when output_hidden_states=True is passed or when config.output_hidden_states=True) — 由 torch.FloatTensor 组成的元组（如果模型有嵌入层，则为嵌入的输出 + 每个层的输出）的形状为 (batch_size, sequence_length, hidden_size)。
每层模型的隐藏状态加上可选的初始嵌入输出。
attentions (tuple(torch.FloatTensor), optional, returned when output_attentions=True is passed or when config.output_attentions=True) — 由 torch.FloatTensor 组成的元组（每层一个）的形状为 (batch_size, num_heads, sequence_length, sequence_length)。
在自注意力头中用于计算加权平均值的注意力 softmax 后的注意力权重。

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

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

示例：

>>> from transformers import AutoTokenizer, CanineForTokenClassification
>>> import torch
>>> tokenizer = AutoTokenizer.from_pretrained("google/canine-s")
>>> model = CanineForTokenClassification.from_pretrained("google/canine-s")
>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="pt"
... )
>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_token_class_ids = logits.argmax(-1)
>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]
>>> predicted_tokens_classes

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

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

Transformers 4.37 中文文档（二十七）（1）

CANINE

概述

使用提示

使用示例

资源

CanineConfig

`class transformers.CanineConfig`

CanineTokenizer

`class transformers.CanineTokenizer`

`build_inputs_with_special_tokens`

`get_special_tokens_mask`

`create_token_type_ids_from_sequences`

CANINE 特定输出

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

CanineModel

`class transformers.CanineModel`

`forward`

CanineForSequenceClassification

`class transformers.CanineForSequenceClassification`

`forward`

CanineForMultipleChoice

`class transformers.CanineForMultipleChoice`

`forward`

CanineForTokenClassification

`class transformers.CanineForTokenClassification`

`forward`

热门文章

最新文章

相关课程

相关电子书

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Transformers 4.37 中文文档（二十七）（1）

CANINE

概述

使用提示

使用示例

资源

CanineConfig

class transformers.CanineConfig

CanineTokenizer

class transformers.CanineTokenizer

build_inputs_with_special_tokens

get_special_tokens_mask

create_token_type_ids_from_sequences

CANINE 特定输出

class transformers.models.canine.modeling_canine.CanineModelOutputWithPooling

CanineModel

class transformers.CanineModel

forward

CanineForSequenceClassification

class transformers.CanineForSequenceClassification

forward

CanineForMultipleChoice

class transformers.CanineForMultipleChoice

forward

CanineForTokenClassification

class transformers.CanineForTokenClassification

forward

热门文章

最新文章

相关课程

相关电子书

`class transformers.CanineConfig`

`class transformers.CanineTokenizer`

`build_inputs_with_special_tokens`

`get_special_tokens_mask`

`create_token_type_ids_from_sequences`

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

`class transformers.CanineModel`

`forward`

`class transformers.CanineForSequenceClassification`

`forward`

`class transformers.CanineForMultipleChoice`

`forward`

`class transformers.CanineForTokenClassification`

`forward`