Transformers 文档

BigBird

Hugging Face's logo
加入 Hugging Face 社区

并获得增强的文档体验

开始使用

BigBird

PyTorch Flax

概览

BigBird 模型在 Big Bird: Transformers for Longer Sequences 中被提出,作者是 Zaheer, Manzil 和 Guruganesh, Guru 和 Dubey, Kumar Avinava 和 Ainslie, Joshua 和 Alberti, Chris 和 Ontanon, Santiago 和 Pham, Philip 和 Ravula, Anirudh 和 Wang, Qifan 和 Yang, Li 以及其他人。BigBird 是一种基于稀疏注意力机制的 Transformer 模型,它扩展了基于 Transformer 的模型,例如 BERT,使其能够处理更长的序列。除了稀疏注意力,BigBird 还将全局注意力和随机注意力应用于输入序列。从理论上讲,已经证明,应用稀疏、全局和随机注意力可以近似于完全注意力,同时对于更长的序列而言,计算效率更高。由于能够处理更长的上下文,与 BERT 或 RoBERTa 相比,BigBird 在各种长文档 NLP 任务(例如问答和摘要)上都表现出改进的性能。

该论文的摘要如下:

基于 Transformer 的模型,例如 BERT,一直是 NLP 最成功的深度学习模型之一。不幸的是,它们的核心限制之一是由于其完全注意力机制,对序列长度的二次依赖性(主要是内存方面)。为了解决这个问题,我们提出了 BigBird,一种稀疏注意力机制,可以将这种二次依赖性降低到线性。我们证明 BigBird 是序列函数的通用逼近器,并且是图灵完备的,从而保留了二次完全注意力模型的这些特性。在此过程中,我们的理论分析揭示了拥有 O(1) 个全局令牌(例如 CLS)的一些好处,这些全局令牌作为稀疏注意力机制的一部分,关注整个序列。所提出的稀疏注意力可以处理长度高达先前使用类似硬件可能达到的 8 倍的序列。由于能够处理更长的上下文,BigBird 大大提高了各种 NLP 任务(例如问答和摘要)的性能。我们还提出了基因组数据的新颖应用。

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

使用技巧

  • 有关 BigBird 注意力机制如何工作的详细解释,请参阅 这篇博客文章
  • BigBird 带有 2 种实现:original_fullblock_sparse。 对于序列长度 < 1024,建议使用 original_full,因为使用 block_sparse 注意力没有任何好处。
  • 当前代码使用 3 个块的窗口大小和 2 个全局块。
  • 序列长度必须可被块大小整除。
  • 当前实现仅支持 ITC
  • 当前实现不支持 num_random_blocks = 0
  • BigBird 是一个带有绝对位置嵌入的模型,因此通常建议在右侧而不是左侧填充输入。

资源

BigBirdConfig

class transformers.BigBirdConfig

< >

( vocab_size = 50358 hidden_size = 768 num_hidden_layers = 12 num_attention_heads = 12 intermediate_size = 3072 hidden_act = 'gelu_new' hidden_dropout_prob = 0.1 attention_probs_dropout_prob = 0.1 max_position_embeddings = 4096 type_vocab_size = 2 initializer_range = 0.02 layer_norm_eps = 1e-12 use_cache = True pad_token_id = 0 bos_token_id = 1 eos_token_id = 2 sep_token_id = 66 attention_type = 'block_sparse' use_bias = True rescale_embeddings = False block_size = 64 num_random_blocks = 3 classifier_dropout = None **kwargs )

参数

  • vocab_size (int, 可选, 默认为 50358) — BigBird 模型的词汇表大小。 定义了在调用 BigBirdModel 时传递的 inputs_ids 可以表示的不同 token 的数量。
  • hidden_size (int, 可选, 默认为 768) — 编码器层和池化器层的维度。
  • num_hidden_layers (int, 可选, 默认为 12) — Transformer 编码器中隐藏层的数量。
  • num_attention_heads (int, 可选, 默认为 12) — Transformer 编码器中每个注意力层的注意力头的数量。
  • intermediate_size (int, 可选, 默认为 3072) — Transformer 编码器中“中间”(即,前馈)层的维度。
  • hidden_act (strfunction, 可选, 默认为 "gelu_new") — 编码器和池化器中的非线性激活函数(函数或字符串)。 如果是字符串,则支持 "gelu""relu""selu""gelu_new"
  • hidden_dropout_prob (float, 可选, 默认为 0.1) — 嵌入、编码器和池化器中所有全连接层的 dropout 概率。
  • attention_probs_dropout_prob (float, 可选, 默认为 0.1) — 注意力概率的 dropout 比率。
  • max_position_embeddings (int, 可选, 默认为 4096) — 此模型可能使用的最大序列长度。 通常将其设置为较大的值以防万一(例如,1024 或 2048 或 4096)。
  • type_vocab_size (int, 可选, 默认为 2) — 调用 BigBirdModel 时传递的 token_type_ids 的词汇表大小。
  • initializer_range (float, 可选, 默认为 0.02) — 用于初始化所有权重矩阵的 truncated_normal_initializer 的标准差。
  • layer_norm_eps (float, 可选, 默认为 1e-12) — layer normalization 层使用的 epsilon 值。
  • is_decoder (bool, 可选, 默认为 False) — 模型是否用作解码器。 如果为 False,则模型用作编码器。
  • use_cache (bool, 可选, 默认为 True) — 模型是否应返回上次的键/值注意力(并非所有模型都使用)。 仅在 config.is_decoder=True 时相关。
  • attention_type (str, 可选, 默认为 "block_sparse") — 是使用论文中介绍的块稀疏注意力(复杂度为 n)还是原始注意力层(复杂度为 n^2)。 可能的值为 "original_full""block_sparse"
  • use_bias (bool, 可选, 默认为 True) — 是否在 query、key、value 中使用 bias。
  • rescale_embeddings (bool, 可选, 默认为 False) — 是否使用 (hidden_size ** 0.5) 重新缩放 embeddings。
  • block_size (int, 可选, 默认为 64) — 每个块的大小。 仅当 attention_type == "block_sparse" 时有用。
  • num_random_blocks (int, 可选, 默认为 3) — 每个 query 将会关注这些数量的随机块。 仅当 attention_type == "block_sparse" 时有用。
  • classifier_dropout (float, 可选) — 分类头的 dropout 比率。

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

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

