Transformers 文档

RoBERTa

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

RoBERTa

Models Spaces Paper page

概述

RoBERTa 模型由 Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov 在 RoBERTa: 一种稳健优化的 BERT 预训练方法 中提出。它基于 Google 于 2018 年发布的 BERT 模型。

它建立在 BERT 的基础上,并修改了关键的超参数,移除了下一句子的预训练目标,并使用更大的小批量和学习率进行训练。

论文的摘要如下:

语言模型预训练带来了显著的性能提升,但不同方法之间的仔细比较具有挑战性。训练计算成本高昂,通常在不同大小的私有数据集上完成,而且,正如我们将展示的,超参数选择对最终结果有显著影响。我们提出了对 BERT 预训练 (Devlin et al., 2019) 的复现研究,该研究仔细衡量了许多关键超参数和训练数据大小的影响。我们发现 BERT 的训练明显不足,可以匹敌甚至超过之后发布的每个模型的性能。我们最好的模型在 GLUE、RACE 和 SQuAD 上取得了最先进的结果。这些结果突出了之前被忽视的设计选择的重要性,并对最近报告的改进的来源提出了疑问。我们发布了我们的模型和代码。

此模型由 julien-c 贡献。 原始代码可以在这里找到。

使用技巧

  • 此实现与 BertModel 相同,只是对嵌入进行了微小的调整,并为 RoBERTa 预训练模型进行了设置。

  • RoBERTa 具有与 BERT 相同的架构,但使用字节级 BPE 作为分词器(与 GPT-2 相同),并使用不同的预训练方案。

  • RoBERTa 没有 token_type_ids,因此您无需指示哪个 token 属于哪个段。只需使用分隔 token tokenizer.sep_token (或 </s>) 分隔您的段即可。

  • RoBERTa 类似于 BERT,但具有更好的预训练技术

    • 动态掩码:token 在每个 epoch 中被不同地掩码,而 BERT 只做一次。
    • 句子打包:句子被打包在一起以达到 512 个 token(因此句子的顺序可能跨越多个文档)。
    • 更大的批次:训练使用更大的批次。
    • 字节级 BPE 词汇表:使用 BPE,以字节作为子单元而不是字符,以适应 Unicode 字符。
  • CamemBERT 是 RoBERTa 的包装器。 有关使用示例,请参阅其模型页面。

资源

以下是官方 Hugging Face 和社区(以 🌎 符号表示)资源的列表,可帮助您开始使用 RoBERTa。 如果您有兴趣提交资源以包含在此处,请随时打开 Pull Request,我们将对其进行审核! 该资源最好展示一些新的东西,而不是重复现有资源。

文本分类
Token 分类
填充掩码
问答

多项选择

RobertaConfig

class transformers.RobertaConfig

< >

( vocab_size = 50265 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 position_embedding_type = 'absolute' use_cache = True classifier_dropout = None **kwargs )

参数

  • vocab_size (int, optional, 默认为 50265) — RoBERTa 模型的词汇表大小。定义了当调用 RobertaModelTFRobertaModel 时,可以通过 inputs_ids 传递的不同 token 的数量。
  • hidden_size (int, optional, 默认为 768) — 编码器层和池化层的维度。
  • num_hidden_layers (int, optional, 默认为 12) — Transformer 编码器中的隐藏层数。
  • num_attention_heads (int, optional, 默认为 12) — Transformer 编码器中每个注意力层的注意力头数。
  • intermediate_size (int, optional, 默认为 3072) — Transformer 编码器中 “intermediate”(通常命名为 feed-forward)层的维度。
  • hidden_act (strCallable, optional, 默认为 "gelu") — 编码器和池化器中的非线性激活函数(函数或字符串)。如果为字符串,则支持 "gelu", "relu", "silu""gelu_new"
  • hidden_dropout_prob (float, optional, 默认为 0.1) — embeddings、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_probs_dropout_prob (float, optional, 默认为 0.1) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int, optional, 默认为 512) — 此模型可能使用的最大序列长度。通常将其设置为较大的值以防万一(例如,512 或 1024 或 2048)。
  • type_vocab_size (int, optional, 默认为 2) — 当调用 RobertaModelTFRobertaModel 时,可以通过 token_type_ids 传递的词汇表大小。
  • initializer_range (float, optional, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float, optional, 默认为 1e-12) — layer normalization 层使用的 epsilon 值。
  • position_embedding_type (str, optional, 默认为 "absolute") — 位置 embedding 的类型。选择 "absolute", "relative_key", "relative_key_query" 中的一个。对于位置 embeddings,请使用 "absolute"。有关 "relative_key" 的更多信息,请参阅 Self-Attention with Relative Position Representations (Shaw et al.)。有关 "relative_key_query" 的更多信息,请参阅 Improve Transformer Models with Better Relative Position Embeddings (Huang et al.) 中的方法 4
  • is_decoder (bool, optional, 默认为 False) — 模型是否用作解码器。如果为 False,则模型用作编码器。
  • use_cache (bool, optional, 默认为 True) — 模型是否应返回上次的键/值注意力(并非所有模型都使用)。仅当 config.is_decoder=True 时相关。
  • classifier_dropout (float, optional) — 分类头的 dropout 比率。

这是用于存储 RobertaModelTFRobertaModel 配置的配置类。它用于根据指定的参数实例化 RoBERTa 模型,定义模型架构。使用默认值实例化配置将产生与 RoBERTa FacebookAI/roberta-base 架构类似的配置。

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

示例

>>> from transformers import RobertaConfig, RobertaModel

>>> # Initializing a RoBERTa configuration
>>> configuration = RobertaConfig()

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

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

RobertaTokenizer

class transformers.RobertaTokenizer

< >

