Transformers 4.37 中文文档（二十八）

2024-06-26 15:44:43 浏览数 (1)

原文：huggingface.co/docs/transformers

CPM

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

概述

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

论文摘要如下：

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

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

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

CpmTokenizer

class transformers.CpmTokenizer

<来源>

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

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

build_inputs_with_special_tokens

<来源>

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

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

返回

List[int]

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

通过连接和添加特殊标记，为序列分类任务构建模型输入，输入为单个序列或序列对。一个 XLNet 序列的格式如下：

  • 单个序列：X <sep> <cls>
  • 序列对：A <sep> B <sep> <cls>
convert_tokens_to_string

<来源>

代码语言：javascript复制
( tokens )

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

create_token_type_ids_from_sequences

<来源>

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

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

返回

List[int]

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

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

序列对掩码的格式如下：

代码语言：javascript复制
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

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

get_special_tokens_mask

<来源>

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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

返回

List[int]

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

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

CpmTokenizerFast

class transformers.CpmTokenizerFast

<来源>

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

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

build_inputs_with_special_tokens

<来源>

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

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

返回

List[int]

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

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

  • 单个序列：X <sep> <cls>
  • 序列对：A <sep> B <sep> <cls>
create_token_type_ids_from_sequences

<来源>

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None ) → export const metadata = 'undefined';List[int]

参数

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

返回

List[int]

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

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

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

代码语言：javascript复制
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence    | second sequence |

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

CPMAnt

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

概述

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

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

资源

  • 一个关于CPM-Live的教程。

CpmAntConfig

class transformers.CpmAntConfig

<来源>

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

参数

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

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

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

示例：

代码语言：javascript复制
>>> from transformers import CpmAntModel, CpmAntConfig

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

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

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

CpmAntTokenizer

class transformers.CpmAntTokenizer

<来源>