示例

>>> from transformers import BigBirdConfig, BigBirdModel

>>> # Initializing a BigBird google/bigbird-roberta-base style configuration
>>> configuration = BigBirdConfig()

>>> # Initializing a model (with random weights) from the google/bigbird-roberta-base style configuration
>>> model = BigBirdModel(configuration)

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

BigBirdTokenizer

class transformers.BigBirdTokenizer

< >

( vocab_file unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' sep_token = '[SEP]' mask_token = '[MASK]' cls_token = '[CLS]' sp_model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None **kwargs )

参数

  • vocab_file (str) — 包含实例化分词器所需的词汇表的 SentencePiece 文件(通常具有 .spm 扩展名)。
  • unk_token (str, 可选, 默认为 "<unk>") — 未知 token。词汇表中没有的 token 无法转换为 ID,而是设置为此 token。
  • bos_token (str, 可选, 默认为 "<s>") — 序列开始 token。
  • eos_token (str, 可选, 默认为 "</s>") — 序列结束 token。
  • pad_token (str, 可选, 默认为 "<pad>") — 用于填充的 token,例如在对不同长度的序列进行批处理时。
  • sep_token (str, 可选, 默认为 "[SEP]") — 分隔符 token,用于从多个序列构建序列时,例如用于序列分类的两个序列,或用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。
  • mask_token (str, 可选, 默认为 "[MASK]") — 用于掩码值的 token。这是在使用掩码语言建模训练此模型时使用的 token。这是模型将尝试预测的 token。
  • cls_token (str, 可选, 默认为 "[CLS]") — 分类器 token,用于进行序列分类(对整个序列而不是每个 token 进行分类)。当使用特殊 token 构建时,它是序列的第一个 token。
  • sp_model_kwargs (dict, 可选) — 将传递给 SentencePieceProcessor.__init__() 方法。SentencePiece 的 Python 封装器 可用于设置,其中包括:

    • enable_sampling: 启用子词正则化。

    • nbest_size: unigram 的采样参数。对 BPE-Dropout 无效。

      • nbest_size = {0,1}: 不执行采样。
      • nbest_size > 1: 从 nbest_size 结果中采样。
      • nbest_size < 0: 假设 nbest_size 是无限的,并使用前向过滤和后向采样算法从所有假设(lattice)中采样。
    • alpha: unigram 采样的平滑参数,以及 BPE-dropout 的合并操作的 dropout 概率。

构建 BigBird 分词器。基于 SentencePiece

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

build_inputs_with_special_tokens

< >

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

参数

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

返回

List[int]

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

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

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

get_special_tokens_mask

< >

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = 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) — token 列表是否已使用模型的特殊 token 格式化。

返回

List[int]

范围为 [0, 1] 的整数列表:1 代表特殊 token,0 代表序列 token。

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

create_token_type_ids_from_sequences

< >

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

参数

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

返回

List[int]

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

从传递的两个序列创建一个掩码,用于序列对分类任务。BERT 序列对掩码具有以下格式: :: 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 | 第一个序列 | 第二个序列 | 如果 token_ids_1None,则此方法仅返回掩码的第一部分(0)。

save_vocabulary

< >

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

BigBirdTokenizerFast

class transformers.BigBirdTokenizerFast

< >

( vocab_file = None tokenizer_file = None unk_token = '<unk>' bos_token = '<s>' eos_token = '</s>' pad_token = '<pad>' sep_token = '[SEP]' mask_token = '[MASK]' cls_token = '[CLS]' **kwargs )

参数

  • vocab_file (str) — 包含实例化分词器所需的词汇表的 SentencePiece 文件(通常具有 .spm 扩展名)。
  • bos_token (str, 可选, 默认为 "<s>") — 预训练期间使用的序列开始 token。可用作序列分类器 token。

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

  • eos_token (str, 可选, 默认为 "</s>") — 序列结束符 token。 .. note:: 当使用特殊 token 构建序列时,此 token 不是用于序列结尾的 token。 用于序列结尾的 token 是 sep_token
  • unk_token (str, 可选, 默认为 "<unk>") — 未知 token。词汇表中不存在的 token 无法转换为 ID,而是会被设置为此 token。
  • sep_token (str, 可选, 默认为 "[SEP]") — 分隔符 token,用于从多个序列构建序列时,例如,用于序列分类的两个序列,或者用于问答的文本和问题。它也用作使用特殊 token 构建的序列的最后一个 token。
  • pad_token (str, 可选, 默认为 "<pad>") — 用于填充的 token,例如在批量处理不同长度的序列时。
  • cls_token (str, 可选, 默认为 "[CLS]") — 分类器 token,用于进行序列分类(对整个序列而不是每个 token 进行分类)。当使用特殊 token 构建时,它是序列的第一个 token。
  • mask_token (str, 可选, 默认为 "[MASK]") — 用于遮盖值的 token。这是在使用掩码语言建模训练此模型时使用的 token。这是模型将尝试预测的 token。