( vocab_file merges_file errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。
  • merges_file (str) — merges 文件的路径。
  • errors (str, 可选, 默认值为 "replace") — 将字节解码为 UTF-8 时遵循的范例。 有关更多信息,请参阅 bytes.decode
  • bos_token (str, 可选, 默认值为 "<s>") — 预训练期间使用的序列开始标记。 可以用作序列分类器标记。

    当使用特殊标记构建序列时,这不是用于序列开始的标记。 使用的标记是 cls_token

  • eos_token (str, 可选, 默认值为 "</s>") — 序列结束标记。

    当使用特殊标记构建序列时,这不是用于序列结束的标记。 使用的标记是 sep_token

  • sep_token (str, 可选, 默认值为 "</s>") — 分隔符标记,用于从多个序列构建序列时,例如用于序列分类的两个序列,或用于问答的文本和问题。 它也用作使用特殊标记构建的序列的最后一个标记。
  • cls_token (str, 可选, 默认值为 "<s>") — 分类器标记,用于进行序列分类(对整个序列而不是每个标记进行分类)。 当使用特殊标记构建时,它是序列的第一个标记。
  • unk_token (str, 可选, 默认值为 "<unk>") — 未知标记。 词汇表中不存在的标记无法转换为 ID,而是设置为此标记。
  • pad_token (str, 可选, 默认值为 "<pad>") — 用于填充的标记,例如在批量处理不同长度的序列时。
  • mask_token (str, 可选, 默认值为 "<mask>") — 用于掩码值的标记。 这是使用掩码语言建模训练此模型时使用的标记。 这是模型将尝试预测的标记。
  • add_prefix_space (bool, 可选, 默认值为 False) — 是否在输入中添加初始空格。 这允许像对待任何其他单词一样对待前导单词。 (RoBERTa tokenizer 通过前面的空格检测单词的开头)。

构建 RoBERTa tokenizer,它从 GPT-2 tokenizer 派生而来,使用字节级 Byte-Pair-Encoding。

此 tokenizer 经过训练,将空格视为标记的一部分(有点像 sentencepiece),因此一个单词将

在句子开头(没有空格)或不在句子开头时,编码方式会有所不同

>>> from transformers import RobertaTokenizer

>>> tokenizer = RobertaTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化此 tokenizer 或在某些文本上调用它时传递 add_prefix_space=True 来绕过此行为,但由于模型不是以这种方式预训练的,因此可能会导致性能下降。

当与 is_split_into_words=True 一起使用时,此 tokenizer 将在每个单词(甚至是第一个单词)之前添加一个空格。

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

build_inputs_with_special_tokens

< >

( 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列表。

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

  • 单个序列: <s> X </s>
  • 序列对: <s> A </s></s> B </s>

get_special_tokens_mask

< >

( 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。 当使用 tokenizer prepare_for_model 方法添加特殊标记时,将调用此方法。

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]

零列表。

从传递的两个序列创建一个掩码,用于序列对分类任务。 RoBERTa 不使用标记类型 ID,因此返回零列表。

save_vocabulary

< >

( save_directory: str filename_prefix: Optional = None )

RobertaTokenizerFast

class transformers.RobertaTokenizerFast

< >

( vocab_file = None merges_file = None tokenizer_file = None errors = 'replace' bos_token = '<s>' eos_token = '</s>' sep_token = '</s>' cls_token = '<s>' unk_token = '<unk>' pad_token = '<pad>' mask_token = '<mask>' add_prefix_space = False trim_offsets = True **kwargs )

参数

  • vocab_file (str) — 词汇表文件的路径。
  • merges_file (str) — Merges 文件的路径。
  • errors (str, optional, defaults to "replace") — 将字节解码为 UTF-8 时要遵循的范例。 有关更多信息,请参阅 bytes.decode
  • bos_token (str, optional, defaults to "<s>") — 预训练期间使用的序列开始标记。 可以用作序列分类器标记。

    当使用特殊标记构建序列时,这不是用于序列开始的标记。 使用的标记是 cls_token

  • eos_token (str, optional, defaults to "</s>") — 序列结束标记。

    当使用特殊标记构建序列时,这不是用于序列结束的标记。 使用的标记是 sep_token

  • sep_token (str, optional, defaults to "</s>") — 分隔符标记,用于从多个序列构建序列时,例如,用于序列分类的两个序列,或用于问答的文本和问题。 它也用作使用特殊标记构建的序列的最后一个标记。
  • cls_token (str, optional, defaults to "<s>") — 分类器标记,用于执行序列分类(对整个序列而不是每个标记进行分类)。 当使用特殊标记构建序列时,它是序列的第一个标记。
  • unk_token (str, optional, defaults to "<unk>") — 未知标记。 词汇表中不存在的标记无法转换为 ID,而是设置为此标记。
  • pad_token (str, optional, defaults to "<pad>") — 用于填充的标记,例如在批处理不同长度的序列时。
  • mask_token (str, optional, defaults to "<mask>") — 用于屏蔽值的标记。 这是使用掩码语言建模训练此模型时使用的标记。 这是模型将尝试预测的标记。
  • add_prefix_space (bool, optional, defaults to False) — 是否在输入中添加初始空格。 这允许像对待任何其他单词一样对待前导词。(RoBERTa 分词器通过前面的空格检测单词的开头)。
  • trim_offsets (bool, optional, defaults to True) — 后处理步骤是否应修剪偏移量以避免包含空格。

构建一个“快速” RoBERTa 分词器(由 HuggingFace 的 tokenizers 库支持),从 GPT-2 分词器派生而来,使用字节级字节对编码。

此 tokenizer 经过训练,将空格视为标记的一部分(有点像 sentencepiece),因此一个单词将

在句子开头(没有空格)或不在句子开头时,编码方式会有所不同

>>> from transformers import RobertaTokenizerFast

>>> tokenizer = RobertaTokenizerFast.from_pretrained("FacebookAI/roberta-base")
>>> tokenizer("Hello world")["input_ids"]
[0, 31414, 232, 2]

>>> tokenizer(" Hello world")["input_ids"]
[0, 20920, 232, 2]

您可以通过在实例化此 tokenizer 或在某些文本上调用它时传递 add_prefix_space=True 来绕过此行为,但由于模型不是以这种方式预训练的,因此可能会导致性能下降。

当与 is_split_into_words=True 一起使用时,此分词器需要使用 add_prefix_space=True 实例化。

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

build_inputs_with_special_tokens

< >

( token_ids_0 token_ids_1 = None )

Pytorch
隐藏 Pytorch 内容

RobertaModel

class transformers.RobertaModel

< >

( config add_pooling_layer = True )

参数

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

裸 RoBERTa 模型 Transformer 输出原始隐藏状态,顶部没有任何特定的 Head。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 Head 等)。

此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。

该模型可以充当编码器(仅具有自注意力),也可以充当解码器,在后一种情况下,在自注意力层之间添加一个交叉注意力层,遵循 Ashish Vaswani、Noam Shazeer、Niki Parmar、Jakob Uszkoreit、Llion Jones、Aidan N. Gomez、Lukasz Kaiser 和 Illia Polosukhin 在 Attention is all you need 中描述的架构。

为了充当解码器,模型需要在初始化时将配置的 is_decoder 参数设置为 True。 为了在 Seq2Seq 模型中使用,模型需要使用 is_decoder 参数和 add_cross_attention 都设置为 True 进行初始化; 然后期望 encoder_hidden_states 作为前向传递的输入。

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 encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None past_key_values: Optional = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentionstuple(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) — 避免对 padding 标记索引执行注意力的掩码。 在 [0, 1] 中选择的掩码值:

    • 1 表示标记未被屏蔽
    • 0 表示标记已被屏蔽

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor of shape (batch_size, sequence_length), optional) — 段落标记索引,用于指示输入的第一部分和第二部分。 索引在 [0,1] 中选择:

    • 0 对应于句子 A 标记,
    • 1 对应于句子 B 标记。 仅当使用 type_vocab_size 参数且值

      = 2 初始化模型时,才能使用此参数。 此张量中的所有值应始终 < type_vocab_size。

    什么是标记类型 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) — 用于使自注意力模块的选定 Head 无效的掩码。 在 [0, 1] 中选择的掩码值:

    • 1 表示 Head 未被屏蔽
    • 0 表示 Head 已被屏蔽
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。
  • encoder_hidden_states (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 编码器最后一层的输出端的隐藏状态序列。 如果模型配置为解码器,则在交叉注意力中使用。
  • encoder_attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)(batch_size, sequence_length, target_length)可选) — 用于避免对编码器输入的填充标记索引执行注意力的掩码。 如果模型配置为解码器,则在交叉注意力中使用此掩码。 掩码值在 [0, 1] 中选择:

    • 1 表示未被掩码的标记,
    • 0 表示被掩码的标记。
  • past_key_values (长度为 config.n_layerstuple(tuple(torch.FloatTensor)),其中每个元组有 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含注意力块的预先计算的键和值隐藏状态。 可用于加速解码。

    如果使用 past_key_values,则用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 decoder_input_ids(那些没有将其过去的键值状态提供给此模型的),而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids

  • use_cache (bool可选) — 如果设置为 True,则返回 past_key_values 键值状态,并且可以用于加速解码(请参阅 past_key_values)。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentionstuple(torch.FloatTensor)

一个 transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions 或一个 torch.FloatTensor 元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • last_hidden_state (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的输出端的隐藏状态序列。

  • pooler_output (torch.FloatTensor,形状为 (batch_size, hidden_size)) — 序列的第一个标记(分类标记)的最后一层隐藏状态,在通过用于辅助预训练任务的层进一步处理之后。 例如,对于 BERT 系列模型,这返回通过线性层和 tanh 激活函数处理后的分类标记。 线性层权重从预训练期间的下一句预测(分类)目标中训练而来。

  • 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=Trueconfig.add_cross_attention=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

  • past_key_values (tuple(tuple(torch.FloatTensor))可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layerstuple(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 输入)加速顺序解码。

RobertaModel 前向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, RobertaModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = RobertaModel.from_pretrained("FacebookAI/roberta-base")

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

>>> last_hidden_states = outputs.last_hidden_state

RobertaForCausalLM

class transformers.RobertaForCausalLM

< >

( config )

参数

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

带有 language modeling 头部的 RoBERTa 模型,用于 CLM 微调。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 Head 等)。

此模型也是 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 encoder_hidden_states: Optional = None encoder_attention_mask: Optional = None labels: Optional = None past_key_values: Tuple = None use_cache: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

参数

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

    可以使用 AutoTokenizer 获取索引。 请参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 以了解详细信息。

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 用于避免对填充标记索引执行注意力的掩码。 掩码值在 [0, 1] 中选择:

    • 1 表示未被掩码的标记,
    • 0 表示被掩码的标记。

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 段落标记索引,用于指示输入的第一个和第二个部分。 索引在 [0,1] 中选择:

    • 0 对应于 句子 A 标记,
    • 1 对应于 句子 B 标记。 仅当使用 type_vocab_size 参数且值为

      = 2 初始化模型时,才能使用此参数。 此张量中的所有值应始终 < type_vocab_size。

    什么是标记类型 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)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更灵活地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参见返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。
  • encoder_hidden_states (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 编码器最后一层的输出端的隐藏状态序列。 如果模型配置为解码器,则在交叉注意力中使用。
  • encoder_attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 用于避免对编码器输入的填充标记索引执行注意力的掩码。 如果模型配置为解码器,则在交叉注意力中使用此掩码。 掩码值在 [0, 1] 中选择:

    • 1 表示未被掩码的标记,
    • 0 表示被掩码的标记。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 用于计算从左到右的语言建模损失(下一个词预测)的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(参见 input_ids 文档字符串)。索引设置为 -100 的 token 将被忽略(masked),损失仅针对标签在 [0, ..., config.vocab_size] 中的 token 计算
  • past_key_values (tuple(tuple(torch.FloatTensor)),长度为 config.n_layers,其中每个 tuple 包含 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的张量) — 包含 attention 模块的预计算的键和值 hidden states。可用于加速解码。

    如果使用 past_key_values,用户可以选择仅输入最后的 decoder_input_ids (那些没有将其过去的键值状态提供给此模型的)形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)decoder_input_ids

  • use_cache (bool可选) — 如果设置为 True,则返回 past_key_values 键值状态,可用于加速解码(参见 past_key_values)。

返回

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

一个 transformers.modeling_outputs.CausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 的 tuple(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置 (RobertaConfig) 和输入的各种元素。

  • loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — 语言建模损失(用于下一个 token 预测)。

  • logits (torch.FloatTensor,形状为 (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 之后的注意力权重,用于计算自注意力头中的加权平均值。

  • cross_attentions (tuple(torch.FloatTensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — torch.FloatTensor 的 tuple(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    Cross attentions 权重,在 attention softmax 之后,用于计算 cross-attention head 中的加权平均值。

  • past_key_values (tuple(tuple(torch.FloatTensor))可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — torch.FloatTensor tuple 的 tuple,长度为 config.n_layers,其中每个 tuple 包含 self-attention 和 cross-attention 层的缓存的键、值状态(如果模型在 encoder-decoder 设置中使用)。仅当 config.is_decoder = True 时相关。

    包含预计算的 hidden-states(attention 模块中的键和值),可以用于(参见 past_key_values 输入)加速顺序解码。

The RobertaForCausalLM 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, RobertaForCausalLM, AutoConfig
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> config = AutoConfig.from_pretrained("FacebookAI/roberta-base")
>>> config.is_decoder = True
>>> model = RobertaForCausalLM.from_pretrained("FacebookAI/roberta-base", config=config)

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

>>> prediction_logits = outputs.logits

RobertaForMaskedLM

class transformers.RobertaForMaskedLM

< >

( config )

参数

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

RoBERTa 模型,顶部带有一个 language modeling head。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 Head 等)。

此模型也是 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 encoder_hidden_states: Optional = None encoder_attention_mask: 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,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 token 的索引。

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

    什么是 input IDs?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 用于避免对 padding token 索引执行 attention 的 mask。Mask 值在 [0, 1] 中选择:

    • 1 表示 token 未被 mask
    • 0 表示 token 已被 mask

    什么是 attention masks?

  • token_type_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — Segment token 索引,用于指示输入的第一个和第二个部分。索引在 [0,1] 中选择:

    • 0 对应于 sentence A token,
    • 1 对应于 sentence B token。此参数仅当模型使用 type_vocab_size 参数且值为

      = 2 初始化时才可使用。此 tensor 中的所有值应始终 < type_vocab_size。

    什么是 token type IDs?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列 token 在 position embeddings 中的位置索引。在 [0, config.max_position_embeddings - 1] 范围内选择。

    什么是 position IDs?

  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于 nullify self-attention 模块的选定 head 的 mask。Mask 值在 [0, 1] 中选择:

    • 1 表示 head 未被 mask
    • 0 表示 head 已被 mask
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您想比模型的内部 embedding lookup matrix 更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions tensors。有关更多详细信息,请参见返回的 tensors 下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。有关更多详细信息,请参见返回的 tensors 下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是一个普通的 tuple。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 用于计算 masked language modeling 损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(参见 input_ids 文档字符串)。索引设置为 -100 的 token 将被忽略(masked),损失仅针对标签在 [0, ..., config.vocab_size] 中的 token 计算
  • kwargs (Dict[str, any]可选,默认为 {}) — 用于隐藏已弃用的旧版参数。

返回

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

一个 transformers.modeling_outputs.MaskedLMOutput 或一个 torch.FloatTensor 的 tuple(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含取决于配置 (RobertaConfig) 和输入的各种元素。

  • loss (torch.FloatTensor,形状为 (1,)可选,当提供 labels 时返回) — Masked language modeling (MLM) 损失。

  • logits (torch.FloatTensor,形状为 (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 RobertaForMaskedLM 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, RobertaForMaskedLM
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = RobertaForMaskedLM.from_pretrained("FacebookAI/roberta-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)
>>> tokenizer.decode(predicted_token_id)
' Paris'

>>> labels = tokenizer("The capital of France is Paris.", return_tensors="pt")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

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

RobertaForSequenceClassification

class transformers.RobertaForSequenceClassification

< >

( config )

参数

  • config (RobertaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。请查看 from_pretrained() 方法来加载模型权重。

RoBERTa 模型转换器,顶部带有一个序列分类/回归头(池化输出顶部的线性层),例如用于 GLUE 任务。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 Head 等)。

此模型也是 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.SequenceClassifierOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 掩码,用于避免在填充 token 索引上执行注意力机制。掩码值在 [0, 1] 中选择:

    • 1 表示 tokens 未被掩码
    • 0 表示 tokens 被掩码

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在 [0,1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。 此参数仅当模型使用 type_vocab_size 参数且值

      = 2 初始化时才能使用。 此张量中的所有值应始终 < type_vocab_size。

    什么是 token 类型 IDs?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 掩码,用于使自注意力模块的选定 head 失效。 掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩码
    • 0 表示 head 被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通的 tuple。
  • labels (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。 索引应在 [0, ..., config.num_labels - 1] 中。 如果 config.num_labels == 1,则计算回归损失(均方损失);如果 config.num_labels > 1,则计算分类损失(交叉熵损失)。

返回

transformers.modeling_outputs.SequenceClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.SequenceClassifierOutput 或一个 torch.FloatTensor 的 tuple(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含取决于配置 (RobertaConfig) 和输入的各种元素。

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

RobertaForSequenceClassification 的 forward 方法,覆盖了 __call__ 特殊方法。

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

单标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, RobertaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-emotion")
>>> model = RobertaForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-emotion")

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

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

>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'optimism'

>>> # 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 = RobertaForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-emotion", num_labels=num_labels)

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

多标签分类示例

>>> import torch
>>> from transformers import AutoTokenizer, RobertaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-emotion")
>>> model = RobertaForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-emotion", 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 = RobertaForSequenceClassification.from_pretrained(
...     "cardiffnlp/twitter-roberta-base-emotion", 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

RobertaForMultipleChoice

class transformers.RobertaForMultipleChoice

< >

( config )

参数

  • config (RobertaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型相关的权重,仅加载配置。请查看 from_pretrained() 方法来加载模型权重。

Roberta 模型,顶部带有一个多项选择分类头(池化输出顶部的线性层和一个 softmax),例如用于 RocStories/SWAG 任务。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 Head 等)。

此模型也是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参阅 PyTorch 文档,了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: Optional = None token_type_ids: Optional = None attention_mask: Optional = None labels: 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.MultipleChoiceModelOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, num_choices, sequence_length)可选) — 掩码,用于避免在填充 token 索引上执行注意力机制。掩码值在 [0, 1] 中选择:

    • 1 表示 tokens 未被掩码
    • 0 表示 tokens 被掩码

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor,形状为 (batch_size, num_choices, sequence_length)可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在 [0,1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。 此参数仅当模型使用 type_vocab_size 参数且值

      = 2 初始化时才能使用。 此张量中的所有值应始终 < type_vocab_size。

    什么是 token 类型 IDs?

  • position_ids (torch.LongTensor,形状为 (batch_size, num_choices, sequence_length)可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 掩码,用于使自注意力模块的选定 head 失效。 掩码值在 [0, 1] 中选择:

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

返回

transformers.modeling_outputs.MultipleChoiceModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.MultipleChoiceModelOutputtorch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

RobertaForMultipleChoice 前向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, RobertaForMultipleChoice
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = RobertaForMultipleChoice.from_pretrained("FacebookAI/roberta-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

RobertaForTokenClassification

class transformers.RobertaForTokenClassification

< >

( config )

参数

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

带有 token 分类头的 Roberta 模型(隐藏状态输出之上的线性层),例如,用于命名实体识别 (NER) 任务。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 Head 等)。

此模型也是 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.TokenClassifierOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 掩码,以避免在填充 token 索引上执行注意力机制。 掩码值在 [0, 1] 中选择:

    • 1 表示 token 未被掩盖
    • 0 表示 token 已被掩盖

    什么是注意力掩码?

  • token_type_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 分段 token 索引,用于指示输入的第一个和第二个部分。 索引在 [0,1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。 仅当使用 type_vocab_size 参数(值

      = 2

      )初始化模型时,才能使用此参数。 此张量中的所有值应始终 < type_vocab_size。

    什么是 token 类型 ID?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [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)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这将非常有用。
  • output_attentions (bool, optional) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是普通的元组。
  • labels (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 用于计算 token 分类损失的标签。 索引应在 [0, ..., config.num_labels - 1] 中。

返回

transformers.modeling_outputs.TokenClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.TokenClassifierOutputtorch.FloatTensor 的元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

RobertaForTokenClassification 前向方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, RobertaForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("Jean-Baptiste/roberta-large-ner-english")
>>> model = RobertaForTokenClassification.from_pretrained("Jean-Baptiste/roberta-large-ner-english")

>>> 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
['O', 'ORG', 'ORG', 'O', 'O', 'O', 'O', 'O', 'LOC', 'O', 'LOC', 'LOC']

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

RobertaForQuestionAnswering

class transformers.RobertaForQuestionAnswering

< >

( config )

参数

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

带有 span 分类头的 Roberta 模型,用于抽取式问答任务,如 SQuAD(隐藏状态输出之上的线性层,用于计算 span start logitsspan end logits)。

此模型继承自 PreTrainedModel。 查看超类文档,了解库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 Head 等)。

此模型也是 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 start_positions: Optional = None end_positions: Optional = None output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None ) transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 ID?

  • attention_mask (torch.FloatTensor,形状为 (batch_size, sequence_length)可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示标记未被掩码
    • 0 表示标记被掩码

    什么是 attention masks?

  • token_type_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 片段标记索引,用于指示输入的第一个和第二个部分。索引在 [0,1] 中选择:

    • 0 对应于 句子 A 标记,
    • 1 对应于 句子 B 标记。此参数仅当模型使用 type_vocab_size 参数且值为

      = 2 初始化时才能使用。此张量中的所有值应始终 < type_vocab_size。

    什么是 token type IDs?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs?

  • head_mask (torch.FloatTensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于 nullify self-attention 模块中选定 head 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩码
    • 0 表示 head 被掩码
  • inputs_embeds (torch.FloatTensor,形状为 (batch_size, sequence_length, hidden_size)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。
  • start_positions (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算标记分类损失的已标记跨度开始位置(索引)的标签。位置被限制在序列的长度 (sequence_length) 内。序列之外的位置不计入损失计算。
  • end_positions (torch.LongTensor,形状为 (batch_size,)可选) — 用于计算标记分类损失的已标记跨度结束位置(索引)的标签。位置被限制在序列的长度 (sequence_length) 内。序列之外的位置不计入损失计算。

返回

transformers.modeling_outputs.QuestionAnsweringModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_outputs.QuestionAnsweringModelOutput 或一个 torch.FloatTensor 元组(如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • 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 之后的注意力权重,用于计算自注意力头中的加权平均值。

RobertaForQuestionAnswering forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, RobertaForQuestionAnswering
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("deepset/roberta-base-squad2")
>>> model = RobertaForQuestionAnswering.from_pretrained("deepset/roberta-base-squad2")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="pt")
>>> with torch.no_grad():
...     outputs = model(**inputs)

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens, skip_special_tokens=True)
' puppet'

>>> # target is "nice puppet"
>>> target_start_index = torch.tensor([14])
>>> target_end_index = torch.tensor([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
>>> round(loss.item(), 2)
0.86
TensorFlow
隐藏 TensorFlow 内容

TFRobertaModel

class transformers.TFRobertaModel

< >

( config *inputs **kwargs )

参数

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

裸 RoBERTa 模型 Transformer 输出原始隐藏状态,顶部没有任何特定的 Head。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型,并参阅 TF 2.0 文档以了解与通用用法和行为相关的所有事项。

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

  • 所有输入都作为关键字参数(如 PyTorch 模型),或
  • 所有输入都作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit() 等方法时,事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可!但是,如果您想在 Keras 方法(如 fit()predict())之外使用第二种格式,例如在使用 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})

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

call

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = 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 ) transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentionstuple(tf.Tensor)

参数

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

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

    什么是 input IDs?

  • attention_mask (形状为 (batch_size, sequence_length)Numpy arraytf.Tensor可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示标记未被掩码
    • 0 表示标记被掩码

    什么是 attention masks?

  • token_type_ids (形状为 (batch_size, sequence_length)Numpy arraytf.Tensor可选) — 片段标记索引,用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择:

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

    什么是 token type IDs?

  • position_ids (形状为 (batch_size, sequence_length)Numpy arraytf.Tensor可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs?

  • head_mask (形状为 (num_heads,)(num_layers, num_heads)Numpy arraytf.Tensor可选) — 用于 nullify self-attention 模块中选定 head 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩码
    • 0 表示 head 被掩码
  • inputs_embeds (形状为 (batch_size, sequence_length, hidden_size)tf.Tensor可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精确地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息,请参阅返回张量下的 attentions。 此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回张量下的 hidden_states。 此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用,在 graph 模式下该值将始终设置为 True。
  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
  • encoder_hidden_states (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 编码器最后一层的隐状态序列。如果模型配置为解码器,则在交叉注意力机制中使用。
  • encoder_attention_mask (tf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在编码器输入的 padding 标记索引上执行 attention 的掩码。如果模型配置为解码器,则此掩码在交叉注意力机制中使用。掩码值在 [0, 1] 中选择:

    • 1 表示标记未被掩盖
    • 0 表示标记被掩盖
  • past_key_values (Tuple[Tuple[tf.Tensor]],长度为 config.n_layers) — 包含 attention 块的预计算的键和值隐状态。可用于加速解码。如果使用 past_key_values,则用户可以选择仅输入最后部分的 decoder_input_ids(那些没有将其过去的键值状态提供给此模型的输入),其形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)decoder_input_ids
  • use_cache (bool可选,默认为 True) — 如果设置为 True,则返回 past_key_values 键值状态,并可用于加速解码(参见 past_key_values)。训练期间设置为 False,生成期间设置为 True

返回

transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentionstuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFBaseModelOutputWithPoolingAndCrossAttentions 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • last_hidden_state (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)) — 模型最后一层的隐状态序列。

  • pooler_output (tf.Tensor,形状为 (batch_size, hidden_size)) — 序列的第一个标记(分类标记)的最后一层隐状态,通过线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间从下一句预测(分类)目标中训练而来。

    此输出通常不是输入语义内容的良好摘要,对于整个输入序列,您通常最好使用隐状态序列的平均或池化。

  • past_key_values (List[tf.Tensor]可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — tf.Tensor 列表,长度为 config.n_layers,每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含预计算的 hidden-states(attention 模块中的键和值),可以用于(参见 past_key_values 输入)加速顺序解码。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

  • cross_attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFRobertaModel 的前向传播方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = TFRobertaModel.from_pretrained("FacebookAI/roberta-base")

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

>>> last_hidden_states = outputs.last_hidden_state

TFRobertaForCausalLM

class transformers.TFRobertaForCausalLM

< >

( config: RobertaConfig *inputs **kwargs )

call

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None encoder_hidden_states: np.ndarray | tf.Tensor | None = None encoder_attention_mask: np.ndarray | tf.Tensor | None = None past_key_values: Optional[Tuple[Tuple[Union[np.ndarray, tf.Tensor]]]] = 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 ) transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentionstuple(tf.Tensor)

参数

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

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

    什么是输入 IDs?

  • attention_mask (形状为 (batch_size, sequence_length)Numpy arraytf.Tensor可选) — 用于避免在 padding 标记索引上执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示标记未被掩盖
    • 0 表示标记被掩盖

    什么是 attention 掩码?

  • token_type_ids (形状为 (batch_size, sequence_length)Numpy arraytf.Tensor可选) — 分段标记索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

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

    什么是标记类型 IDs?

  • position_ids (形状为 (batch_size, sequence_length)Numpy arraytf.Tensor可选) — 每个输入序列标记在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (形状为 (num_heads,)(num_layers, num_heads)Numpy arraytf.Tensor可选) — 用于使自注意力模块的选定 head 失效的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩盖
    • 0 表示 head 被掩盖
  • inputs_embeds (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attention 张量。有关更多详细信息,请参见返回的张量下的 attentions。此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。
  • output_hidden_states (bool可选) — 是否返回所有层的隐状态。有关更多详细信息,请参见返回的张量下的 hidden_states。此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 eager 模式下使用,在 graph 模式下,该值将始终设置为 True。
  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
  • encoder_hidden_states (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 编码器最后一层的隐状态序列。如果模型配置为解码器,则在交叉注意力机制中使用。
  • encoder_attention_mask (tf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在编码器输入中的 padding 标记索引上执行 attention 的掩码。如果模型配置为解码器,则此掩码在交叉注意力机制中使用。掩码值在 [0, 1] 中选择:

    • 1 表示标记未被掩盖
    • 0 表示标记被掩盖
  • past_key_values (Tuple[Tuple[tf.Tensor]],长度为 config.n_layers) — 包含 attention 块的预计算的键和值隐状态。可用于加速解码。如果使用 past_key_values,则用户可以选择仅输入最后部分的 decoder_input_ids(那些没有将其过去的键值状态提供给此模型的输入),其形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)decoder_input_ids
  • use_cache (bool可选,默认为 True) — 如果设置为 True,则返回 past_key_values 键值状态,并可用于加速解码(参见 past_key_values)。训练期间设置为 False,生成期间设置为 True
  • labels (形状为 (batch_size, sequence_length)tf.Tensornp.ndarray可选) — 用于计算交叉熵分类损失的标签。索引应为 [0, ..., config.vocab_size - 1]

返回

transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentionstuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFCausalLMOutputWithCrossAttentions 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • loss (tf.Tensor,形状为 (n,)可选,其中 n 是非掩码标签的数量,当提供 labels 时返回) — 语言建模损失(用于下一个标记预测)。

  • logits (tf.Tensor,形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数(SoftMax 之前每个词汇表标记的分数)。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

  • cross_attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

  • past_key_values (List[tf.Tensor]可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — tf.Tensor 列表,长度为 config.n_layers,每个张量的形状为 (2, batch_size, num_heads, sequence_length, embed_size_per_head))。

    包含预计算的 hidden-states(attention 模块中的键和值),可以用于(参见 past_key_values 输入)加速顺序解码。

TFRobertaForCausalLM 的前向传播方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = TFRobertaForCausalLM.from_pretrained("FacebookAI/roberta-base")

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

TFRobertaForMaskedLM

class transformers.TFRobertaForMaskedLM

< >

( config *inputs **kwargs )

参数

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

RoBERTa 模型,顶部带有一个 language modeling head。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型,并参阅 TF 2.0 文档以了解与通用用法和行为相关的所有事项。

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

  • 所有输入都作为关键字参数(如 PyTorch 模型),或
  • 所有输入都作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit() 等方法时,事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可!但是,如果您想在 Keras 方法(如 fit()predict())之外使用第二种格式,例如在使用 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})

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

call

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFMaskedLMOutputtuple(tf.Tensor)

参数

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

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

    什么是输入 IDs?

  • attention_mask (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示标记未被掩盖
    • 0 表示标记被掩盖

    什么是注意力掩码?

  • token_type_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 段落标记索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

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

    什么是标记类型 IDs?

  • position_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (Numpy arraytf.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于使自注意力模块的选定头无效的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头未被掩盖
    • 0 表示头被掩盖
  • inputs_embeds (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有注意力层的注意力张量。 有关更多详细信息,请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用,在 graph 模式下将使用配置中的值。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 eager 模式下使用,在 graph 模式下,该值将始终设置为 True。
  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
  • labels (tf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于计算掩码语言建模损失的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(请参阅 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩盖),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。

返回

transformers.modeling_tf_outputs.TFMaskedLMOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFMaskedLMOutputtf.Tensor 元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • loss (tf.Tensor,形状为 (n,)可选,当提供 labels 时返回) — 掩码语言建模 (MLM) 损失。

  • logits (tf.Tensor,形状为 (batch_size, sequence_length, config.vocab_size)) — 语言建模 head 的预测分数(SoftMax 之前每个词汇表标记的分数)。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFRobertaForMaskedLM 前向方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = TFRobertaForMaskedLM.from_pretrained("FacebookAI/roberta-base")

>>> inputs = tokenizer("The capital of France is <mask>.", return_tensors="tf")
>>> logits = model(**inputs).logits

>>> # retrieve index of <mask>
>>> mask_token_index = tf.where((inputs.input_ids == tokenizer.mask_token_id)[0])
>>> selected_logits = tf.gather_nd(logits[0], indices=mask_token_index)

>>> predicted_token_id = tf.math.argmax(selected_logits, axis=-1)
>>> tokenizer.decode(predicted_token_id)
' Paris'
>>> labels = tokenizer("The capital of France is Paris.", return_tensors="tf")["input_ids"]
>>> # mask labels of non-<mask> tokens
>>> labels = tf.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)

>>> outputs = model(**inputs, labels=labels)
>>> round(float(outputs.loss), 2)
0.1

TFRobertaForSequenceClassification

class transformers.TFRobertaForSequenceClassification

< >

( config *inputs **kwargs )

参数

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

RoBERTa 模型转换器,顶部带有一个序列分类/回归头(池化输出顶部的线性层),例如用于 GLUE 任务。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型,并参阅 TF 2.0 文档以了解与通用用法和行为相关的所有事项。

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

  • 所有输入都作为关键字参数(如 PyTorch 模型),或
  • 所有输入都作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit() 等方法时,事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可!但是,如果您想在 Keras 方法(如 fit()predict())之外使用第二种格式,例如在使用 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})

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

call

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFSequenceClassifierOutputtuple(tf.Tensor)

参数

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

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

    什么是输入 IDs?

  • attention_mask (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在填充标记索引上执行注意力的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示标记未被掩盖
    • 0 表示标记被掩盖

    什么是注意力掩码?

  • token_type_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 分段 token 索引,用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。

    什么是 token 类型 IDs?

  • position_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (Numpy arraytf.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于 nullify self-attention 模块中选定 head 的 Mask。Mask 值从 [0, 1] 中选择:

    • 1 表示 head 不被 mask
    • 0 表示 head 被 mask
  • inputs_embeds (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions 张量。有关更多详细信息,请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。有关更多详细信息,请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 eager 模式下使用,在 graph 模式下,该值将始终设置为 True。
  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
  • labels (tf.Tensor,形状为 (batch_size,)可选) — 用于计算序列分类/回归损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。如果 config.num_labels == 1,则计算回归损失(均方误差损失);如果 config.num_labels > 1,则计算分类损失(交叉熵损失)。

返回

transformers.modeling_tf_outputs.TFSequenceClassifierOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFSequenceClassifierOutputtf.Tensor 元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • loss (tf.Tensor,形状为 (batch_size, )可选,当提供 labels 时返回) — 分类(或回归,如果 config.num_labels==1)损失。

  • logits (tf.Tensor,形状为 (batch_size, config.num_labels)) — 分类(或回归,如果 config.num_labels==1)得分(在 SoftMax 之前)。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFRobertaForSequenceClassification 前向方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-emotion")
>>> model = TFRobertaForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-emotion")

>>> 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])
>>> model.config.id2label[predicted_class_id]
'optimism'
>>> # 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 = TFRobertaForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-emotion", num_labels=num_labels)

>>> labels = tf.constant(1)
>>> loss = model(**inputs, labels=labels).loss
>>> round(float(loss), 2)
0.08

TFRobertaForMultipleChoice

class transformers.TFRobertaForMultipleChoice

< >

( config *inputs **kwargs )

参数

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

Roberta 模型,顶部带有一个多项选择分类头(池化输出顶部的线性层和一个 softmax),例如用于 RocStories/SWAG 任务。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型,并参阅 TF 2.0 文档以了解与通用用法和行为相关的所有事项。

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

  • 所有输入都作为关键字参数(如 PyTorch 模型),或
  • 所有输入都作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit() 等方法时,事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可!但是,如果您想在 Keras 方法(如 fit()predict())之外使用第二种格式,例如在使用 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})

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

call

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFMultipleChoiceModelOutputtuple(tf.Tensor)

参数

  • input_ids (Numpy arraytf.Tensor,形状为 (batch_size, num_choices, sequence_length)) — 词汇表中输入序列 token 的索引。

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

    什么是输入 IDs?

  • attention_mask (Numpy arraytf.Tensor,形状为 (batch_size, num_choices, sequence_length)可选) — Mask,以避免对 padding token 索引执行 attention。Mask 值从 [0, 1] 中选择:

    • 1 表示 token 不被 mask
    • 0 表示 token 被 mask

    什么是 attention masks?

  • token_type_ids (Numpy arraytf.Tensor,形状为 (batch_size, num_choices, sequence_length)可选) — 分段 token 索引,用于指示输入的第一个和第二个部分。索引从 [0, 1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。

    什么是 token 类型 IDs?

  • position_ids (Numpy arraytf.Tensor,形状为 (batch_size, num_choices, sequence_length)可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (Numpy arraytf.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于 nullify self-attention 模块中选定 head 的 Mask。Mask 值从 [0, 1] 中选择:

    • 1 表示 head 不被 mask
    • 0 表示 head 被 mask
  • inputs_embeds (tf.Tensor,形状为 (batch_size, num_choices, sequence_length, hidden_size)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更好地控制如何将 input_ids 索引转换为关联向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions 张量。有关更多详细信息,请参阅返回张量下的 attentions。此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。有关更多详细信息,请参阅返回张量下的 hidden_states。此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。此参数可以在 eager 模式下使用,在 graph 模式下,该值将始终设置为 True。
  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
  • labels (tf.Tensor of shape (batch_size,), optional) — Labels for computing the multiple choice classification loss. Indices should be in [0, ..., num_choices] where num_choices is the size of the second dimension of the input tensors. (See input_ids above)

返回

transformers.modeling_tf_outputs.TFMultipleChoiceModelOutputtuple(tf.Tensor) 组成

一个 transformers.modeling_tf_outputs.TFMultipleChoiceModelOutput 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • loss (tf.Tensor,形状为 (batch_size, )可选,当提供 labels 时返回) — 分类损失。

  • logits (tf.Tensor,形状为 (batch_size, num_choices)) — num_choices 是输入张量的第二个维度。(参见上面的 input_ids)。

    分类得分(在 SoftMax 之前)。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFRobertaForMultipleChoice 前向传播方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = TFRobertaForMultipleChoice.from_pretrained("FacebookAI/roberta-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."

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="tf", padding=True)
>>> inputs = {k: tf.expand_dims(v, 0) for k, v in encoding.items()}
>>> outputs = model(inputs)  # batch size is 1

>>> # the linear classifier still needs to be trained
>>> logits = outputs.logits

TFRobertaForTokenClassification

class transformers.TFRobertaForTokenClassification

< >

( config *inputs **kwargs )

参数

  • config (RobertaConfig) — Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.

RoBERTa 模型,顶部带有一个 token 分类头 (隐藏状态输出顶部的线性层),例如用于命名实体识别 (NER) 任务。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型,并参阅 TF 2.0 文档以了解与通用用法和行为相关的所有事项。

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

  • 所有输入都作为关键字参数(如 PyTorch 模型),或
  • 所有输入都作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit() 等方法时,事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可!但是,如果您想在 Keras 方法(如 fit()predict())之外使用第二种格式,例如在使用 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})

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

call

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None labels: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFTokenClassifierOutputtuple(tf.Tensor)

参数

  • input_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs?

  • attention_mask (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 掩码,用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择:

    • 1 代表 tokens 未被掩盖
    • 0 代表 tokens 被掩盖

    什么是 attention 掩码?

  • token_type_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。

    什么是 token 类型 IDs?

  • position_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 每个输入序列 token 在位置嵌入中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是位置 IDs?

  • head_mask (Numpy arraytf.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 掩码,用于使 self-attention 模块的选定 head 失效。掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩盖
    • 0 表示 head 被掩盖
  • inputs_embeds (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — 可选地,您可以选择直接传递嵌入表示而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions 张量。 有关更多详细信息,请参见返回张量下的 attentions。 此参数只能在即时模式下使用,在图模式下将使用配置中的值。
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回张量下的 hidden_states。 此参数只能在即时模式下使用,在图模式下将使用配置中的值。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在即时模式下使用,在图模式下该值将始终设置为 True。
  • training (bool可选,默认为 False) — 是否在训练模式下使用模型 (某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
  • labels (tf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于计算 token 分类损失的标签。索引应在 [0, ..., config.num_labels - 1] 中。

返回

transformers.modeling_tf_outputs.TFTokenClassifierOutputtuple(tf.Tensor) 组成

一个 transformers.modeling_tf_outputs.TFTokenClassifierOutput 或一个 tf.Tensor 元组 (如果传递了 return_dict=False 或者当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • loss (tf.Tensor,形状为 (n,)可选,其中 n 是未掩盖标签的数量,当提供 labels 时返回) — 分类损失。

  • logits (tf.Tensor,形状为 (batch_size, sequence_length, config.num_labels)) — 分类得分 (在 SoftMax 之前)。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFRobertaForTokenClassification 前向传播方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("ydshieh/roberta-large-ner-english")
>>> model = TFRobertaForTokenClassification.from_pretrained("ydshieh/roberta-large-ner-english")

>>> inputs = tokenizer(
...     "HuggingFace is a company based in Paris and New York", add_special_tokens=False, return_tensors="tf"
... )

>>> logits = model(**inputs).logits
>>> predicted_token_class_ids = tf.math.argmax(logits, axis=-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t] for t in predicted_token_class_ids[0].numpy().tolist()]
>>> predicted_tokens_classes
['O', 'ORG', 'ORG', 'O', 'O', 'O', 'O', 'O', 'LOC', 'O', 'LOC', 'LOC']
>>> labels = predicted_token_class_ids
>>> loss = tf.math.reduce_mean(model(**inputs, labels=labels).loss)
>>> round(float(loss), 2)
0.01

TFRobertaForQuestionAnswering

class transformers.TFRobertaForQuestionAnswering

< >

( config *inputs **kwargs )

参数

  • config (RobertaConfig) — Model configuration class with all the parameters of the model. Initializing with a config file does not load the weights associated with the model, only the configuration. Check out the from_pretrained() method to load the model weights.

RoBERTa 模型,顶部带有一个跨度分类头,用于抽取式问答任务,如 SQuAD (隐藏状态输出顶部的线性层,用于计算 span start logitsspan end logits)。

此模型继承自 TFPreTrainedModel。查看超类文档以获取库为其所有模型实现的通用方法(例如下载或保存、调整输入嵌入大小、剪枝 head 等)。

此模型也是 keras.Model 子类。将其用作常规 TF 2.0 Keras 模型,并参阅 TF 2.0 文档以了解与通用用法和行为相关的所有事项。

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

  • 所有输入都作为关键字参数(如 PyTorch 模型),或
  • 所有输入都作为第一个位置参数中的列表、元组或字典。

支持第二种格式的原因是 Keras 方法在将输入传递给模型和层时更喜欢这种格式。由于这种支持,当使用 model.fit() 等方法时,事情应该对您“正常工作” - 只需以 model.fit() 支持的任何格式传递您的输入和标签即可!但是,如果您想在 Keras 方法(如 fit()predict())之外使用第二种格式,例如在使用 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})

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

call

< >

( input_ids: TFModelInputType | None = None attention_mask: np.ndarray | tf.Tensor | None = None token_type_ids: np.ndarray | tf.Tensor | None = None position_ids: np.ndarray | tf.Tensor | None = None head_mask: np.ndarray | tf.Tensor | None = None inputs_embeds: np.ndarray | tf.Tensor | None = None output_attentions: Optional[bool] = None output_hidden_states: Optional[bool] = None return_dict: Optional[bool] = None start_positions: np.ndarray | tf.Tensor | None = None end_positions: np.ndarray | tf.Tensor | None = None training: Optional[bool] = False ) transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutputtuple(tf.Tensor)

参数

  • input_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs?

  • attention_mask (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 用于避免在 padding 标记索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择:

    • 1 表示标记未被 Mask
    • 0 表示标记被 Mask

    什么是 attention masks?

  • token_type_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — Segment token indices 用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择:

    • 0 对应于 sentence A 标记,
    • 1 对应于 sentence B 标记。

    什么是 token type IDs?

  • position_ids (Numpy arraytf.Tensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。

    什么是 position IDs?

  • head_mask (Numpy arraytf.Tensor,形状为 (num_heads,)(num_layers, num_heads)可选) — 用于 nullify self-attention 模块中选定 head 的 Mask。 Mask 值在 [0, 1] 中选择:

    • 1 表示 head 未被 Mask
    • 0 表示 head 被 Mask
  • inputs_embeds (tf.Tensor,形状为 (batch_size, sequence_length, hidden_size)可选) — (可选)您可以选择直接传递嵌入表示,而不是传递 input_ids。如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参阅返回 tensors 下的 attentions。 此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参阅返回 tensors 下的 hidden_states。 此参数只能在 eager 模式下使用,在 graph 模式下将使用 config 中的值。
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通元组。 此参数可以在 eager 模式下使用,在 graph 模式下,该值将始终设置为 True。
  • training (bool可选,默认为 False) — 是否在训练模式下使用模型(某些模块(如 dropout 模块)在训练和评估之间具有不同的行为)。
  • start_positions (tf.Tensor,形状为 (batch_size,)可选) — 用于计算 token 分类损失的标记 span 起始位置(索引)的标签。 位置被限制在序列的长度 (sequence_length) 内。 序列之外的位置不计入损失计算。
  • end_positions (tf.Tensor,形状为 (batch_size,)可选) — 用于计算 token 分类损失的标记 span 结束位置(索引)的标签。 位置被限制在序列的长度 (sequence_length) 内。 序列之外的位置不计入损失计算。

返回

transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutputtuple(tf.Tensor)

一个 transformers.modeling_tf_outputs.TFQuestionAnsweringModelOutputtf.Tensor 元组(如果传递 return_dict=False 或当 config.return_dict=False 时),包括各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • loss (tf.Tensor,形状为 (batch_size, )可选,当提供 start_positionsend_positions 时返回) — 总 span 提取损失是起始位置和结束位置的交叉熵损失之和。

  • start_logits (tf.Tensor,形状为 (batch_size, sequence_length)) — Span-start 分数(在 SoftMax 之前)。

  • end_logits (tf.Tensor,形状为 (batch_size, sequence_length)) — Span-end 分数(在 SoftMax 之前)。

  • hidden_states (tuple(tf.Tensor)可选,当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — tf.Tensor 元组(一个用于嵌入的输出 + 一个用于每一层的输出),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(tf.Tensor)可选,当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — tf.Tensor 元组(每一层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

TFRobertaForQuestionAnswering forward 方法,覆盖了 __call__ 特殊方法。

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

示例

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

>>> tokenizer = AutoTokenizer.from_pretrained("ydshieh/roberta-base-squad2")
>>> model = TFRobertaForQuestionAnswering.from_pretrained("ydshieh/roberta-base-squad2")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"

>>> inputs = tokenizer(question, text, return_tensors="tf")
>>> outputs = model(**inputs)

>>> answer_start_index = int(tf.math.argmax(outputs.start_logits, axis=-1)[0])
>>> answer_end_index = int(tf.math.argmax(outputs.end_logits, axis=-1)[0])

>>> predict_answer_tokens = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> tokenizer.decode(predict_answer_tokens)
' puppet'
>>> # target is "nice puppet"
>>> target_start_index = tf.constant([14])
>>> target_end_index = tf.constant([15])

>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = tf.math.reduce_mean(outputs.loss)
>>> round(float(loss), 2)
0.86
JAX
隐藏 JAX 内容

FlaxRobertaModel

class transformers.FlaxRobertaModel

< >

( config: RobertaConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

裸 RoBERTa 模型 Transformer 输出原始隐藏状态,顶部没有任何特定的 Head。

此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None encoder_hidden_states = None encoder_attention_mask = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs?

  • attention_mask (numpy.ndarray,形状为 (batch_size, sequence_length)可选) — 用于避免在 padding 标记索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择:

    • 1 表示标记未被 Mask
    • 0 表示标记被 Mask

    什么是 attention masks?

  • token_type_ids (numpy.ndarray,形状为 (batch_size, sequence_length)可选) — Segment token indices 用于指示输入的第一个和第二个部分。索引在 [0, 1] 中选择:

    • 0 对应于 sentence A 标记,
    • 1 对应于 sentence B 标记。

    什么是 token type IDs?

  • position_ids (numpy.ndarray,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列标记的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (形状为 (batch_size, sequence_length)numpy.ndarray, optional) -- 用于置空注意力模块中选定 head 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩蔽
    • 0 表示 head 被掩蔽
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是纯元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一个 torch.FloatTensor 元组 (如果在传递 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size)jnp.ndarray) — 模型最后一层的输出处的隐藏状态序列。

  • pooler_output (形状为 (batch_size, hidden_size)jnp.ndarray) — 序列的第一个 token(分类 token)的最后一层隐藏状态,通过线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间从下一句预测(分类)目标中训练而来。

  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组(embedding 的输出一个,每层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

FlaxRobertaPreTrainedModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, FlaxRobertaModel

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = FlaxRobertaModel.from_pretrained("FacebookAI/roberta-base")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxRobertaForCausalLM

class transformers.FlaxRobertaForCausalLM

< >

( config: RobertaConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (RobertaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。

带有语言建模头的 Roberta 模型(隐藏状态输出之上的线性层),例如用于自回归任务。

此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None encoder_hidden_states = None encoder_attention_mask = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, sequence_length)numpy.ndarray) — 词汇表中输入序列 token 的索引。

    索引可以使用 AutoTokenizer 获得。 参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 以了解详情。

    什么是输入 IDs?

  • attention_mask (形状为 (batch_size, sequence_length)numpy.ndarray, optional) — 避免对 padding token 索引执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 token 未被掩蔽
    • 0 表示 token 被掩蔽

    什么是 attention 掩码?

  • token_type_ids (形状为 (batch_size, sequence_length)numpy.ndarray, optional) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。

    什么是 token 类型 IDs?

  • position_ids (形状为 (batch_size, sequence_length)numpy.ndarray, optional) — 每个输入序列 token 在位置 embedding 中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (形状为 (batch_size, sequence_length)numpy.ndarray, optional) -- 用于置空注意力模块中选定 head 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩蔽
    • 0 表示 head 被掩蔽
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是纯元组。

返回

transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentions 或一个 torch.FloatTensor 元组 (如果在传递 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • logits (形状为 (batch_size, sequence_length, config.vocab_size)jnp.ndarray) — 语言建模头的预测分数(SoftMax 之前每个词汇表 token 的分数)。

  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组(embedding 的输出一个,每层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

  • cross_attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

    Cross attentions 权重,在 attention softmax 之后,用于计算 cross-attention head 中的加权平均值。

  • past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layersjnp.ndarray 元组的元组,每个元组包含自注意力层和交叉注意力层的缓存键、值状态(如果模型用于编码器-解码器设置)。 仅在 config.is_decoder = True 时相关。

    包含预计算的 hidden-states(attention 模块中的键和值),可以用于(参见 past_key_values 输入)加速顺序解码。

FlaxRobertaPreTrainedModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, FlaxRobertaForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = FlaxRobertaForCausalLM.from_pretrained("FacebookAI/roberta-base")

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

>>> # retrieve logts for next token
>>> next_token_logits = outputs.logits[:, -1]

FlaxRobertaForMaskedLM

class transformers.FlaxRobertaForMaskedLM

< >

( config: RobertaConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (RobertaConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法来加载模型权重。

RoBERTa 模型,顶部带有一个 language modeling head。

此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None encoder_hidden_states = None encoder_attention_mask = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, sequence_length)numpy.ndarray) — 词汇表中输入序列 token 的索引。

    索引可以使用 AutoTokenizer 获得。 参阅 PreTrainedTokenizer.encode()PreTrainedTokenizer.call() 以了解详情。

    什么是输入 IDs?

  • attention_mask (形状为 (batch_size, sequence_length)numpy.ndarray, optional) — 避免对 padding token 索引执行 attention 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 token 未被掩蔽
    • 0 表示 token 被掩蔽

    什么是 attention 掩码?

  • token_type_ids (形状为 (batch_size, sequence_length)numpy.ndarray, optional) — 分段 token 索引,用于指示输入的第一部分和第二部分。索引在 [0, 1] 中选择:

    • 0 对应于 句子 A token,
    • 1 对应于 句子 B token。

    什么是 token 类型 IDs?

  • position_ids (形状为 (batch_size, sequence_length)numpy.ndarray, optional) — 每个输入序列 token 在位置 embedding 中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (形状为 (batch_size, sequence_length)numpy.ndarray, optional) -- 用于置空注意力模块中选定 head 的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩蔽
    • 0 表示 head 被掩蔽
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是纯元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPooling 或一个 torch.FloatTensor 元组 (如果在传递 return_dict=False 或当 config.return_dict=False 时),包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • last_hidden_state (形状为 (batch_size, sequence_length, hidden_size)jnp.ndarray) — 模型最后一层的输出处的隐藏状态序列。

  • pooler_output (形状为 (batch_size, hidden_size)jnp.ndarray) — 序列的第一个 token(分类 token)的最后一层隐藏状态,通过线性层和 Tanh 激活函数进一步处理。线性层权重在预训练期间从下一句预测(分类)目标中训练而来。

  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组(embedding 的输出一个,每层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

FlaxRobertaPreTrainedModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, FlaxRobertaForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = FlaxRobertaForMaskedLM.from_pretrained("FacebookAI/roberta-base")

>>> inputs = tokenizer("The capital of France is [MASK].", return_tensors="jax")

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

FlaxRobertaForSequenceClassification

class transformers.FlaxRobertaForSequenceClassification

< >

( config: RobertaConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

带有序列分类/回归头的 Roberta 模型 Transformer(池化输出顶部的线性层),例如用于 GLUE 任务。

此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None encoder_hidden_states = None encoder_attention_mask = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxSequenceClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray,形状为 (batch_size, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs?

  • attention_mask (numpy.ndarray,形状为 (batch_size, sequence_length)可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择:

    • 1 表示 tokens 未被 Mask
    • 0 表示 tokens 被 Mask

    什么是 attention masks?

  • token_type_ids (numpy.ndarray,形状为 (batch_size, sequence_length)可选) — Segment token 索引以指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择:

    • 0 对应于 sentence A token,
    • 1 对应于 sentence B token。

    什么是 token type IDs?

  • position_ids (numpy.ndarray,形状为 (batch_size, sequence_length)可选) — 每个输入序列 tokens 在 position embeddings 中的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (numpy.ndarray,形状为 (batch_size, sequence_length)optional) -- 用于 nullify selected heads of the attention modules 的 Mask。 Mask 值在 [0, 1]` 中选择:

    • 1 表示 head 未被 Mask
    • 0 表示 head 被 Mask
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通 tuple。

返回

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxSequenceClassifierOutput 或一个 torch.FloatTensor 的 tuple(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • logits (jnp.ndarray,形状为 (batch_size, config.num_labels)) — 分类(或回归,如果 config.num_labels==1)分数(在 SoftMax 之前)。

  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组(embedding 的输出一个,每层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

FlaxRobertaPreTrainedModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, FlaxRobertaForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = FlaxRobertaForSequenceClassification.from_pretrained("FacebookAI/roberta-base")

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

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

FlaxRobertaForMultipleChoice

class transformers.FlaxRobertaForMultipleChoice

< >

( config: RobertaConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

Roberta 模型,顶部带有一个多项选择分类头(池化输出顶部的线性层和一个 softmax),例如用于 RocStories/SWAG 任务。

此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None encoder_hidden_states = None encoder_attention_mask = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (numpy.ndarray,形状为 (batch_size, num_choices, sequence_length)) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs?

  • attention_mask (numpy.ndarray,形状为 (batch_size, num_choices, sequence_length)可选) — 用于避免在 padding token 索引上执行 attention 的 Mask。 Mask 值在 [0, 1] 中选择:

    • 1 表示 tokens 未被 Mask
    • 0 表示 tokens 被 Mask

    什么是 attention masks?

  • token_type_ids (numpy.ndarray,形状为 (batch_size, num_choices, sequence_length)可选) — Segment token 索引以指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择:

    • 0 对应于 sentence A token,
    • 1 对应于 sentence B token。

    什么是 token type IDs?

  • position_ids (numpy.ndarray,形状为 (batch_size, num_choices, sequence_length)可选) — 每个输入序列 tokens 在 position embeddings 中的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (numpy.ndarray,形状为 (batch_size, num_choices, sequence_length)optional) -- 用于 nullify selected heads of the attention modules 的 Mask。 Mask 值在 [0, 1]` 中选择:

    • 1 表示 head 未被 Mask
    • 0 表示 head 被 Mask
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是普通 tuple。

返回

transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutput 或一个 torch.FloatTensor 的 tuple(如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含各种元素,具体取决于配置 (RobertaConfig) 和输入。

  • logits (jnp.ndarray,形状为 (batch_size, num_choices)) — num_choices 是输入张量的第二个维度。(参见上面的 input_ids)。

    分类得分(在 SoftMax 之前)。

  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组(embedding 的输出一个,每层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

FlaxRobertaPreTrainedModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, FlaxRobertaForMultipleChoice

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = FlaxRobertaForMultipleChoice.from_pretrained("FacebookAI/roberta-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."

>>> encoding = tokenizer([prompt, prompt], [choice0, choice1], return_tensors="jax", padding=True)
>>> outputs = model(**{k: v[None, :] for k, v in encoding.items()})

>>> logits = outputs.logits

FlaxRobertaForTokenClassification

class transformers.FlaxRobertaForTokenClassification

< >

( config: RobertaConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

带有 token 分类头的 Roberta 模型(隐藏状态输出之上的线性层),例如,用于命名实体识别 (NER) 任务。

此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None encoder_hidden_states = None encoder_attention_mask = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxTokenClassifierOutputtuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, sequence_length)numpy.ndarray) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs?

  • attention_mask (形状为 (batch_size, sequence_length)numpy.ndarray, 可选) — 掩码,用于避免在 padding token 索引上执行 attention。 掩码值在 [0, 1] 中选择:

    • 1 表示 tokens 未被掩盖
    • 0 表示 tokens 被掩盖

    什么是 attention masks?

  • token_type_ids (形状为 (batch_size, sequence_length)numpy.ndarray, 可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择:

    • 0 对应于 sentence A token,
    • 1 对应于 sentence B token。

    什么是 token type IDs?

  • position_ids (形状为 (batch_size, sequence_length)numpy.ndarray, 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (形状为 (batch_size, sequence_length)numpy.ndarray, optional) -- 用于 nullify attention 模块中选定 head 的掩码。 掩码值在 [0, 1]` 中选择:

    • 1 表示 head 未被掩盖
    • 0 表示 head 被掩盖
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。

返回

transformers.modeling_flax_outputs.FlaxTokenClassifierOutputtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxTokenClassifierOutput 或一个 torch.FloatTensor 的 tuple (如果传递 return_dict=False 或当 config.return_dict=False 时),包括取决于配置 (RobertaConfig) 和输入的各种元素。

  • logits (形状为 (batch_size, sequence_length, config.num_labels)jnp.ndarray) — 分类得分(在 SoftMax 之前)。

  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组(embedding 的输出一个,每层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

FlaxRobertaPreTrainedModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, FlaxRobertaForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = FlaxRobertaForTokenClassification.from_pretrained("FacebookAI/roberta-base")

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

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

FlaxRobertaForQuestionAnswering

class transformers.FlaxRobertaForQuestionAnswering

< >

( config: RobertaConfig input_shape: Tuple = (1, 1) seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

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

带有 span 分类头的 Roberta 模型,用于抽取式问答任务,如 SQuAD(隐藏状态输出之上的线性层,用于计算 span start logitsspan end logits)。

此模型继承自 FlaxPreTrainedModel。 查看超类文档,了解库为所有模型实现的通用方法(例如,从 PyTorch 模型下载、保存和转换权重)

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen 模块,并参阅 Flax 文档,了解与常规用法和行为相关的所有事项。

最后,此模型支持固有的 JAX 功能,例如

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None encoder_hidden_states = None encoder_attention_mask = None params: dict = None dropout_rng: PRNGKey = None train: bool = False output_attentions: Optional = None output_hidden_states: Optional = None return_dict: Optional = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutputtuple(torch.FloatTensor)

参数

  • input_ids (形状为 (batch_size, sequence_length)numpy.ndarray) — 词汇表中输入序列 tokens 的索引。

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

    什么是输入 IDs?

  • attention_mask (形状为 (batch_size, sequence_length)numpy.ndarray, 可选) — 掩码,用于避免在 padding token 索引上执行 attention。 掩码值在 [0, 1] 中选择:

    • 1 表示 tokens 未被掩盖
    • 0 表示 tokens 被掩盖

    什么是 attention masks?

  • token_type_ids (形状为 (batch_size, sequence_length)numpy.ndarray, 可选) — 分段 token 索引,用于指示输入的第一部分和第二部分。 索引在 [0, 1] 中选择:

    • 0 对应于 sentence A token,
    • 1 对应于 sentence B token。

    什么是 token type IDs?

  • position_ids (形状为 (batch_size, sequence_length)numpy.ndarray, 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (形状为 (batch_size, sequence_length)numpy.ndarray, optional) -- 用于 nullify attention 模块中选定 head 的掩码。 掩码值在 [0, 1]` 中选择:

    • 1 表示 head 未被掩盖
    • 0 表示 head 被掩盖
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。

返回

transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutputtuple(torch.FloatTensor)

一个 transformers.modeling_flax_outputs.FlaxQuestionAnsweringModelOutput 或一个 torch.FloatTensor 的 tuple (如果传递 return_dict=False 或当 config.return_dict=False 时),包括取决于配置 (RobertaConfig) 和输入的各种元素。

  • start_logits (形状为 (batch_size, sequence_length)jnp.ndarray) — Span-start 得分(在 SoftMax 之前)。

  • end_logits (形状为 (batch_size, sequence_length)jnp.ndarray) — Span-end 得分(在 SoftMax 之前)。

  • hidden_states (tuple(jnp.ndarray), optional, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — jnp.ndarray 的元组(embedding 的输出一个,每层的输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出端的隐状态,加上初始嵌入输出。

  • attentions (tuple(jnp.ndarray), optional, 当传递 output_attentions=True 或当 config.output_attentions=True 时返回) — jnp.ndarray 的元组(每层一个),形状为 (batch_size, num_heads, sequence_length, sequence_length)

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

FlaxRobertaPreTrainedModel 的 forward 方法,覆盖了 __call__ 特殊方法。

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

示例

>>> from transformers import AutoTokenizer, FlaxRobertaForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("FacebookAI/roberta-base")
>>> model = FlaxRobertaForQuestionAnswering.from_pretrained("FacebookAI/roberta-base")

>>> question, text = "Who was Jim Henson?", "Jim Henson was a nice puppet"
>>> inputs = tokenizer(question, text, return_tensors="jax")

>>> outputs = model(**inputs)
>>> start_scores = outputs.start_logits
>>> end_scores = outputs.end_logits
< > Update on GitHub