代码语言：javascript复制
( vocab_file bod_token = '<d>' eod_token = '</d>' bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' unk_token = '<unk>' line_token = '</n>' space_token = '</_>' padding_side = 'left' **kwargs )

参数

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

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

build_inputs_with_special_tokens

<源代码>

代码语言：javascript复制
( token_ids_0: List token_ids_1: List = None ) → export const metadata = 'undefined';List[int]

参数

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

返回

List[int]

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

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

  • 单个序列：[BOS] Sequence。
get_special_tokens_mask

<源代码>

代码语言：javascript复制
( token_ids_0: List token_ids_1: Optional = None already_has_special_tokens: bool = False ) → export const metadata = 'undefined';List[int]

参数

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

返回

List[int]

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

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

CpmAntModel

class transformers.CpmAntModel

<源代码>

代码语言：javascript复制
( config: CpmAntConfig )

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

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

forward

<源代码>

代码语言：javascript复制
( input_ids: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None past_key_values: Optional = None use_cache: Optional = None return_dict: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.BaseModelOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids（形状为(batch_size, seq_len)的torch.Tensor）— 词汇表中输入序列标记的索引。 可以使用CPMAntTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或者当config.use_cache=True时返回） — 包含预计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。
  • use_cache（bool，可选） — 如果设置为True，则返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
  • output_attentions（bool，可选） — 是否返回所有注意力层的注意力张量。
  • output_hidden_states（bool，可选） — 是否返回所有层的隐藏状态。
  • return_dict（bool，可选） — 是否返回 ModelOutput 而不是普通元组。

返回

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

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

  • last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor） — 模型最后一层的隐藏状态序列。 如果仅使用past_key_values，则输出形状为(batch_size, 1, hidden_size)的序列的最后一个隐藏状态。
  • past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递了use_cache=True或者当config.use_cache=True时返回） — 长度为config.n_layers的元组tuple(torch.FloatTensor)，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，并且如果config.is_encoder_decoder=True，还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预计算的隐藏状态（自注意力块中的键和值，以及如果config.is_encoder_decoder=True，则包含交叉注意力块中的键和值），可用于加速顺序解码。
  • hidden_states（tuple(torch.FloatTensor)，可选，当传递了output_hidden_states=True或者当config.output_hidden_states=True时返回） — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入的输出 每层的输出）。 模型在每一层的输出隐藏状态以及可选的初始嵌入输出。
  • attentions（tuple(torch.FloatTensor)，可选，当传递了output_attentions=True或者当config.output_attentions=True时返回） — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力权重经过注意力 softmax 后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, CpmAntModel
>>> import torch

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

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

>>> last_hidden_states = outputs.last_hidden_state

CpmAntForCausalLM

class transformers.CpmAntForCausalLM

<来源>

代码语言：javascript复制
( config: CpmAntConfig )

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

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

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

forward

<来源>

代码语言：javascript复制
( input_ids: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None labels: Optional = None return_dict: Optional = None attention_mask: Optional = None **kwargs ) → export const metadata = 'undefined';transformers.modeling_outputs.CausalLMOutputWithPast or tuple(torch.FloatTensor)

参数

  • input_ids（形状为（batch_size，seq_len）的torch.Tensor） - 词汇表中输入序列标记的索引。 可以使用CPMAntTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？
  • past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回） - 包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。
  • use_cache（bool，可选） - 如果设置为True，将返回past_key_values键值状态，可用于加速解码（参见past_key_values）。
  • output_attentions（bool，可选） - 是否返回所有注意力层的注意力张量。
  • output_hidden_states（bool，可选） - 是否返回所有层的隐藏状态。
  • return_dict（bool，可选） - 是否返回 ModelOutput 而不是普通元组。 参数 - 输入 ID（形状为（batch_size，seq_len）的torch.Tensor）：词汇表中输入序列标记的索引。 可以使用CPMAntTokenizer获取索引。有关详细信息，请参阅 PreTrainedTokenizer.encode()和 PreTrainedTokenizer.call()。 什么是输入 ID？ past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回：包含预先计算的隐藏状态（自注意力块和交叉注意力块中的键和值），可用于加速顺序解码。 use_cache (bool, optional): 如果设置为True，将返回past_key_values键值状态，并可用于加速解码（参见past_key_values）。 output_attentions (bool, optional): 是否返回所有注意力层的注意力张量。 output_hidden_states (bool, optional): 是否返回所有层的隐藏状态。 labels (torch.Tensor，形状为(batch_size, sequence_length)，optional): 用于计算掩码语言建模损失的标签。 return_dict (bool，optional): 是否返回 ModelOutput 而不是普通元组。 attention_mask (torch.Tensor，形状为(batch_size, sequence_length)，optional): CPMAnt 将自动处理注意力掩码，此参数是文本生成流水线的虚拟参数。 示例 —
  • 使用 CpmAntForCausalLM 进行文本生成。 —

返回

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

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

  • loss (torch.FloatTensor，形状为(1,)，optional，当提供labels时返回) — 语言建模损失（用于下一个标记预测）。
  • logits (torch.FloatTensor，形状为(batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  • past_key_values (tuple(tuple(torch.FloatTensor)), optional, 当传递use_cache=True或config.use_cache=True时返回 — 长度为config.n_layers的元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（参见past_key_values输入）。
  • hidden_states (tuple(torch.FloatTensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回 — 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组。 模型在每一层输出的隐藏状态加上可选的初始嵌入输出。
  • attentions (tuple(torch.FloatTensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回 — 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> import torch
>>> from transformers import AutoTokenizer, CpmAntForCausalLM

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

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

CTRL

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

概述

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

论文摘要如下:

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

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

使用提示

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

资源

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

CTRLConfig

class transformers.CTRLConfig

<源代码>

代码语言：javascript复制
( vocab_size = 246534 n_positions = 256 n_embd = 1280 dff = 8192 n_layer = 48 n_head = 16 resid_pdrop = 0.1 embd_pdrop = 0.1 layer_norm_epsilon = 1e-06 initializer_range = 0.02 use_cache = True **kwargs )

参数

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

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

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

示例：

代码语言：javascript复制
>>> from transformers import CTRLConfig, CTRLModel

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

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

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

CTRLTokenizer

class transformers.CTRLTokenizer

< source >

代码语言：javascript复制
( vocab_file merges_file unk_token = '<unk>' **kwargs )

参数

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

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

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

save_vocabulary

< source >

代码语言：javascript复制
( save_directory: str filename_prefix: Optional = None )

PytorchHide Pytorch content

CTRLModel

class transformers.CTRLModel

< source >

代码语言：javascript复制
( config )

参数

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

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

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

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

forward

<来源>

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

参数

  • input_ids（形状为(batch_size, sequence_length)的torch.LongTensor）— 如果past_key_values为None，则input_ids_length=sequence_length，否则past_key_values[0].shape[-2]（输入过去关键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用了past_key_values，则只应将未计算其过去的输入 ID 作为input_ids传递。 可以使用 AutoTokenizer 来获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
  • past_key_values（长度为config.n_layers的Tuple[Tuple[torch.FloatTensor]]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参阅下面的past_key_values输出）。可用于加速顺序解码。已经计算过其过去的input_ids不应作为输入 ID 传递给此模型。
  • attention_mask（形状为(batch_size, sequence_length)的torch.FloatTensor，可选）— 用于避免在填充标记索引上执行注意力的掩码。选择的掩码值在[0, 1]之间：
    • 1 表示未被masked的标记，
    • 0 表示被masked的标记。

    什么是注意力掩码？

  • token_type_ids（形状为(batch_size, sequence_length)的torch.LongTensor，可选）— 指示输入的第一部分和第二部分的段标记索引。选择的索引在[0, 1]中：
    • 0 对应于句子 A标记，
    • 1 对应于句子 B标记。

    什么是标记类型 ID？

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

返回

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

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

  • last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor）-模型最后一层的隐藏状态序列输出。 如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)序列的最后一个隐藏状态。
  • past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或config.use_cache=True时返回）-长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量，如果config.is_encoder_decoder=True，还有 2 个额外的形状为(batch_size, num_heads, encoder_sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值以及可选地在交叉注意力块中，如果config.is_encoder_decoder=True，可以使用的）（请参见past_key_values输入）以加速顺序解码。
  • hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回）-形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型具有嵌入层的输出，则为一个 每层输出的一个）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或config.output_attentions=True时返回）-形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, CTRLModel
>>> import torch

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

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

>>> outputs = model(**inputs)

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

CTRLLMHeadModel

class transformers.CTRLLMHeadModel

<来源>

代码语言：javascript复制
( config )

参数

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

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

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

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

forward

< source >

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

参数

  • input_ids (torch.LongTensor of shape (batch_size, sequence_length)) — 如果 past_key_values 为 None，则 input_ids_length = sequence_length，否则为 past_key_values[0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用了 past_key_values，则只应将未计算其过去的输入 ID 作为 input_ids 传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。 什么是 input IDs?
  • past_key_values (Tuple[Tuple[torch.FloatTensor]] of length config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值）（请参见下面的 past_key_values 输出）。可用于加速顺序解码。已给出其过去的 input_ids 不应作为输入 ID 传递给此模型，因为它们已经计算过。
  • attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
    • 1 表示 not masked 的标记，
    • 0 表示 masked 的标记。

    什么是 attention masks?

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段标记索引，指示输入的第一部分和第二部分。索引选择在 [0, 1]：
    • 0 对应于 句子 A 标记，
    • 1 对应于 句子 B 标记。

    什么是 token type IDs?

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

返回

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

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

  • loss（形状为(1,)的torch.FloatTensor，可选，当提供labels时返回）— 语言建模损失（用于下一个标记预测）。
  • logits（形状为(batch_size, sequence_length, config.vocab_size)的torch.FloatTensor）— 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  • past_key_values（tuple(tuple(torch.FloatTensor))，可选，当传递use_cache=True或者当config.use_cache=True时返回）— 长度为config.n_layers的tuple(torch.FloatTensor)元组，每个元组有 2 个形状为(batch_size, num_heads, sequence_length, embed_size_per_head)的张量。 包含预先计算的隐藏状态（自注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。
  • hidden_states（tuple(torch.FloatTensor)，可选，当传递output_hidden_states=True或者当config.output_hidden_states=True时返回）— 形状为(batch_size, sequence_length, hidden_size)的torch.FloatTensor元组（如果模型有嵌入层，则为嵌入输出和每一层的输出）。 模型在每一层输出的隐藏状态以及可选的初始嵌入输出。
  • attentions（tuple(torch.FloatTensor)，可选，当传递output_attentions=True或者当config.output_attentions=True时返回）— 形状为(batch_size, num_heads, sequence_length, sequence_length)的torch.FloatTensor元组（每层一个）。 注意力权重在注意力 softmax 之后，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> import torch
>>> from transformers import AutoTokenizer, CTRLLMHeadModel

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

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

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

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

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

CTRLForSequenceClassification

class transformers.CTRLForSequenceClassification

< source >

代码语言：javascript复制
( config )

参数

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

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

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

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

forward

< source >

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

参数

  • input_ids (torch.LongTensor，形状为 (batch_size, sequence_length)) — input_ids_length = sequence_length 如果 past_key_values 是 None，否则 past_key_values[0].shape[-2]（输入过去键值状态的序列长度）。词汇表中输入序列标记的索引。 如果使用了 past_key_values，则只能传递那些没有计算过其过去的输入 ID 作为 input_ids。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。 什么是输入 ID？
  • past_key_values (Tuple[Tuple[torch.FloatTensor]]，长度为 config.n_layers) — 包含由模型计算的预计算隐藏状态（注意力块中的键和值），如下面的 past_key_values 输出所示。可用于加速顺序解码。将其过去传递给该模型的 input_ids 不应作为输入 ID 传递，因为它们已经计算过。
  • attention_mask (torch.FloatTensor，形状为 (batch_size, sequence_length)，可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值选择在 [0, 1]：
    • 1 表示标记是 未掩盖的，
    • 0 表示标记是 被掩盖的。

    什么是注意力掩码？

  • token_type_ids (torch.LongTensor，形状为 (batch_size, sequence_length)，可选) — 指示输入的第一部分和第二部分的段标记索引。索引选择在 [0, 1]：
    • 0 对应于一个 句子 A 的标记，
    • 1 对应于一个 句子 B 的标记。

    什么是标记类型 ID？

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

返回值

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

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

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

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

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

单标签分类示例：

代码语言：javascript复制
>>> import torch
>>> from transformers import AutoTokenizer, CTRLForSequenceClassification

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

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

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

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'LABEL_0'
代码语言：javascript复制
>>> import torch

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

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

多标签分类示例：

代码语言：javascript复制
>>> import torch
>>> from transformers import AutoTokenizer, CTRLForSequenceClassification

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

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

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

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'LABEL_0'
代码语言：javascript复制
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = CTRLForSequenceClassification.from_pretrained("Salesforce/ctrl", num_labels=num_labels)

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

TensorFlowHide TensorFlow 内容

TFCTRLModel

class transformers.TFCTRLModel

< source >

代码语言：javascript复制
( config *inputs **kwargs )

参数

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

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

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

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

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

  • 将所有输入作为关键字参数（类似于 PyTorch 模型），
  • 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于有了这种支持，当使用model.fit()等方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，比如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可以用来收集所有输入张量在第一个位置参数中：

  • 一个只包含input_ids的单个张量，没有其他内容：model(input_ids)
  • 一个长度可变的列表，其中包含一个或多个输入张量，按照文档字符串中给定的顺序：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
  • 一个字典，其中包含与文档字符串中给定的输入名称相关联的一个或多个输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用子类化创建模型和层时，您无需担心这些问题，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

call

< source >

代码语言：javascript复制
( input_ids: TFModelInputType | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFBaseModelOutputWithPast or tuple(tf.Tensor)

参数

  • input_ids（形状为(batch_size, input_ids_length)的Numpy数组或tf.Tensor） — input_ids_length = sequence_length，如果past为None，则为past[0].shape[-2]（输入过去键值状态的序列长度）。 输入序列标记在词汇表中的索引。 如果使用past，则只能将未计算其过去的输入 ID 作为input_ids传递。 可以使用 AutoTokenizer 获取索引。查看 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()获取详细信息。 什么是输入 ID？
  • past（长度为config.n_layers的List[tf.Tensor]） — 包含由模型计算的预先计算的隐藏状态（注意块中的键和值），如下面的past输出所示。可用于加速顺序解码。已经计算过其过去的令牌 ID 不应作为输入 ID 传递给此模型。
  • attention_mask（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选）— 用于避免在填充标记索引上执行注意力的掩码。掩码值在[0, 1]中选择：
    • 1 表示未被masked的标记，
    • 0 表示被masked的标记。

    什么是注意力掩码？

  • token_type_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy array，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
    • 0 对应于句子 A的标记，
    • 1 对应于句子 B的标记。

    什么是标记类型 ID？

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

返回

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

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

  • last_hidden_state（形状为(batch_size, sequence_length, hidden_size)的tf.Tensor）— 模型最后一层的隐藏状态序列。 如果使用past_key_values，则仅输出形状为(batch_size, 1, hidden_size)的序列的最后隐藏状态。
  • past_key_values（List[tf.Tensor]，可选，当传递use_cache=True或config.use_cache=True时返回）— 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)）。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（请参见past_key_values输入）。
  • hidden_states (tuple(tf.Tensor), 可选，当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 一个用于每个层的输出）。 模型在每个层的输出处的隐藏状态加上初始嵌入输出。
  • attentions (tuple(tf.Tensor), 可选，当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每个层一个）。 在注意力 softmax 之后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, TFCTRLModel
>>> import tensorflow as tf

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

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

>>> last_hidden_states = outputs.last_hidden_state

TFCTRLLMHeadModel

class transformers.TFCTRLLMHeadModel

<来源>

代码语言：javascript复制
( config *inputs **kwargs )

参数

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

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

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

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

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

  • 将所有输入作为关键字参数（类似于 PyTorch 模型），或者
  • 将所有输入作为列表、元组或字典的第一个位置参数。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持，当使用诸如model.fit()之类的方法时，应该可以“正常工作” - 只需以model.fit()支持的任何格式传递输入和标签！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 KerasFunctional API 创建自己的层或模型时，有三种可能性可用于收集第一个位置参数中的所有输入张量：

  • 一个仅包含input_ids的单个张量，没有其他内容：model(input_ids)
  • 一个变长列表，其中包含一个或多个按照文档字符串中给定的顺序的输入张量：model([input_ids, attention_mask])或model([input_ids, attention_mask, token_type_ids])
  • 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，在使用子类化创建模型和层时，您不需要担心这些内容，因为您可以像将输入传递给任何其他 Python 函数一样传递输入！

call

<来源>

代码语言：javascript复制
( input_ids: TFModelInputType | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFCausalLMOutputWithPast or tuple(tf.Tensor)

参数

  • input_ids（形状为(batch_size, input_ids_length)的Numpy array或tf.Tensor）- 如果past为None，则input_ids_length = sequence_length，否则为past[0].shape[-2]（输入过去键值状态的sequence_length）。 词汇表中输入序列令牌的索引。 如果使用past，则只能将未计算其过去的输入 ID 作为input_ids传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call()和 PreTrainedTokenizer.encode()。 什么是输入 ID？
  • past（长度为config.n_layers的List[tf.Tensor]）- 包含由模型计算的预先计算的隐藏状态（注意力块中的键和值），如模型计算的past输出所示。可用于加速顺序解码。已经计算过其过去的令牌 ID 不应作为输入 ID 传递给此模型。
  • attention_mask（tf.Tensor或形状为(batch_size, sequence_length)的Numpy array，可选）- 用于避免在填充令牌索引上执行注意力的掩码。掩码值在[0, 1]中选择：
    • 1 表示未被掩盖的令牌，
    • 0 表示被掩盖的令牌。

    什么是注意力掩码？

  • token_type_ids（tf.Tensor或形状为(batch_size, sequence_length)的Numpy array，可选）- 段标记索引，用于指示输入的第一部分和第二部分。索引在[0, 1]中选择：
    • 0 对应于一个句子 A的标记，
    • 1 对应于一个句子 B的标记。

    什么是令牌类型 ID？

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

返回

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

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

  • loss (tf.Tensor of shape (n,), optional, 当提供labels时返回，其中 n 是未屏蔽标签的数量) — 语言建模损失（用于下一个标记的预测）。
  • logits (tf.Tensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数（SoftMax 之前每个词汇标记的分数）。
  • past_key_values (List[tf.Tensor], optional, 当传递use_cache=True或config.use_cache=True时返回) — 长度为config.n_layers的tf.Tensor列表，每个张量的形状为(2, batch_size, num_heads, sequence_length, embed_size_per_head)。 包含预先计算的隐藏状态（注意力块中的键和值），可用于加速顺序解码（查看past_key_values输入）。
  • hidden_states (tuple(tf.Tensor), optional, 当传递output_hidden_states=True或config.output_hidden_states=True时返回) — 形状为(batch_size, sequence_length, hidden_size)的tf.Tensor元组（一个用于嵌入的输出 一个用于每一层的输出）。 模型在每一层输出处的隐藏状态以及初始嵌入输出。
  • attentions (tuple(tf.Tensor), optional, 当传递output_attentions=True或config.output_attentions=True时返回) — 形状为(batch_size, num_heads, sequence_length, sequence_length)的tf.Tensor元组（每层一个）。 注意力 softmax 后的注意力权重，用于计算自注意力头中的加权平均值。

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, TFCTRLLMHeadModel
>>> import tensorflow as tf

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

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

TFCTRLForSequenceClassification

class transformers.TFCTRLForSequenceClassification

<来源>

代码语言：javascript复制
( config *inputs **kwargs )

参数

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

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

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

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

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

这个模型也是一个 tf.keras.Model 的子类。将其用作常规的 TF 2.0 Keras 模型，并参考 TF 2.0 文档以获取与一般用法和行为相关的所有内容。

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

  • 将所有输入作为关键字参数（类似于 PyTorch 模型），或
  • 将所有输入作为列表、元组或字典放在第一个位置参数中。

支持第二种格式的原因是，当将输入传递给模型和层时，Keras 方法更喜欢这种格式。由于有了这种支持，当使用 model.fit() 等方法时，应该可以“正常工作” - 只需以 model.fit() 支持的任何格式传递输入和标签即可！但是，如果您想在 Keras 方法之外使用第二种格式，例如在使用 Keras Functional API 创建自己的层或模型时，有三种可能性可以用来收集第一个位置参数中的所有输入张量：

  • 一个仅包含 input_ids 而没有其他内容的单个张量：model(input_ids)
  • 一个长度可变的列表，其中包含一个或多个与文档字符串中给定顺序的输入张量：model([input_ids, attention_mask]) 或 model([input_ids, attention_mask, token_type_ids])
  • 一个字典，其中包含一个或多个与文档字符串中给定的输入名称相关联的输入张量：model({"input_ids": input_ids, "token_type_ids": token_type_ids})

请注意，当使用 子类化 创建模型和层时，您无需担心任何这些，因为您可以像对待任何其他 Python 函数一样传递输入！

call

< source >

代码语言：javascript复制
( input_ids: TFModelInputType | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None use_cache: Optional[bool] = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) → export const metadata = 'undefined';transformers.modeling_tf_outputs.TFSequenceClassifierOutput or tuple(tf.Tensor)

参数

  • input_ids（形状为 (batch_size, input_ids_length) 的 Numpy 数组或 tf.Tensor）— input_ids_length = sequence_length（如果 past 为 None）否则为 past[0].shape[-2]（输入过去键值状态的序列长度）。 词汇表中输入序列标记的索引。 如果使用了 past，则只有那些尚未计算其过去的输入 ID 应作为 input_ids 传递。 可以使用 AutoTokenizer 获取索引。有关详细信息，请参阅 PreTrainedTokenizer.call() 和 PreTrainedTokenizer.encode()。 什么是输入 ID？
  • past（长度为config.n_layers的List[tf.Tensor]）— 包含由模型计算的预计算隐藏状态（注意力块中的键和值），可用于加速顺序解码。已将其过去给予此模型的标记 ID 不应作为输入 ID 传递，因为它们已经计算过。
  • attention_mask（形状为(batch_size, sequence_length)的tf.Tensor或Numpy 数组，可选）— 避免对填充标记索引执行注意力的掩码。掩码值在[0, 1]中选择：
    • 对于未屏蔽的标记，
    • 0 表示屏蔽的标记。

    什么是注意力掩码？

  • token_type_ids（形状为(batch_size, sequence_length)的tf.Tensor或Numpy 数组，可选）— 段标记索引，指示输入的第一部分和第二部分。索引在[0, 1]中选择：
    • 0 对应于句子 A标记，
    • 1 对应于句子 B标记。

    什么是标记类型 ID？

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

返回

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

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

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

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

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

示例：

代码语言：javascript复制
>>> from transformers import AutoTokenizer, TFCTRLForSequenceClassification
>>> import tensorflow as tf

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

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

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

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
代码语言：javascript复制
>>> # To train a model on `num_labels` classes, you can pass `num_labels=num_labels` to `.from_pretrained(...)`
>>> num_labels = len(model.config.id2label)
>>> model = TFCTRLForSequenceClassification.from_pretrained("Salesforce/ctrl", num_labels=num_labels)

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

DeBERTa

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

概述

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

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

论文摘要如下：

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

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

资源

列出了官方 Hugging Face 和社区（由

函数 模型 配置 索引 size

0 人点赞