构建一个“快速” BigBird tokenizer(由 HuggingFace 的 tokenizers 库支持)。基于 Unigram。此 tokenizer 继承自 PreTrainedTokenizerFast,其中包含大多数主要方法。用户应参考此超类以获取有关这些方法的更多信息

build_inputs_with_special_tokens

< >

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

参数

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

返回

List[int]

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

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

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

create_token_type_ids_from_sequences

< >

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

参数

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

返回

List[int]

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

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

序列对掩码具有以下格式

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

如果 token_ids_1 为 None,则仅返回掩码的第一部分(0)。

get_special_tokens_mask

< >

( token_ids_0: typing.List[int] token_ids_1: typing.Optional[typing.List[int]] = 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) — 如果 token 列表已使用模型的特殊 token 格式化,则设置为 True

返回

List[int]

范围为 [0, 1] 的整数列表:1 代表特殊 token,0 代表序列 token。

从没有添加特殊 token 的 token 列表中检索序列 ID。当使用 tokenizer prepare_for_model 方法添加特殊 token 时,将调用此方法。

BigBird 特定输出

class transformers.models.big_bird.modeling_big_bird.BigBirdForPreTrainingOutput

< >

( loss: typing.Optional[torch.FloatTensor] = None prediction_logits: FloatTensor = None seq_relationship_logits: FloatTensor = None hidden_states: typing.Optional[typing.Tuple[torch.FloatTensor]] = None attentions: typing.Optional[typing.Tuple[torch.FloatTensor]] = None )

参数

  • loss (可选, 当提供 labels 时返回, 形状为 (1,)torch.FloatTensor) — 总损失,作为掩码语言建模损失和下一句预测(分类)损失的总和。
  • prediction_logits (形状为 (batch_size, sequence_length, config.vocab_size)torch.FloatTensor) — 语言建模头的预测得分(SoftMax 之前每个词汇表 token 的得分)。
  • seq_relationship_logits (形状为 (batch_size, 2)torch.FloatTensor) — 下一句预测(分类)头的预测得分(SoftMax 之前 True/False 连续性的得分)。
  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=Trueconfig.output_hidden_states=True 时返回) — torch.FloatTensor 的元组(每个层的输出一个,加上嵌入的初始输出),形状为 (batch_size, sequence_length, hidden_size)

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

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

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

BigBirdForPreTraining 的输出类型。

Pytorch
隐藏 Pytorch 内容

BigBirdModel

class transformers.BigBirdModel

< >

( config add_pooling_layer = True )

参数

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

裸 BigBird 模型 Transformer 输出原始隐藏状态,顶部没有任何特定的 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: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentions or tuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs?

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

    • 1 代表 未被 Mask 的 tokens,
    • 0 代表 已被 Mask 的 tokens。

    什么是 attention masks?

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

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

    什么是 token type IDs?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列 tokens 的位置索引。 在范围 [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。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参阅返回的 tensors 下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参阅返回的 tensors 下的 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)可选) — 用于避免对编码器输入的 padding token 索引执行 attention 的 Mask。 如果模型配置为解码器,则此 mask 在交叉注意力中使用。 Mask 值在 [0, 1] 中选择:

    • 1 代表 未被 Mask 的 tokens,
    • 0 代表 已被 Mask 的 tokens。
  • past_key_values (tuple(tuple(torch.FloatTensor)),长度为 config.n_layers,其中每个元组有 4 个形状为 (batch_size, num_heads, sequence_length - 1, embed_size_per_head) 的 tensors) — 包含 attention blocks 的预先计算的 key 和 value 隐藏状态。 可用于加速解码。 如果使用 past_key_values,则用户可以选择仅输入形状为 (batch_size, 1) 的最后一个 decoder_input_ids(那些没有将其过去的 key value 状态提供给此模型的),而不是形状为 (batch_size, sequence_length) 的所有 decoder_input_ids
  • use_cache (bool可选) — 如果设置为 True,则返回 past_key_values key value 状态,并且可以用于加速解码(请参阅 past_key_values)。

返回

transformers.modeling_outputs.BaseModelOutputWithPoolingAndCrossAttentionstuple(torch.FloatTensor)

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

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

  • pooler_output (torch.FloatTensor,形状为 (batch_size, hidden_size)) — 序列的第一个 token(分类 token)的最后一层隐藏状态,在通过用于辅助预训练任务的层进一步处理之后。 例如,对于 BERT 系列模型,这将返回通过线性层和 tanh 激活函数处理后的分类 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)

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

  • past_key_values (tuple(tuple(torch.FloatTensor))可选,当传递 use_cache=True 或当 config.use_cache=True 时返回) — tuple(torch.FloatTensor) 的元组,长度为 config.n_layers,每个元组有 2 个形状为 (batch_size, num_heads, sequence_length, embed_size_per_head) 的 tensors,并且如果 config.is_encoder_decoder=True,则可选地还有 2 个形状为 (batch_size, num_heads, encoder_sequence_length, embed_size_per_head) 的 tensors。

    包含预先计算的隐藏状态(self-attention blocks 中的 key 和 values,以及如果 config.is_encoder_decoder=True,则可选地包含 cross-attention blocks 中的 key 和 values),这些状态可用于(请参阅 past_key_values 输入)加速顺序解码。

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

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

示例

>>> from transformers import AutoTokenizer, BigBirdModel
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = BigBirdModel.from_pretrained("google/bigbird-roberta-base")

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

>>> last_hidden_states = outputs.last_hidden_state

BigBirdForPreTraining

class transformers.BigBirdForPreTraining

< >

( config )

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.FloatTensor] = None next_sentence_label: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.big_bird.modeling_big_bird.BigBirdForPreTrainingOutput or tuple(torch.FloatTensor)

参数

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

    索引可以使用 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。

    什么是 token type IDs?

  • position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [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。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 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 loss 的标签。 索引应在 [-100, 0, ..., config.vocab_size] 中(请参阅 input_ids docstring) 索引设置为 -100 的 Token 将被忽略(masked),loss 仅针对标签在 [0, ..., config.vocab_size] 中的 token 计算
  • next_sentence_label (torch.LongTensor, 形状为 (batch_size,), 可选) — 用于计算下一个序列预测(分类)loss 的标签。 如果指定,nsp loss 将添加到 masked_lm loss。 输入应为序列对(请参阅 input_ids docstring) 索引应在 [0, 1] 中:

    • 0 表示序列 B 是序列 A 的延续,
    • 1 表示序列 B 是随机序列。
  • kwargs (Dict[str, any], 可选, 默认为 {}) — 用于隐藏已弃用的旧版参数。

返回

transformers.models.big_bird.modeling_big_bird.BigBirdForPreTrainingOutputtuple(torch.FloatTensor)

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

  • loss (可选, 当提供 labels 时返回, torch.FloatTensor, 形状为 (1,)) — 总 loss,为 masked language modeling loss 和下一个序列预测(分类)loss 的总和。

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

  • seq_relationship_logits (torch.FloatTensor, 形状为 (batch_size, 2)) — 下一个序列预测(分类)head 的预测分数(SoftMax 之前 True/False 延续的分数)。

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple(embeddings 输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, BigBirdForPreTraining
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = BigBirdForPreTraining.from_pretrained("google/bigbird-roberta-base")

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

>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.seq_relationship_logits

BigBirdForCausalLM

class transformers.BigBirdForCausalLM

< >

( config )

参数

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

BigBird 模型,顶部带有一个用于 CLM fine-tuning 的 language modeling head。 此模型是 PyTorch torch.nn.Module 子类。 将其用作常规 PyTorch 模块,并参考 PyTorch 文档以了解与常规用法和行为相关的所有事项。

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None past_key_values: typing.Optional[typing.Tuple[typing.Tuple[torch.FloatTensor]]] = None labels: typing.Optional[torch.LongTensor] = None use_cache: typing.Optional[bool] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None **kwargs ) transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(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。

    什么是 token type IDs?

  • position_ids (torch.LongTensor, 形状为 (batch_size, sequence_length), 可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [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。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool, 可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参见返回的 tensors 下的 attentions
  • output_hidden_states (bool, 可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回的 tensors 下的 hidden_states
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通 tuple。
  • encoder_hidden_states (torch.FloatTensor, 形状为 (batch_size, sequence_length, hidden_size), 可选) — 编码器最后一层输出的 hidden-states 序列。 如果模型配置为 decoder,则在 cross-attention 中使用。
  • encoder_attention_mask (torch.FloatTensor of shape (batch_size, sequence_length), optional) — 用于避免在编码器输入的 padding 标记索引上执行 attention 的掩码。如果模型配置为解码器,则此掩码在交叉 attention 中使用。掩码值在 [0, 1] 中选择:

    • 1 表示 未被掩码 的标记,
    • 0 表示 已被掩码 的标记。
  • past_key_values (tuple(tuple(torch.FloatTensor)) of length config.n_layers with each tuple having 4 tensors of shape (batch_size, num_heads, sequence_length - 1, embed_size_per_head)) — 包含 attention 模块的预计算的键和值隐藏状态。可用于加速解码。如果使用了 past_key_values,用户可以选择仅输入最后一部分 decoder_input_ids (那些没有将其过去的键值状态提供给此模型的),形状为 (batch_size, 1),而不是所有形状为 (batch_size, sequence_length)decoder_input_ids
  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算从左到右语言建模损失(下一个词预测)的标签。索引应在 [-100, 0, ..., config.vocab_size] 中(参见 input_ids 文档字符串)。索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。
  • use_cache (bool, optional) — 如果设置为 True,则返回 past_key_values 键值状态,并且可以用于加速解码(参见 past_key_values)。

返回

transformers.modeling_outputs.CausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

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

  • loss (torch.FloatTensor of shape (1,), optional, 在提供 labels 时返回) — 语言建模损失(用于下一个标记预测)。

  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(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)

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

    交叉 attention softmax 后的 attention 权重,用于计算交叉 attention 头中的加权平均值。

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

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

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

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

示例

>>> import torch
>>> from transformers import AutoTokenizer, BigBirdForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = BigBirdForCausalLM.from_pretrained("google/bigbird-roberta-base")

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

BigBirdForMaskedLM

class transformers.BigBirdForMaskedLM

< >

( config )

参数

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

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

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None encoder_hidden_states: typing.Optional[torch.FloatTensor] = None encoder_attention_mask: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.modeling_outputs.MaskedLMOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

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

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

    什么是 attention 掩码?

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

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

    什么是标记类型 IDs?

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

    什么是位置 IDs?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), optional) — 用于 nullify 自 attention 模块的选定头的掩码。掩码值在 [0, 1] 中选择:

    • 1 表示头 未被掩码
    • 0 表示头 已被掩码
  • inputs_embeds (torch.FloatTensor of shape (batch_size, sequence_length, hidden_size), optional) — 可选地,您可以选择直接传递嵌入表示,而不是传递 input_ids。 如果您希望比模型的内部嵌入查找矩阵更精细地控制如何将 input_ids 索引转换为关联的向量,这将非常有用。
  • output_attentions (bool, optional) — 是否返回所有 attention 层的 attention 张量。 有关更多详细信息,请参见返回的张量下的 attentions
  • output_hidden_states (bool, optional) — 是否返回所有层的隐藏状态。 有关更多详细信息,请参见返回的张量下的 hidden_states
  • return_dict (bool, optional) — 是否返回 ModelOutput 而不是纯元组。
  • labels (torch.LongTensor of shape (batch_size, sequence_length), optional) — 用于计算掩码语言建模损失的标签。 索引应在 [-100, 0, ..., config.vocab_size] 中(参见 input_ids 文档字符串)。 索引设置为 -100 的标记将被忽略(掩码),损失仅针对标签在 [0, ..., config.vocab_size] 中的标记计算。

返回

transformers.modeling_outputs.MaskedLMOutputtuple(torch.FloatTensor)

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

  • loss (torch.FloatTensor of shape (1,), optional, 在提供 labels 时返回) — 掩码语言建模 (MLM) 损失。

  • logits (torch.FloatTensor of shape (batch_size, sequence_length, config.vocab_size)) — 语言建模头的预测分数(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)

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> import torch
>>> from transformers import AutoTokenizer, BigBirdForMaskedLM
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = BigBirdForMaskedLM.from_pretrained("google/bigbird-roberta-base")
>>> squad_ds = load_dataset("rajpurkar/squad_v2", split="train")
>>> # select random long article
>>> LONG_ARTICLE_TARGET = squad_ds[81514]["context"]
>>> # select random sentence
>>> LONG_ARTICLE_TARGET[332:398]
'the highest values are very close to the theoretical maximum value'

>>> # add mask_token
>>> LONG_ARTICLE_TO_MASK = LONG_ARTICLE_TARGET.replace("maximum", "[MASK]")
>>> inputs = tokenizer(LONG_ARTICLE_TO_MASK, return_tensors="pt")
>>> # long article input
>>> list(inputs["input_ids"].shape)
[1, 919]

>>> 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)
'maximum'
>>> labels = tokenizer(LONG_ARTICLE_TARGET, return_tensors="pt")["input_ids"]
>>> labels = torch.where(inputs.input_ids == tokenizer.mask_token_id, labels, -100)
>>> outputs = model(**inputs, labels=labels)
>>> round(outputs.loss.item(), 2)
1.99

BigBirdForSequenceClassification

class transformers.BigBirdForSequenceClassification

< >

( config )

参数

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

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

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

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = 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)可选) — 掩码,用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择:

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

    什么是注意力掩码?

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

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

    什么是 token 类型 IDs?

  • position_ids (torch.LongTensor,形状为 (batch_size, sequence_length)可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [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可选) — 是否返回所有 attention 层的 attentions tensors。 有关更多详细信息,请参见返回的 tensors 下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的 hidden states。 有关更多详细信息,请参见返回的 tensors 下的 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 时),包含各种元素,具体取决于配置 (BigBirdConfig) 和输入。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> import torch
>>> from transformers import AutoTokenizer, BigBirdForSequenceClassification
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("l-yohai/bigbird-roberta-base-mnli")
>>> model = BigBirdForSequenceClassification.from_pretrained("l-yohai/bigbird-roberta-base-mnli")
>>> squad_ds = load_dataset("rajpurkar/squad_v2", split="train")
>>> LONG_ARTICLE = squad_ds[81514]["context"]
>>> inputs = tokenizer(LONG_ARTICLE, return_tensors="pt")
>>> # long input article
>>> list(inputs["input_ids"].shape)
[1, 919]

>>> with torch.no_grad():
...     logits = model(**inputs).logits
>>> predicted_class_id = logits.argmax().item()
>>> model.config.id2label[predicted_class_id]
'LABEL_0'
>>> num_labels = len(model.config.id2label)
>>> model = BigBirdForSequenceClassification.from_pretrained(
...     "l-yohai/bigbird-roberta-base-mnli", num_labels=num_labels
... )
>>> labels = torch.tensor(1)
>>> loss = model(**inputs, labels=labels).loss
>>> round(loss.item(), 2)
1.13

BigBirdForMultipleChoice

class transformers.BigBirdForMultipleChoice

< >

( config )

参数

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

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

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

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = 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)可选) — 掩码,用于避免在 padding token 索引上执行 attention。掩码值在 [0, 1] 中选择:

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

    什么是注意力掩码?

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

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

    什么是 token 类型 IDs?

  • position_ids (torch.LongTensor,形状为 (batch_size, num_choices, sequence_length)可选) — 位置嵌入中每个输入序列 token 的位置索引。 在范围 [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可选) — 是否返回所有注意力层的注意力张量。有关更多详细信息,请参阅返回张量下的 attentions
  • output_hidden_states (bool可选) — 是否返回所有层的隐藏状态。有关更多详细信息,请参阅返回张量下的 hidden_states
  • return_dict (bool可选) — 是否返回 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 时),其中包含各种元素,具体取决于配置 (BigBirdConfig) 和输入。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, BigBirdForMultipleChoice
>>> import torch

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

BigBirdForTokenClassification

class transformers.BigBirdForTokenClassification

< >

( config )

参数

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

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

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

forward

< >

( input_ids: LongTensor = None attention_mask: typing.Optional[torch.FloatTensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None labels: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = 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)可选) — 用于避免在 padding token 索引上执行注意力的掩码。掩码值选自 [0, 1]

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

    什么是注意力掩码?

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

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

    什么是 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)可选) — 用于置空自注意力模块中选定 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 而不是普通元组。
  • 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 时),其中包含各种元素,具体取决于配置 (BigBirdConfig) 和输入。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, BigBirdForTokenClassification
>>> import torch

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = BigBirdForTokenClassification.from_pretrained("google/bigbird-roberta-base")

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

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

>>> predicted_token_class_ids = logits.argmax(-1)

>>> # Note that tokens are classified rather then input words which means that
>>> # there might be more predicted token classes than words.
>>> # Multiple token classes might account for the same word
>>> predicted_tokens_classes = [model.config.id2label[t.item()] for t in predicted_token_class_ids[0]]

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

BigBirdForQuestionAnswering

class transformers.BigBirdForQuestionAnswering

< >

( config add_pooling_layer = False )

参数

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

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

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

forward

< >

( input_ids: typing.Optional[torch.LongTensor] = None attention_mask: typing.Optional[torch.FloatTensor] = None question_lengths: typing.Optional[torch.Tensor] = None token_type_ids: typing.Optional[torch.LongTensor] = None position_ids: typing.Optional[torch.LongTensor] = None head_mask: typing.Optional[torch.FloatTensor] = None inputs_embeds: typing.Optional[torch.FloatTensor] = None start_positions: typing.Optional[torch.LongTensor] = None end_positions: typing.Optional[torch.LongTensor] = None output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.big_bird.modeling_big_bird.BigBirdForQuestionAnsweringModelOutput or tuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

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

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

    什么是 attention 掩码?

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

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

    什么是 token 类型 IDs?

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

    什么是位置 IDs?

  • head_mask (torch.FloatTensor of shape (num_heads,) or (num_layers, num_heads), 可选) — 用于使 self-attention 模块的选定 head 无效的掩码。 掩码值在 [0, 1] 中选择:

    • 1 表示 head 未被掩盖
    • 0 表示 head 被掩盖
  • inputs_embeds (torch.FloatTensor of shape (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 of shape (batch_size,), 可选) — 用于计算 token 分类损失的标记跨度开始位置(索引)的标签。 位置被钳制到序列的长度 (sequence_length)。 序列之外的位置不计入损失计算。
  • end_positions (torch.LongTensor of shape (batch_size,), 可选) — 用于计算 token 分类损失的标记跨度结束位置(索引)的标签。 位置被钳制到序列的长度 (sequence_length)。 序列之外的位置不计入损失计算。

返回

transformers.models.big_bird.modeling_big_bird.BigBirdForQuestionAnsweringModelOutputtuple(torch.FloatTensor)

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

  • loss (torch.FloatTensor of shape (1,), 可选,当提供 labels 时返回) — 总跨度提取损失是 start 和 end 位置的交叉熵之和。

  • start_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度开始分数(在 SoftMax 之前)。

  • end_logits (torch.FloatTensor of shape (batch_size, sequence_length)) — 跨度结束分数(在 SoftMax 之前)。

  • pooler_output (torch.FloatTensor of shape (batch_size, 1)) — 来自 BigBigModel 的 pooler 输出

  • hidden_states (tuple(torch.FloatTensor), 可选, 当传递 output_hidden_states=True 或当 config.output_hidden_states=True 时返回) — torch.FloatTensor 的 Tuple(embeddings 输出一个,每层输出一个),形状为 (batch_size, sequence_length, hidden_size)

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> import torch
>>> from transformers import AutoTokenizer, BigBirdForQuestionAnswering
>>> from datasets import load_dataset

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = BigBirdForQuestionAnswering.from_pretrained("google/bigbird-roberta-base")
>>> squad_ds = load_dataset("rajpurkar/squad_v2", split="train")
>>> # select random article and question
>>> LONG_ARTICLE = squad_ds[81514]["context"]
>>> QUESTION = squad_ds[81514]["question"]
>>> QUESTION
'During daytime how high can the temperatures reach?'

>>> inputs = tokenizer(QUESTION, LONG_ARTICLE, return_tensors="pt")
>>> # long article and question input
>>> list(inputs["input_ids"].shape)
[1, 929]

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

>>> answer_start_index = outputs.start_logits.argmax()
>>> answer_end_index = outputs.end_logits.argmax()
>>> predict_answer_token_ids = inputs.input_ids[0, answer_start_index : answer_end_index + 1]
>>> predict_answer_token = tokenizer.decode(predict_answer_token_ids)
>>> target_start_index, target_end_index = torch.tensor([130]), torch.tensor([132])
>>> outputs = model(**inputs, start_positions=target_start_index, end_positions=target_end_index)
>>> loss = outputs.loss
JAX
隐藏 JAX 内容

FlaxBigBirdModel

class transformers.FlaxBigBirdModel

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (BigBirdConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
  • dtype (jax.numpy.dtype, 可选,默认为 jax.numpy.float32) — 计算的数据类型。 可以是 jax.numpy.float32jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,则所有计算将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

裸 BigBird 模型 Transformer,输出原始 hidden-states,顶部没有任何特定的 head。

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

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module,并参考 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: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

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

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

    什么是 attention 掩码?

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

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

    什么是 token 类型 IDs?

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

    • 1 表示 head 未被掩蔽
    • 0 表示 head 已被掩蔽
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.modeling_flax_outputs.FlaxBaseModelOutputWithPoolingtuple(torch.FloatTensor)

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

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

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

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdModel

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = FlaxBigBirdModel.from_pretrained("google/bigbird-roberta-base")

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

>>> last_hidden_states = outputs.last_hidden_state

FlaxBigBirdForPreTraining

class transformers.FlaxBigBirdForPreTraining

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (BigBirdConfig) — 模型配置类,包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算的数据类型。 可以是 jax.numpy.float32, jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,所有计算都将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

BigBird 模型,顶部带有两个 head,如预训练期间所做的那样:一个 masked language modeling head 和一个 next sentence prediction (classification) head (掩码语言建模 head 和下一句预测 (分类) head)。

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

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module,并参考 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: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None past_key_values: dict = None ) transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForPreTrainingOutputtuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs?

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

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

    什么是 attention masks?

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

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

    什么是 token type IDs?

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

    • 1 表示 head 未被掩蔽
    • 0 表示 head 已被掩蔽
  • return_dict (bool, 可选) — 是否返回 ModelOutput 而不是普通的元组。

返回

transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForPreTrainingOutputtuple(torch.FloatTensor)

一个 transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForPreTrainingOutput 或一个 torch.FloatTensor 的元组 (如果传递了 return_dict=False 或当 config.return_dict=False 时),其中包含取决于配置 (BigBirdConfig) 和输入的各种元素。

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

  • seq_relationship_logits (jnp.ndarray,形状为 (batch_size, 2)) — 下一句预测 (分类) head 的预测得分 (SoftMax 之前 True/False 延续的得分)。

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdForPreTraining

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = FlaxBigBirdForPreTraining.from_pretrained("google/bigbird-roberta-base")

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

>>> prediction_logits = outputs.prediction_logits
>>> seq_relationship_logits = outputs.seq_relationship_logits

FlaxBigBirdForCausalLM

class transformers.FlaxBigBirdForCausalLM

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (BigBirdConfig) — 模型配置类,包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法来加载模型权重。
  • dtype (jax.numpy.dtype, 可选, 默认为 jax.numpy.float32) — 计算的数据类型。 可以是 jax.numpy.float32jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,所有计算都将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

BigBird 模型,顶部带有一个语言建模 head (隐藏状态输出顶部的线性层),例如用于自回归任务。

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

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module,并参考 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: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

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

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

    什么是 attention 掩码?

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

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

    什么是 token 类型 IDs?

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

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

返回

transformers.modeling_flax_outputs.FlaxCausalLMOutputWithCrossAttentionstuple(torch.FloatTensor)

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

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

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

    交叉 attention softmax 后的 attention 权重,用于计算交叉 attention 头中的加权平均值。

  • past_key_values (tuple(tuple(jnp.ndarray)), optional, 当传递了 use_cache=True 或当 config.use_cache=True 时返回) — 长度为 config.n_layersjnp.ndarray tuples 的 tuple,每个 tuple 包含 self-attention 和 cross-attention 层的缓存 key、value 状态(如果模型用于 encoder-decoder 设置)。 仅当 config.is_decoder = True 时相关。

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

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdForCausalLM

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = FlaxBigBirdForCausalLM.from_pretrained("google/bigbird-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]

FlaxBigBirdForMaskedLM

class transformers.FlaxBigBirdForMaskedLM

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (BigBirdConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
  • dtype (jax.numpy.dtype, optional, 默认为 jax.numpy.float32) — 计算的数据类型。 可以是 jax.numpy.float32jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,所有计算都将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

带有 language modeling head 的 BigBird 模型。

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

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module,并参考 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: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxMaskedLMOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

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

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

    什么是 attention 掩码?

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

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

    什么是 token 类型 IDs?

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

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

返回

transformers.modeling_flax_outputs.FlaxMaskedLMOutputtuple(torch.FloatTensor)

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

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

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdForMaskedLM

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = FlaxBigBirdForMaskedLM.from_pretrained("google/bigbird-roberta-base")

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

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

FlaxBigBirdForSequenceClassification

class transformers.FlaxBigBirdForSequenceClassification

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (BigBirdConfig) — 带有模型所有参数的模型配置类。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
  • dtype (jax.numpy.dtype, optional, 默认为 jax.numpy.float32) — 计算的数据类型。 可以是 jax.numpy.float32jax.numpy.float16 (在 GPU 上) 和 jax.numpy.bfloat16 (在 TPU 上) 之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,所有计算都将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

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

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

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module,并参考 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: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxSequenceClassifierOutputtuple(torch.FloatTensor)

参数

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

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

    什么是输入 IDs?

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

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

    什么是 attention 掩码?

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

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

    什么是 token type IDs?

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

    • 1 表示 head 未被掩盖
    • 0 表示 head 已被掩盖
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是纯元组。

返回

transformers.modeling_flax_outputs.FlaxSequenceClassifierOutputtuple(torch.FloatTensor)

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

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

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdForSequenceClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = FlaxBigBirdForSequenceClassification.from_pretrained("google/bigbird-roberta-base")

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

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

FlaxBigBirdForMultipleChoice

class transformers.FlaxBigBirdForMultipleChoice

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True **kwargs )

参数

  • config (BigBirdConfig) — 模型配置类,包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
  • dtype (jax.numpy.dtype可选,默认为 jax.numpy.float32) — 计算的数据类型。 可以是 jax.numpy.float32jax.numpy.float16(在 GPU 上)和 jax.numpy.bfloat16(在 TPU 上)之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,则所有计算将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

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

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

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module,并参考 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: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutputtuple(torch.FloatTensor)

参数

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

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

    什么是 input IDs?

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

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

    什么是 attention 掩码?

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

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

    什么是 token type IDs?

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

    • 1 表示 head 未被掩盖
    • 0 表示 head 已被掩盖
  • return_dict (bool可选) — 是否返回 ModelOutput 而不是纯元组。

返回

transformers.modeling_flax_outputs.FlaxMultipleChoiceModelOutputtuple(torch.FloatTensor)

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

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

    分类得分(在 SoftMax 之前)。

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdForMultipleChoice

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

FlaxBigBirdForTokenClassification

class transformers.FlaxBigBirdForTokenClassification

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (BigBirdConfig) — 模型配置类,包含模型的所有参数。 使用配置文件初始化不会加载与模型关联的权重,仅加载配置。 查看 from_pretrained() 方法以加载模型权重。
  • dtype (jax.numpy.dtype可选,默认为 jax.numpy.float32) — 计算的数据类型。 可以是 jax.numpy.float32jax.numpy.float16(在 GPU 上)和 jax.numpy.bfloat16(在 TPU 上)之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。 如果指定,则所有计算将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

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

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

此模型也是 flax.linen.Module 子类。 将其用作常规 Flax linen Module,并参考 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: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None past_key_values: dict = None ) transformers.modeling_flax_outputs.FlaxTokenClassifierOutputtuple(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 的掩码。掩码值在 [0, 1] 中选择:

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

    什么是 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)可选) — 每个输入序列 token 在 position embeddings 中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (numpy.ndarray,形状为 (batch_size, sequence_length)optional) -- 用于 nullify attention 模块中选定 heads 的掩码。掩码值在 [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 时),包含各种元素,具体取决于配置 (BigBirdConfig) 和输入。

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

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdForTokenClassification

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = FlaxBigBirdForTokenClassification.from_pretrained("google/bigbird-roberta-base")

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

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

FlaxBigBirdForQuestionAnswering

class transformers.FlaxBigBirdForQuestionAnswering

< >

( config: BigBirdConfig input_shape: typing.Optional[tuple] = None seed: int = 0 dtype: dtype = <class 'jax.numpy.float32'> _do_init: bool = True gradient_checkpointing: bool = False **kwargs )

参数

  • config (BigBirdConfig) — 带有模型所有参数的模型配置类。使用配置文件初始化不会加载与模型关联的权重,仅加载配置。查看 from_pretrained() 方法以加载模型权重。
  • dtype (jax.numpy.dtype可选,默认为 jax.numpy.float32) — 计算的数据类型。可以是 jax.numpy.float32jax.numpy.float16(在 GPU 上)和 jax.numpy.bfloat16(在 TPU 上)之一。

    这可以用于在 GPU 或 TPU 上启用混合精度训练或半精度推理。如果指定,则所有计算将使用给定的 dtype 执行。

    请注意,这仅指定计算的 dtype,不影响模型参数的 dtype。

    如果您希望更改模型参数的 dtype,请参阅 to_fp16()to_bf16()

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

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

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

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

__call__

< >

( input_ids attention_mask = None token_type_ids = None position_ids = None head_mask = None question_lengths = None params: dict = None dropout_rng: typing.Optional[PRNGKey] = None indices_rng: typing.Optional[PRNGKey] = None train: bool = False output_attentions: typing.Optional[bool] = None output_hidden_states: typing.Optional[bool] = None return_dict: typing.Optional[bool] = None ) transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForQuestionAnsweringModelOutputtuple(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 的掩码。掩码值在 [0, 1] 中选择:

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

    什么是 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)可选) — 每个输入序列 token 在 position embeddings 中的位置索引。在范围 [0, config.max_position_embeddings - 1] 中选择。
  • head_mask (numpy.ndarray,形状为 (batch_size, sequence_length)optional) -- 用于 nullify attention 模块中选定 heads 的掩码。掩码值在 [0, 1] 中选择:

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

返回

transformers.models.big_bird.modeling_flax_big_bird.FlaxBigBirdForQuestionAnsweringModelOutputtuple(torch.FloatTensor)

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

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

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

  • pooled_output (jnp.ndarray,形状为 (batch_size, hidden_size)) — 由 FlaxBigBirdModel 返回的 pooled_output。

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

    模型在每一层输出以及初始 embedding 输出的 Hidden-states。

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

    attention softmax 之后的 Attention 权重,用于计算 self-attention heads 中的加权平均值。

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

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

示例

>>> from transformers import AutoTokenizer, FlaxBigBirdForQuestionAnswering

>>> tokenizer = AutoTokenizer.from_pretrained("google/bigbird-roberta-base")
>>> model = FlaxBigBirdForQuestionAnswering.from_pretrained("google/bigbird-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
< > 在 GitHub 上更新